@loadstrike/loadstrike-sdk 1.0.30201 → 1.0.30401

package/dist/esm/cluster.js

@@ -1,5 +1,11 @@
-import { randomUUID } from "node:crypto";
+import { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
+import { cpus } from "node:os";
 import { EndpointAdapterFactory } from "./transports.js";
+import { parseLoadEngineV2HistogramArtifact, serializeLoadEngineV2HistogramArtifact } from "./load-engine-v2.js";
+const EMPTY_LOAD_ENGINE_V2_HISTOGRAM_ARTIFACT_BASE64 = serializeLoadEngineV2HistogramArtifact({
+    distributions: [],
+    measurementSummaries: []
+}).toString("base64");
 export class LocalClusterCoordinator {
     /**
      * Exposes the public constructor operation.
@@ -120,6 +126,1444 @@ export function planAgentScenarioAssignments(scenarioNames, agentCount, options
     }
     return assignments;
 }
+export const LOAD_ENGINE_V2_CLUSTER_CAPABILITIES = Object.freeze({
+    schedulerVersions: ["2"],
+    histogramVersions: ["1"],
+    shardingVersions: ["1"],
+    resultChunkVersions: ["1"],
+    iterationObservationSchemas: ["loadstrike.iteration-observation/1"],
+    // Distributed correlation is negotiated only when the runtime has a shared
+    // correlation implementation. An empty list is deliberately fail-closed.
+    correlationSetVersions: [],
+    planHashVersions: ["LS-SP1"],
+    callbackExecutionModes: ["async"],
+    maximumResultChunkBytes: 256 * 1024
+});
+const loadEngineV2ProcessInstanceId = randomBytes(32).toString("hex");
+const LOAD_ENGINE_V2_MAX_RESULT_BYTES = 64 * 1024 * 1024;
+const LOAD_ENGINE_V2_DEFAULT_CHUNK_BYTES = 128 * 1024;
+export function createLoadEngineV2Registration(input) {
+    validateBoundedV2Identifier(input.runId, "run ID", 128);
+    validateBoundedV2Identifier(input.sessionId, "session ID", 128);
+    validateBoundedV2Identifier(input.coordinatorNonce, "coordinator nonce", 128);
+    validateLoadEngineV2AgentId(input.agentId);
+    if (input.targetSubject !== buildLoadEngineV2ScopedTargetSubject(input.runId, input.sessionId, input.coordinatorNonce, input.agentId)) {
+        throw new Error("Load Engine V2 registration targeted subject is outside the run/session/nonce scope.");
+    }
+    const processInstanceId = input.processInstanceId ?? loadEngineV2ProcessInstanceId;
+    validateLowercaseHash(processInstanceId, "process instance id");
+    const registrationSequence = parseCanonicalNonNegativeInt64(input.registrationSequence64, "registration sequence");
+    const leaseIssued = parseCanonicalNonNegativeInt64(input.leaseIssuedUtcNs64, "registration lease issue");
+    const leaseExpires = parseCanonicalNonNegativeInt64(input.leaseExpiresUtcNs64, "registration lease expiry");
+    if (leaseExpires <= leaseIssued || leaseExpires - leaseIssued > 30000000000n) {
+        throw new Error("Load Engine V2 registration lease must be positive and no longer than 30 seconds.");
+    }
+    void registrationSequence;
+    const schedulerVisibleProcessorCount = input.schedulerVisibleProcessorCount ?? Math.max(cpus().length, 1);
+    if (!Number.isSafeInteger(schedulerVisibleProcessorCount) || schedulerVisibleProcessorCount <= 0) {
+        throw new Error("Load Engine V2 registration scheduler-visible processor count is invalid.");
+    }
+    const sdkLanguage = input.sdkLanguage ?? "typescript";
+    const sdkPackageVersion = input.sdkPackageVersion ?? process.env.npm_package_version ?? "0.0.0";
+    const runtimeVersion = input.runtimeVersion ?? process.version;
+    validateBoundedV2Identifier(sdkLanguage, "SDK language", 128);
+    validateBoundedV2Identifier(sdkPackageVersion, "SDK package version", 128);
+    validateBoundedV2Identifier(runtimeVersion, "runtime version", 128);
+    const selected = { ...LOAD_ENGINE_V2_CLUSTER_CAPABILITIES, ...(input.capabilities ?? {}) };
+    const registration = {
+        runId: input.runId,
+        sessionId: input.sessionId,
+        coordinatorNonce: input.coordinatorNonce,
+        agentId: input.agentId,
+        targetSubject: input.targetSubject,
+        processInstanceId,
+        schedulerVisibleProcessorCount,
+        sdkLanguage,
+        sdkPackageVersion,
+        runtimeVersion,
+        registrationSequence64: input.registrationSequence64,
+        leaseIssuedUtcNs64: input.leaseIssuedUtcNs64,
+        leaseExpiresUtcNs64: input.leaseExpiresUtcNs64,
+        schedulerVersions: canonicalV2CapabilityList(selected.schedulerVersions, "scheduler versions"),
+        histogramVersions: canonicalV2CapabilityList(selected.histogramVersions, "histogram versions"),
+        shardingVersions: canonicalV2CapabilityList(selected.shardingVersions, "sharding versions"),
+        resultChunkVersions: canonicalV2CapabilityList(selected.resultChunkVersions, "result chunk versions"),
+        iterationObservationSchemas: canonicalV2CapabilityList(selected.iterationObservationSchemas, "iteration observation schemas"),
+        correlationSetVersions: canonicalV2CapabilityList(selected.correlationSetVersions, "correlation versions"),
+        planHashVersions: canonicalV2CapabilityList(selected.planHashVersions, "plan hash versions"),
+        callbackExecutionModes: canonicalV2CallbackModes(selected.callbackExecutionModes),
+        maximumResultChunkBytes: selected.maximumResultChunkBytes,
+        registrationBindingHash: ""
+    };
+    if (!Number.isSafeInteger(registration.maximumResultChunkBytes)
+        || registration.maximumResultChunkBytes < 16 * 1024
+        || registration.maximumResultChunkBytes > 256 * 1024) {
+        throw new Error("Load Engine V2 registration result chunk bound must be 16384..262144 bytes.");
+    }
+    registration.registrationBindingHash = buildLoadEngineV2RegistrationBindingHash(registration);
+    return registration;
+}
+export function negotiateLoadEngineV2Registrations(runId, sessionId, coordinatorNonce, expectedAgentIds, registrations, nowUtcNs64) {
+    const expected = normalizeExpectedAgentIds(expectedAgentIds);
+    const now = parseCanonicalInt64(nowUtcNs64, "coordinator UTC nanoseconds");
+    if (registrations.length !== expected.length) {
+        throw new Error("Load Engine V2 capability negotiation requires the exact expected participant set.");
+    }
+    const actual = [...registrations].sort((left, right) => compareAgentIds(left.agentId, right.agentId));
+    if (new Set(actual.map((value) => value.agentId)).size !== actual.length
+        || actual.some((value, index) => value.agentId !== expected[index])) {
+        throw new Error("Load Engine V2 capability negotiation did not receive the exact expected participant set.");
+    }
+    for (const registration of actual) {
+        validateLoadEngineV2AgentId(registration.agentId);
+        if (registration.runId !== runId || registration.sessionId !== sessionId
+            || registration.coordinatorNonce !== coordinatorNonce
+            || registration.targetSubject !== buildLoadEngineV2ScopedTargetSubject(runId, sessionId, coordinatorNonce, registration.agentId)) {
+            throw new Error("Load Engine V2 registration does not match the coordinator run/session/nonce scope.");
+        }
+        validateLowercaseHash(registration.processInstanceId, "process instance id");
+        const issued = parseCanonicalNonNegativeInt64(registration.leaseIssuedUtcNs64, "registration lease issue");
+        const expires = parseCanonicalNonNegativeInt64(registration.leaseExpiresUtcNs64, "registration lease expiry");
+        parseCanonicalNonNegativeInt64(registration.registrationSequence64, "registration sequence");
+        if (issued > now || expires <= now || expires <= issued || expires - issued > 30000000000n) {
+            throw new Error("Load Engine V2 registration lease expired before commit.");
+        }
+        if (!hashEquals(buildLoadEngineV2RegistrationBindingHash({ ...registration, registrationBindingHash: "" }), registration.registrationBindingHash))
+            throw new Error("Load Engine V2 registration binding hash is invalid.");
+        requireCapability(registration.schedulerVersions, "2", "scheduler-v2");
+        requireCapability(registration.histogramVersions, "1", "histogram-v1");
+        requireCapability(registration.shardingVersions, "1", "global-sharding-v1");
+        requireCapability(registration.resultChunkVersions, "1", "result-chunks-v1");
+        requireCapability(registration.iterationObservationSchemas, "loadstrike.iteration-observation/1", "loadstrike.iteration-observation/1");
+        requireCapability(registration.planHashVersions, "LS-SP1", "canonical LS-SP1 plan hash");
+    }
+    return actual;
+}
+export function buildLoadEngineV2ScopedRegistrationSubject(runId, sessionId, coordinatorNonce) {
+    [runId, sessionId, coordinatorNonce].forEach((value, index) => validateBoundedV2Identifier(value, ["run ID", "session ID", "coordinator nonce"][index], 128));
+    const bytes = Buffer.concat([
+        Buffer.from("LS-RS1\n", "ascii"), frameUtf8("1"), frameUtf8(runId), frameUtf8(sessionId),
+        frameUtf8(coordinatorNonce)
+    ]);
+    return `loadstrike.v2.${sha256Hex(bytes)}.register`;
+}
+export function buildLoadEngineV2ScopedTargetSubject(runId, sessionId, coordinatorNonce, agentId) {
+    validateBoundedV2Identifier(runId, "run ID", 128);
+    validateBoundedV2Identifier(sessionId, "session ID", 128);
+    validateBoundedV2Identifier(coordinatorNonce, "coordinator nonce", 128);
+    validateLoadEngineV2AgentId(agentId);
+    const bytes = Buffer.concat([
+        Buffer.from("LS-TS1\n", "ascii"), frameUtf8("1"), frameUtf8(runId), frameUtf8(sessionId),
+        frameUtf8(coordinatorNonce), frameUtf8(agentId)
+    ]);
+    return `loadstrike.v2.target.${sha256Hex(bytes)}`;
+}
+export function buildLoadEngineV2GlobalInvocationId(runId, scenarioIndex, simulationIndex, identityKind, primaryOrdinal, secondaryOrdinal) {
+    validateBoundedV2Identifier(runId, "run ID", 128);
+    const scenario = parseCanonicalNonNegativeInt64(String(scenarioIndex), "scenario index");
+    const simulation = parseCanonicalNonNegativeInt64(String(simulationIndex), "simulation index");
+    const primary = parseCanonicalNonNegativeInt64(String(primaryOrdinal), "primary ordinal");
+    const secondary = parseCanonicalNonNegativeInt64(String(secondaryOrdinal), "secondary ordinal");
+    if (!["arrival", "worker-iteration", "constant-iteration"].includes(identityKind)) {
+        throw new Error("Load Engine V2 invocation identity kind is invalid.");
+    }
+    return sha256Hex(Buffer.concat([
+        Buffer.from("LS-I1\n", "ascii"),
+        frameUtf8(runId),
+        frameUtf8(scenario.toString()),
+        frameUtf8(simulation.toString()),
+        frameUtf8(identityKind),
+        frameUtf8(primary.toString()),
+        frameUtf8(secondary.toString())
+    ]));
+}
+export function createLoadEngineV2CoordinatorHello(input) {
+    const expectedAgentIds = normalizeExpectedAgentIds(input.expectedAgentIds);
+    if (input.registrationSubject !== buildLoadEngineV2ScopedRegistrationSubject(input.runId, input.sessionId, input.coordinatorNonce))
+        throw new Error("Load Engine V2 coordinator hello registration subject is invalid.");
+    parseCanonicalNonNegativeInt64(input.expiresUtcNs64, "coordinator hello expiry");
+    const hello = { ...input, expectedAgentIds, bindingHash: "" };
+    hello.bindingHash = buildLoadEngineV2CoordinatorHelloBindingHash(hello);
+    return hello;
+}
+export function validateLoadEngineV2CoordinatorHello(hello, expectedSessionId, expectedAgentId, nowUtcNs64) {
+    validateLoadEngineV2AgentId(expectedAgentId);
+    if (hello.sessionId !== expectedSessionId || !hello.expectedAgentIds.includes(expectedAgentId)) {
+        throw new Error("Load Engine V2 coordinator hello does not authorize this session and agent.");
+    }
+    if (hello.registrationSubject !== buildLoadEngineV2ScopedRegistrationSubject(hello.runId, hello.sessionId, hello.coordinatorNonce) || parseCanonicalNonNegativeInt64(hello.expiresUtcNs64, "coordinator hello expiry")
+        <= parseCanonicalNonNegativeInt64(nowUtcNs64, "coordinator hello validation time")) {
+        throw new Error("Load Engine V2 coordinator hello subject or expiry is invalid.");
+    }
+    const expected = buildLoadEngineV2CoordinatorHelloBindingHash({ ...hello, bindingHash: "" });
+    if (!hashEquals(expected, hello.bindingHash)) {
+        throw new Error("Load Engine V2 coordinator hello binding hash is invalid.");
+    }
+}
+function buildLoadEngineV2CoordinatorHelloBindingHash(hello) {
+    const expected = normalizeExpectedAgentIds(hello.expectedAgentIds);
+    const fields = [
+        Buffer.from("LS-CH1\n", "ascii"), frameUtf8("1"), frameUtf8(hello.runId),
+        frameUtf8(hello.sessionId), frameUtf8(hello.coordinatorNonce), frameUtf8(hello.registrationSubject),
+        frameUtf8(hello.expiresUtcNs64), frameUtf8(expected.length.toString()),
+        ...expected.map(frameUtf8)
+    ];
+    return sha256Hex(Buffer.concat(fields));
+}
+function buildLoadEngineV2RegistrationBindingHash(registration) {
+    const fields = [
+        Buffer.from("LS-RG1\n", "ascii"), frameUtf8("1"), frameUtf8(registration.runId),
+        frameUtf8(registration.sessionId), frameUtf8(registration.coordinatorNonce),
+        frameUtf8(registration.agentId), frameUtf8(registration.processInstanceId),
+        frameUtf8(registration.targetSubject), frameUtf8(registration.schedulerVisibleProcessorCount.toString()),
+        frameUtf8(registration.sdkLanguage), frameUtf8(registration.sdkPackageVersion),
+        frameUtf8(registration.runtimeVersion)
+    ];
+    for (const values of [
+        registration.schedulerVersions, registration.histogramVersions, registration.shardingVersions,
+        registration.resultChunkVersions, registration.iterationObservationSchemas,
+        registration.correlationSetVersions, registration.planHashVersions, registration.callbackExecutionModes
+    ]) {
+        const ordered = canonicalV2CapabilityList(values, "registration capability");
+        fields.push(frameUtf8(ordered.length.toString()), ...ordered.map(frameUtf8));
+    }
+    fields.push(frameUtf8(registration.maximumResultChunkBytes.toString()), frameUtf8(registration.registrationSequence64), frameUtf8(registration.leaseIssuedUtcNs64), frameUtf8(registration.leaseExpiresUtcNs64));
+    return sha256Hex(Buffer.concat(fields));
+}
+function canonicalV2CapabilityList(values, field) {
+    if (!Array.isArray(values) || values.length > 32 || new Set(values).size !== values.length) {
+        throw new Error(`Load Engine V2 registration ${field} are invalid.`);
+    }
+    values.forEach((value) => validateBoundedV2Identifier(value, field, 128));
+    return [...values].sort(compareUtf8);
+}
+function canonicalV2CallbackModes(values) {
+    const result = canonicalV2CapabilityList(values, "callback execution modes");
+    if (!result.length || result.some((value) => value !== "async" && value !== "blocking")) {
+        throw new Error("Load Engine V2 registration callback execution modes are invalid.");
+    }
+    return result;
+}
+function acceptLoadEngineV2RegistrationRenewal(registrations, next, runId, sessionId, coordinatorNonce, nowUtcNs64) {
+    negotiateLoadEngineV2Registrations(runId, sessionId, coordinatorNonce, [next.agentId], [next], nowUtcNs64);
+    const current = registrations.get(next.agentId);
+    if (!current) {
+        registrations.set(next.agentId, next);
+        return true;
+    }
+    const currentSequence = parseCanonicalNonNegativeInt64(current.registrationSequence64, "registration sequence");
+    const nextSequence = parseCanonicalNonNegativeInt64(next.registrationSequence64, "registration sequence");
+    if (nextSequence === currentSequence) {
+        if (!hashEquals(current.registrationBindingHash, next.registrationBindingHash)) {
+            throw new Error("Load Engine V2 registration has a conflicting retry for the same sequence.");
+        }
+        return false;
+    }
+    const immutableKeys = [
+        "runId", "sessionId", "coordinatorNonce", "agentId", "processInstanceId", "targetSubject",
+        "schedulerVisibleProcessorCount", "sdkLanguage", "sdkPackageVersion", "runtimeVersion",
+        "maximumResultChunkBytes"
+    ];
+    const immutableLists = [
+        "schedulerVersions", "histogramVersions", "shardingVersions", "resultChunkVersions",
+        "iterationObservationSchemas", "correlationSetVersions", "planHashVersions", "callbackExecutionModes"
+    ];
+    if (nextSequence !== currentSequence + 1n
+        || immutableKeys.some((key) => current[key] !== next[key])
+        || immutableLists.some((key) => JSON.stringify(current[key]) !== JSON.stringify(next[key]))
+        || parseCanonicalNonNegativeInt64(next.leaseIssuedUtcNs64, "registration lease issue")
+            < parseCanonicalNonNegativeInt64(current.leaseIssuedUtcNs64, "registration lease issue")
+        || parseCanonicalNonNegativeInt64(next.leaseExpiresUtcNs64, "registration lease expiry")
+            <= parseCanonicalNonNegativeInt64(current.leaseExpiresUtcNs64, "registration lease expiry")) {
+        throw new Error("Load Engine V2 registration lease renewal is stale or changed immutable metadata.");
+    }
+    registrations.set(next.agentId, next);
+    return true;
+}
+async function refreshLoadEngineV2Registrations(consumer, registrations, runId, sessionId, coordinatorNonce, expectedAgentIds, timeoutMs, requiredFutureNs) {
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        const now = utcNowNs();
+        const live = expectedAgentIds.every((agentId) => {
+            const registration = registrations.get(agentId);
+            return registration && parseCanonicalNonNegativeInt64(registration.leaseExpiresUtcNs64, "registration lease expiry") > now + requiredFutureNs;
+        });
+        if (live) {
+            return negotiateLoadEngineV2Registrations(runId, sessionId, coordinatorNonce, expectedAgentIds, [...registrations.values()], now.toString());
+        }
+        if (Date.now() >= deadline) {
+            throw new Error("Load Engine V2 registration lease renewal timed out before the next commit.");
+        }
+        const payload = await consumer.consume();
+        const body = recordOrUndefined(payload?.body);
+        if (!body || !expectedAgentIds.includes(body.agentId)) {
+            await sleep(5);
+            continue;
+        }
+        acceptLoadEngineV2RegistrationRenewal(registrations, body, runId, sessionId, coordinatorNonce, utcNowNs64());
+    }
+}
+export function buildLoadEngineV2Plan(input) {
+    const expected = normalizeExpectedAgentIds(input.expectedAgentIds);
+    validateBoundedV2Identifier(input.runId, "run ID", 128);
+    validateBoundedV2Identifier(input.sessionId, "session ID", 128);
+    validateBoundedV2Identifier(input.registrationNonce, "registration nonce", 128);
+    const maxInFlight = parseCanonicalPositiveInt64(input.maxInFlight64, "MaxInFlight");
+    const reportingInterval = parseCanonicalPositiveInt64(input.reportingIntervalNs64, "reporting interval");
+    const schedulerSeed = parseCanonicalNonNegativeInt64(input.schedulerSeed64 ?? "0", "scheduler seed");
+    const processorCount = parseCanonicalPositiveInt64(input.schedulerVisibleProcessorCount64 ?? "1", "scheduler-visible processor count");
+    const maxStatisticsStateBytes = parseV2Limit(input.maxStatisticsStateBytes64 ?? "536870912", "MaxStatisticsStateBytes", 67108864n, 4294967296n);
+    const maxDistributionSeries = parseV2Limit(input.maxDistributionSeries64 ?? "256", "MaxDistributionSeries", 16n, 100000n);
+    const maxCorrelationGroups = parseV2Limit(input.maxCorrelationGroups64 ?? "512", "MaxCorrelationGroups", 16n, 100000n);
+    const maxStatusGroups = parseV2Limit(input.maxStatusGroupsPerSeries64 ?? "64", "MaxStatusGroupsPerSeries", 8n, 10000n);
+    const maxPortalBytes = parseV2Limit(input.maxPortalRunDistributionBytes64 ?? "1073741824", "MaxPortalRunDistributionBytes", 134217728n, 8589934592n);
+    if (maxInFlight > 1000000n || reportingInterval > 9223372036854775807n
+        || schedulerSeed > 4294967295n || processorCount > 2147483647n) {
+        throw new Error("Load Engine V2 plan settings exceed the supported non-correlation profile.");
+    }
+    const scenarios = [...input.scenarios].sort((left, right) => compareCanonicalIntegers(left.scenarioIndex64, right.scenarioIndex64));
+    if (!scenarios.length || new Set(scenarios.map((value) => value.scenarioIndex64)).size !== scenarios.length) {
+        throw new Error("Load Engine V2 requires unique selected scenario declaration indexes.");
+    }
+    const declaredSteps = new Map();
+    const portalSeries = [];
+    let simulationCount = 0n;
+    for (const scenario of scenarios) {
+        parseCanonicalNonNegativeInt64(scenario.scenarioIndex64, "scenario index");
+        validateBoundedV2Identifier(scenario.scenarioName, "scenario name", 1024);
+        if (scenario.target !== "agent") {
+            throw new Error("The supported non-correlation LS-SP1 profile requires agent-target scenarios.");
+        }
+        const mode = scenario.callbackExecutionMode ?? "async";
+        if (mode !== "async" && mode !== "blocking")
+            throw new Error("Load Engine V2 callback mode is invalid.");
+        const byIdentity = new Map();
+        for (const stepName of scenario.declaredStepNames ?? []) {
+            const row = buildV2DeclaredStep(scenario.scenarioIndex64, stepName);
+            const key = row.identity.toString("hex");
+            const prior = byIdentity.get(key);
+            if (!prior || Buffer.compare(row.display, prior.display) < 0)
+                byIdentity.set(key, row);
+        }
+        const steps = [...byIdentity.values()].sort((left, right) => Buffer.compare(left.identity, right.identity));
+        declaredSteps.set(scenario.scenarioIndex64, steps);
+        addV2MeasurementPortalSeries(portalSeries, buildV2Identity(0x01, scenario.scenarioIndex64));
+        for (const step of steps)
+            addV2MeasurementPortalSeries(portalSeries, step.identity);
+        addV2MeasurementPortalSeries(portalSeries, buildV2Identity(0x04, scenario.scenarioIndex64));
+        const simulations = [...scenario.simulations].sort((left, right) => compareCanonicalIntegers(left.simulationIndex64, right.simulationIndex64));
+        if (!simulations.length
+            || new Set(simulations.map((value) => value.simulationIndex64)).size !== simulations.length) {
+            throw new Error("Load Engine V2 requires unique simulation indexes in every selected scenario.");
+        }
+        for (const simulation of simulations) {
+            validateV2Simulation(simulation);
+            addV2SchedulerPortalSeries(portalSeries, buildV2Identity(0x05, scenario.scenarioIndex64, simulation.simulationIndex64));
+            addV2SchedulerPortalSeries(portalSeries, buildV2Identity(0x06, scenario.scenarioIndex64, simulation.simulationIndex64));
+            simulationCount += 1n;
+        }
+    }
+    const staticMeasurementCount = 2n * BigInt(scenarios.length)
+        + [...declaredSteps.values()].reduce((sum, rows) => sum + BigInt(rows.length), 0n);
+    if (staticMeasurementCount > maxDistributionSeries) {
+        throw new Error("Load Engine V2 static scenario/step identities exceed MaxDistributionSeries.");
+    }
+    portalSeries.sort((left, right) => Buffer.compare(Buffer.from(left.seriesKeyHex, "hex"), Buffer.from(right.seriesKeyHex, "hex")) || compareUtf8(left.unit, right.unit) || compareUtf8(left.outcome, right.outcome));
+    if (BigInt(portalSeries.length) !== 6n * staticMeasurementCount + 2n * simulationCount) {
+        throw new Error("Load Engine V2 frozen portal series enumeration is incomplete.");
+    }
+    const exactPlanStringBytes = calculateV2ExactPlanStringBytes(input, expected, portalSeries, declaredSteps);
+    const globalAggregateScratch = calculateV2StatisticsReservation(maxDistributionSeries, simulationCount, maxStatusGroups, exactPlanStringBytes);
+    if (globalAggregateScratch > maxStatisticsStateBytes) {
+        throw new Error(`Load Engine V2 statistics reservation ${globalAggregateScratch} exceeds configured ${maxStatisticsStateBytes}.`);
+    }
+    const resultOwnerCount = BigInt(expected.length);
+    const receiverScratch = checkedV2Sum(globalAggregateScratch, 262144n, 131072n);
+    let effectivePortalPointLimit = 0n;
+    let portalLiveStateBytes = 0n;
+    for (let points = 1000n; points >= 2n; points -= 1n) {
+        const candidate = calculateV2PortalLiveState(BigInt(portalSeries.length), resultOwnerCount, points);
+        if (candidate + receiverScratch <= maxPortalBytes) {
+            effectivePortalPointLimit = points;
+            portalLiveStateBytes = candidate;
+            break;
+        }
+    }
+    if (effectivePortalPointLimit === 0n) {
+        throw new Error("Load Engine V2 portal reservation cannot retain the two protected endpoints.");
+    }
+    const maxEncodedNonDetailArtifactBytes = 67108864n;
+    const maxEncodedRecoveryOverlayBytes = 4096n;
+    const latestPerOwner = 262144n + maxEncodedNonDetailArtifactBytes;
+    const latestSnapshotSpoolBytes = BigInt(expected.length)
+        * (latestPerOwner + maxEncodedRecoveryOverlayBytes)
+        + (latestPerOwner > maxEncodedRecoveryOverlayBytes ? latestPerOwner : maxEncodedRecoveryOverlayBytes);
+    const blocking = scenarios.some((scenario) => (scenario.callbackExecutionMode ?? "async") === "blocking");
+    const configuredBlockingWorkers = blocking
+        ? minimumBigIntV2(maxInFlight, 1024n, maximumBigIntV2(32n, processorCount * 32n))
+        : 0n;
+    const fields = [Buffer.from("LS-SP1\n", "ascii")];
+    const write = (value) => { fields.push(frameUtf8(value)); };
+    [
+        "1", input.runId, input.sessionId, input.registrationNonce, "2", "2", "1", "1", "", "1",
+        "131072", "0", "", "", "", "0", schedulerSeed.toString(), "global",
+        maxInFlight.toString(), reportingInterval.toString(), "0", maxStatisticsStateBytes.toString(),
+        maxDistributionSeries.toString(), maxCorrelationGroups.toString(), maxStatusGroups.toString(),
+        maxPortalBytes.toString(), "0", "0", "0", "0", "0", "0",
+        "0", "-1", "0", "0", "0", "0", "0", resultOwnerCount.toString(),
+        expected.length.toString(), portalSeries.length.toString(), effectivePortalPointLimit.toString(),
+        globalAggregateScratch.toString(), portalLiveStateBytes.toString(), receiverScratch.toString(),
+        latestSnapshotSpoolBytes.toString(), "0", expected.length.toString()
+    ].forEach(write);
+    expected.forEach((agentId, processGroupIndex) => {
+        [
+            agentId, processGroupIndex.toString(), "1", processorCount.toString(),
+            configuredBlockingWorkers.toString(), maxEncodedNonDetailArtifactBytes.toString(),
+            maxEncodedRecoveryOverlayBytes.toString(), "0"
+        ].forEach(write);
+    });
+    portalSeries.forEach((series) => {
+        write(series.seriesKeyHex);
+        write(series.unit);
+        write(series.outcome);
+    });
+    write(scenarios.length.toString());
+    for (const scenario of scenarios) {
+        const mode = scenario.callbackExecutionMode ?? "async";
+        write(scenario.scenarioIndex64);
+        write(scenario.scenarioName);
+        write(scenario.target);
+        write("");
+        ["", "", "-1", "0", ""].forEach(write);
+        const steps = declaredSteps.get(scenario.scenarioIndex64) ?? [];
+        write(steps.length.toString());
+        steps.forEach((step) => {
+            write(step.identity.toString("hex"));
+            write(step.display.toString("hex"));
+        });
+        write("0");
+        write(expected.length.toString());
+        expected.forEach((agentId, shardIndex) => {
+            write(agentId);
+            write(shardIndex.toString());
+            write(expected.length.toString());
+            write(mode);
+        });
+        const simulations = [...scenario.simulations].sort((left, right) => compareCanonicalIntegers(left.simulationIndex64, right.simulationIndex64));
+        write(simulations.length.toString());
+        for (const simulation of simulations) {
+            write(simulation.simulationIndex64);
+            write("-1");
+            write("");
+            write(simulation.kind);
+            [simulation.rate64, simulation.minRate64, simulation.maxRate64, simulation.copies64,
+                simulation.iterations64, simulation.intervalNs64, simulation.durationNs64, "0"].forEach(write);
+        }
+    }
+    const bytes = Buffer.concat(fields);
+    return { bytes, hash: sha256Hex(bytes), expectedAgentIds: expected, portalSeries };
+}
+/** Canonical LoadStrikeIdentityKeyV1 scenario bytes. */
+export function buildLoadEngineV2ScenarioIdentityKey(scenarioIndex64) {
+    parseCanonicalNonNegativeInt64(scenarioIndex64, "scenario identity index");
+    return buildV2Identity(0x01, scenarioIndex64);
+}
+/** Canonical LoadStrikeIdentityKeyV1 reserved step-other bytes. */
+export function buildLoadEngineV2ReservedStepOtherIdentityKey(scenarioIndex64) {
+    parseCanonicalNonNegativeInt64(scenarioIndex64, "reserved step identity index");
+    return buildV2Identity(0x04, scenarioIndex64);
+}
+export function buildLoadEngineV2StepIdentityKey(scenarioIndex64, stepName) {
+    parseCanonicalNonNegativeInt64(scenarioIndex64, "step identity index");
+    const row = buildV2DeclaredStep(scenarioIndex64, stepName);
+    return { identity: row.identity, display: new TextDecoder("utf-8", { fatal: true }).decode(row.display) };
+}
+/** Resolves a runtime step to its frozen signed identity or the reserved `<other>` bucket. */
+export function resolveLoadEngineV2StepIdentityKey(scenarioIndex64, stepName, declaredStepNames) {
+    const observed = buildV2DeclaredStep(scenarioIndex64, stepName);
+    let signedDisplay;
+    for (const declaredName of declaredStepNames) {
+        const declared = buildV2DeclaredStep(scenarioIndex64, declaredName);
+        if (!declared.identity.equals(observed.identity))
+            continue;
+        if (!signedDisplay || Buffer.compare(declared.display, signedDisplay) < 0) {
+            signedDisplay = declared.display;
+        }
+    }
+    if (!signedDisplay) {
+        return {
+            identity: buildLoadEngineV2ReservedStepOtherIdentityKey(scenarioIndex64),
+            display: "<other>",
+            routedToOther: true
+        };
+    }
+    return {
+        identity: observed.identity,
+        display: new TextDecoder("utf-8", { fatal: true }).decode(signedDisplay),
+        routedToOther: false
+    };
+}
+export function buildLoadEngineV2SchedulerIdentityKey(kind, scenarioIndex64, simulationIndex64) {
+    parseCanonicalNonNegativeInt64(scenarioIndex64, "scheduler identity scenario index");
+    parseCanonicalNonNegativeInt64(simulationIndex64, "scheduler identity simulation index");
+    return buildV2Identity(kind === "decision" ? 0x05 : 0x06, scenarioIndex64, simulationIndex64);
+}
+export function buildLoadEngineV2StatusIdentityKey(status, message) {
+    validateUnicodeScalars(status);
+    validateUnicodeScalars(message);
+    if (!status && !message)
+        return undefined;
+    const payload = Buffer.concat([Buffer.from("LS-ST1\n", "ascii"), frameUtf8(status), frameUtf8(message)]);
+    const digest = sha256Hex(payload);
+    const identity = payload.length <= 1024
+        ? buildV2Identity(0x0b, status, message)
+        : buildV2Identity(0x0c, payload.length.toString(), digest);
+    const source = !message ? status : !status ? message : `${status}: ${message}`;
+    let prefix = "";
+    for (const scalar of source) {
+        if (Buffer.byteLength(prefix + scalar, "utf8") > 512)
+            break;
+        prefix += scalar;
+    }
+    return {
+        identity,
+        display: Buffer.byteLength(source, "utf8") <= 512 ? source : `${prefix}…#${digest.slice(0, 32)}`
+    };
+}
+/** Canonical LoadStrikePortalSeriesKeyV1 bytes. */
+export function buildLoadEngineV2PortalSeriesKey(identity, unit, outcome) {
+    if (!identity.length)
+        throw new Error("Load Engine V2 portal identity cannot be empty.");
+    return Buffer.concat([
+        Buffer.from("LS-PS1\n", "ascii"),
+        frameUtf8("1"),
+        frameBytes(Buffer.from(identity)),
+        frameUtf8(unit),
+        frameUtf8(outcome)
+    ]);
+}
+function buildV2Identity(tag, ...values) {
+    if (!Number.isInteger(tag) || tag < 1 || tag > 0x0e) {
+        throw new Error("Load Engine V2 identity tag is invalid.");
+    }
+    return Buffer.concat([
+        Buffer.from("LS-ID1\n", "ascii"),
+        Buffer.from([tag]),
+        ...values.map(frameUtf8)
+    ]);
+}
+function buildV2DeclaredStep(scenarioIndex64, stepName) {
+    validateUnicodeScalars(stepName);
+    const bytes = Buffer.from(stepName, "utf8");
+    if (bytes.length <= 1024) {
+        return { identity: buildV2Identity(0x02, scenarioIndex64, stepName), display: bytes };
+    }
+    const digest = sha256Hex(bytes);
+    let prefix = "";
+    for (const scalar of stepName) {
+        if (Buffer.byteLength(prefix + scalar, "utf8") > 512)
+            break;
+        prefix += scalar;
+    }
+    return {
+        identity: buildV2Identity(0x03, scenarioIndex64, bytes.length.toString(), digest),
+        display: Buffer.from(`${prefix}…#${digest.slice(0, 32)}`, "utf8")
+    };
+}
+function addV2MeasurementPortalSeries(target, identity) {
+    for (const unit of ["microseconds", "bytes"]) {
+        for (const outcome of ["ok", "fail", "all"]) {
+            target.push({
+                seriesKeyHex: buildLoadEngineV2PortalSeriesKey(identity, unit, outcome).toString("hex"),
+                unit,
+                outcome
+            });
+        }
+    }
+}
+function addV2SchedulerPortalSeries(target, identity) {
+    target.push({
+        seriesKeyHex: buildLoadEngineV2PortalSeriesKey(identity, "microseconds", "none").toString("hex"),
+        unit: "microseconds",
+        outcome: "none"
+    });
+}
+function validateV2Simulation(simulation) {
+    const allowed = new Set([
+        "inject", "inject-random", "ramping-inject", "keep-constant", "ramping-constant",
+        "iterations-for-inject", "iterations-for-constant", "pause"
+    ]);
+    if (!allowed.has(simulation.kind))
+        throw new Error("Load Engine V2 simulation kind is invalid.");
+    [simulation.simulationIndex64, simulation.rate64, simulation.minRate64,
+        simulation.maxRate64, simulation.copies64, simulation.iterations64,
+        simulation.intervalNs64, simulation.durationNs64]
+        .forEach((value) => parseCanonicalNonNegativeInt64(value, "simulation plan integer"));
+}
+function calculateV2ExactPlanStringBytes(input, expectedAgentIds, portalSeries, declaredSteps) {
+    let total = 0n;
+    const addText = (value) => { total += BigInt(Buffer.byteLength(value, "utf8")); };
+    [input.runId, input.sessionId, input.registrationNonce, ...expectedAgentIds].forEach(addText);
+    for (const scenario of input.scenarios) {
+        addText(scenario.scenarioName);
+        // Agent-target scenarios have no coordinator callback mode. Each signed
+        // participant owns both its agent ID and callback execution mode bytes.
+        for (const agentId of expectedAgentIds) {
+            addText(agentId);
+            addText(scenario.callbackExecutionMode ?? "async");
+        }
+        for (const simulation of scenario.simulations)
+            addText(simulation.kind);
+        for (const step of declaredSteps.get(scenario.scenarioIndex64) ?? []) {
+            total += BigInt(step.identity.length + step.display.length);
+        }
+    }
+    for (const series of portalSeries) {
+        total += BigInt(series.seriesKeyHex.length / 2);
+        addText(series.unit);
+        addText(series.outcome);
+    }
+    if (total > 9223372036854775807n)
+        throw new Error("Load Engine V2 plan strings exceed signed storage.");
+    return total;
+}
+function calculateV2StatisticsReservation(maxDistributionSeries, simulationCount, maxStatusGroups, exactPlanStringBytes) {
+    return checkedV2Sum(maxDistributionSeries * 786432n, maxDistributionSeries * (256n + 1088n), 2n * maxDistributionSeries * maxStatusGroups * (128n + 1664n), simulationCount * 212992n, 16n * 1024n * 1024n, 1024n * 1024n, exactPlanStringBytes);
+}
+function calculateV2PortalLiveState(frozenSeriesCount, resultOwnerCount, pointLimit) {
+    return checkedV2Sum(frozenSeriesCount * ((resultOwnerCount + 1n) * 98304n + pointLimit * 256n + 4096n), resultOwnerCount * 4096n, 1048576n);
+}
+function checkedV2Sum(...values) {
+    let result = 0n;
+    for (const value of values) {
+        if (value < 0n)
+            throw new Error("Load Engine V2 resource calculation became negative.");
+        result += value;
+        if (result > 9223372036854775807n) {
+            throw new Error("Load Engine V2 resource calculation exceeds signed 64-bit storage.");
+        }
+    }
+    return result;
+}
+function parseV2Limit(value, field, minimum, maximum) {
+    const parsed = parseCanonicalNonNegativeInt64(value, field);
+    if (parsed < minimum || parsed > maximum) {
+        throw new Error(`${field} must be from ${minimum} through ${maximum}.`);
+    }
+    return parsed;
+}
+function parseCanonicalPositiveInt64(value, field) {
+    const parsed = parseCanonicalNonNegativeInt64(value, field);
+    if (parsed === 0n)
+        throw new Error(`${field} must be positive.`);
+    return parsed;
+}
+function validateBoundedV2Identifier(value, field, maximumBytes) {
+    validateUnicodeScalars(value);
+    const length = Buffer.byteLength(value, "utf8");
+    if (length === 0 || length > maximumBytes) {
+        throw new Error(`Load Engine V2 ${field} must be from 1 through ${maximumBytes} UTF-8 bytes.`);
+    }
+}
+function frameBytes(value) {
+    if (value.length > 4294967295)
+        throw new Error("Load Engine V2 canonical bytes exceed the framing limit.");
+    const frame = Buffer.allocUnsafe(4 + value.length);
+    frame.writeUInt32BE(value.length, 0);
+    value.copy(frame, 4);
+    return frame;
+}
+function minimumBigIntV2(...values) {
+    return values.reduce((minimum, value) => value < minimum ? value : minimum);
+}
+function maximumBigIntV2(...values) {
+    return values.reduce((maximum, value) => value > maximum ? value : maximum);
+}
+function orderedLoadEngineV2Segments(input) {
+    return [...input.scenarios]
+        .sort((left, right) => compareCanonicalIntegers(left.scenarioIndex64, right.scenarioIndex64))
+        .flatMap((scenario) => [...scenario.simulations]
+        .sort((left, right) => compareCanonicalIntegers(left.simulationIndex64, right.simulationIndex64))
+        .map((simulation) => ({
+        scenarioIndex64: scenario.scenarioIndex64,
+        simulationIndex64: simulation.simulationIndex64
+    })));
+}
+export function buildLoadEngineV2BarrierScopeId(planHash, scope) {
+    validateLowercaseHash(planHash, "plan hash");
+    const fields = [Buffer.from("LS-BS1\n", "ascii"), frameUtf8(planHash), frameUtf8(scope.kind)];
+    if (scope.kind === "scenario") {
+        parseCanonicalNonNegativeInt64(scope.scenarioIndex64, "barrier scenario index");
+        parseCanonicalNonNegativeInt64(scope.simulationIndex64, "barrier simulation index");
+        fields.push(frameUtf8(scope.scenarioIndex64), frameUtf8(scope.simulationIndex64));
+    }
+    else {
+        validateLowercaseHash(scope.trafficMixId, "traffic mix id");
+        parseCanonicalNonNegativeInt64(scope.trafficMixPhaseIndex64, "traffic mix phase index");
+        fields.push(frameUtf8(scope.trafficMixId), frameUtf8(scope.trafficMixPhaseIndex64));
+    }
+    return sha256Hex(Buffer.concat(fields));
+}
+export function buildLoadEngineV2AssignmentHash(barrierScopeId, assignments) {
+    validateLowercaseHash(barrierScopeId, "barrier scope id");
+    if (!assignments.length)
+        throw new Error("Load Engine V2 barrier assignment requires participants.");
+    const ordered = [...assignments].sort(compareBarrierAssignments);
+    const fields = [Buffer.from("LS-BA1\n", "ascii")];
+    const write = (value) => { fields.push(frameUtf8(value)); };
+    write("1");
+    write(barrierScopeId);
+    write(ordered.length.toString());
+    const identities = new Set();
+    for (const assignment of ordered) {
+        validateLoadEngineV2AgentId(assignment.agentId);
+        parseCanonicalNonNegativeInt64(assignment.scenarioIndex64, "scenario index");
+        parseCanonicalNonNegativeInt64(assignment.simulationIndex64, "simulation index");
+        const lane = assignment.trafficMixLaneIndex64 ?? "-1";
+        const phase = assignment.trafficMixPhaseIndex64 ?? "-1";
+        parseCanonicalInt64(lane, "traffic mix lane index");
+        parseCanonicalInt64(phase, "traffic mix phase index");
+        parseCanonicalNonNegativeInt64(assignment.shardIndex64, "shard index");
+        const shardCount = parseCanonicalNonNegativeInt64(assignment.shardCount64, "shard count");
+        if (shardCount <= 0n || BigInt(assignment.shardIndex64) >= shardCount) {
+            throw new Error("Load Engine V2 shard assignment is invalid.");
+        }
+        const identity = [assignment.scenarioIndex64, assignment.simulationIndex64,
+            assignment.trafficMixId ?? "", lane, phase, assignment.agentId, assignment.shardIndex64].join("\u0000");
+        if (identities.has(identity))
+            throw new Error("Load Engine V2 barrier assignment contains a duplicate record.");
+        identities.add(identity);
+        write(assignment.scenarioIndex64);
+        write(assignment.simulationIndex64);
+        write(assignment.trafficMixId ?? "");
+        write(lane);
+        write(phase);
+        write(assignment.agentId);
+        write(assignment.shardIndex64);
+        write(assignment.shardCount64);
+    }
+    return sha256Hex(Buffer.concat(fields));
+}
+function compareBarrierAssignments(left, right) {
+    const numeric = (a, b) => {
+        const av = parseCanonicalInt64(a, "barrier assignment index");
+        const bv = parseCanonicalInt64(b, "barrier assignment index");
+        return av < bv ? -1 : av > bv ? 1 : 0;
+    };
+    return numeric(left.scenarioIndex64, right.scenarioIndex64)
+        || numeric(left.simulationIndex64, right.simulationIndex64)
+        || numeric(left.trafficMixLaneIndex64 ?? "-1", right.trafficMixLaneIndex64 ?? "-1")
+        || compareAgentIds(left.agentId, right.agentId)
+        || numeric(left.shardIndex64, right.shardIndex64);
+}
+export function evaluateLoadEngineV2ClockProbe(sample) {
+    if (!Number.isInteger(sample.probeIndex) || sample.probeIndex < 0 || sample.probeIndex > 4) {
+        throw new Error("Load Engine V2 clock probe index must be from zero through four.");
+    }
+    const c0 = parseCanonicalInt64(sample.coordinatorSendUtcNs64, "clock c0");
+    const a1 = parseCanonicalInt64(sample.agentReceiveUtcNs64, "clock a1");
+    const a2 = parseCanonicalInt64(sample.agentSendUtcNs64, "clock a2");
+    const c3 = parseCanonicalInt64(sample.coordinatorReceiveUtcNs64, "clock c3");
+    const coordinatorResolution = parseCanonicalNonNegativeInt64(sample.coordinatorClockResolutionNs64, "coordinator clock resolution");
+    const agentResolution = parseCanonicalNonNegativeInt64(sample.agentClockResolutionNs64, "agent clock resolution");
+    if (c3 < c0 || a2 < a1)
+        throw new Error("Load Engine V2 clock probe timestamps moved backwards.");
+    const roundTrip = (c3 - c0) - (a2 - a1);
+    if (roundTrip < 0n)
+        throw new Error("Load Engine V2 clock probe round trip is negative.");
+    const offset = ((a1 - c0) + (a2 - c3)) / 2n;
+    const uncertainty = ((roundTrip + 1n) / 2n) + coordinatorResolution + agentResolution;
+    return {
+        ...sample,
+        roundTripNs64: roundTrip.toString(),
+        offsetAgentMinusCoordinatorNs64: offset.toString(),
+        uncertaintyNs64: uncertainty.toString()
+    };
+}
+export function selectLoadEngineV2ClockProbe(samples, latenessToleranceNs64) {
+    if (samples.length !== 5 || new Set(samples.map((value) => value.probeIndex)).size !== 5) {
+        throw new Error("Load Engine V2 clock negotiation requires exactly five distinct probes.");
+    }
+    const selected = samples.map(evaluateLoadEngineV2ClockProbe).sort((left, right) => {
+        const uncertainty = parseCanonicalInt64(left.uncertaintyNs64, "uncertainty")
+            - parseCanonicalInt64(right.uncertaintyNs64, "uncertainty");
+        if (uncertainty !== 0n)
+            return uncertainty < 0n ? -1 : 1;
+        const roundTrip = parseCanonicalInt64(left.roundTripNs64, "round trip")
+            - parseCanonicalInt64(right.roundTripNs64, "round trip");
+        return roundTrip === 0n ? left.probeIndex - right.probeIndex : roundTrip < 0n ? -1 : 1;
+    })[0];
+    let bound = 25000000n;
+    if (latenessToleranceNs64 !== undefined) {
+        const tolerance = parseCanonicalNonNegativeInt64(latenessToleranceNs64, "lateness tolerance");
+        if (tolerance < bound)
+            bound = tolerance;
+    }
+    if (parseCanonicalInt64(selected.uncertaintyNs64, "clock uncertainty") > bound) {
+        throw new Error("Load Engine V2 clock uncertainty exceeds the permitted start-barrier bound.");
+    }
+    return selected;
+}
+export function validateLoadEngineV2BarrierAcks(phase, expectedAgentIds, acknowledgements, planHash, assignmentHash, barrierEpoch64, nowUtcNs64, barrierScopeId) {
+    const expected = normalizeExpectedAgentIds(expectedAgentIds);
+    const ordered = [...acknowledgements].sort((left, right) => compareAgentIds(left.agentId, right.agentId));
+    if (ordered.length !== expected.length || ordered.some((value, index) => value.agentId !== expected[index])) {
+        throw new Error(`Load Engine V2 ${phase} barrier is missing an exact participant acknowledgement.`);
+    }
+    const now = parseCanonicalInt64(nowUtcNs64, "barrier validation time");
+    for (const acknowledgement of ordered) {
+        const deadline = parseCanonicalInt64(acknowledgement.deadlineUtcNs64, "barrier deadline");
+        const acknowledged = parseCanonicalInt64(acknowledgement.acknowledgedUtcNs64, "barrier acknowledgement time");
+        if (!acknowledgement.accepted || acknowledgement.phase !== phase
+            || acknowledgement.planHash !== planHash || acknowledgement.assignmentHash !== assignmentHash
+            || (barrierScopeId !== undefined && acknowledgement.barrierScopeId !== barrierScopeId)
+            || acknowledgement.barrierEpoch64 !== barrierEpoch64 || acknowledged >= deadline) {
+            throw new Error(`Load Engine V2 ${phase} barrier acknowledgement is invalid.`);
+        }
+        if (now >= deadline)
+            throw new Error(`Load Engine V2 ${phase} barrier deadline has elapsed.`);
+    }
+}
+const LOAD_ENGINE_V2_RESULT_EMPTY_SHA256 = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
+const LOAD_ENGINE_V2_MAX_MANIFEST_BYTES = 262144;
+const LOAD_ENGINE_V2_MAX_MANIFEST_ENTRIES = 1029;
+const LOAD_ENGINE_V2_MAX_DETAIL_PARTS = 1024;
+const LOAD_ENGINE_V2_MAIN_ARTIFACTS = [
+    ["scheduler", "scheduler-snapshot-v2"],
+    ["histograms", "histogram-set-v1"],
+    ["correlations", "correlation-set-v1"],
+    ["portal-deltas", "portal-delta-set-v1"],
+    ["correlation-detail-index", "correlation-detail-index-v1"]
+];
+export function loadEngineV2PresentArtifact(kind, artifactId, schema, payload) {
+    return { kind, artifactId, schema, applicability: "present", payload: Buffer.from(payload) };
+}
+export function loadEngineV2EmptyArtifact(kind, artifactId, schema) {
+    return { kind, artifactId, schema, applicability: "empty", payload: Buffer.alloc(0) };
+}
+export function loadEngineV2NotApplicableArtifact(kind, artifactId) {
+    return { kind, artifactId, schema: "0", applicability: "not-applicable", payload: Buffer.alloc(0) };
+}
+export function createLoadEngineV2ResultSnapshot(runId, sessionId, resultOwnerId, snapshotSequence64, planHash, isFinal, chunkBytes, artifacts) {
+    validateV2ResultScope(runId, "run ID");
+    validateV2ResultScope(sessionId, "session ID");
+    validateV2ResultOwner(resultOwnerId);
+    validateLowercaseHash(planHash, "plan hash");
+    parseCanonicalNonNegativeInt64(snapshotSequence64, "snapshot sequence");
+    validateV2ResultChunkBound(chunkBytes);
+    const source = artifacts.map((artifact) => ({ ...artifact, payload: Buffer.from(artifact.payload) }));
+    validateV2ResultArtifactOrder(source);
+    const entries = source.map((artifact) => {
+        if (artifact.applicability === "present" && artifact.payload.length > 0) {
+            return {
+                kind: artifact.kind, artifactId: artifact.artifactId, schema: artifact.schema,
+                applicability: "present", uncompressedLength64: artifact.payload.length.toString(),
+                chunkCount: Math.ceil(artifact.payload.length / chunkBytes),
+                artifactSha256: sha256Hex(artifact.payload)
+            };
+        }
+        if (artifact.applicability === "empty" && artifact.payload.length === 0) {
+            return {
+                kind: artifact.kind, artifactId: artifact.artifactId, schema: artifact.schema,
+                applicability: "empty", uncompressedLength64: "0", chunkCount: 0,
+                artifactSha256: LOAD_ENGINE_V2_RESULT_EMPTY_SHA256
+            };
+        }
+        if (artifact.applicability === "not-applicable" && artifact.schema === "0"
+            && artifact.payload.length === 0) {
+            return {
+                kind: artifact.kind, artifactId: artifact.artifactId, schema: "0",
+                applicability: "not-applicable", uncompressedLength64: "0", chunkCount: 0,
+                artifactSha256: ""
+            };
+        }
+        throw new Error("Load Engine V2 artifact applicability or payload is invalid.");
+    });
+    const partialManifest = {
+        runId, sessionId, resultOwnerId, snapshotSequence64, planHash, isFinal,
+        correlationDetailPartCount: source.length - 5, entries,
+        bytes: Buffer.alloc(0), hash: ""
+    };
+    const manifestBytes = encodeLoadEngineV2ResultManifest(partialManifest);
+    if (manifestBytes.length > LOAD_ENGINE_V2_MAX_MANIFEST_BYTES) {
+        throw new Error("Load Engine V2 manifest exceeds its encoded bound.");
+    }
+    const manifest = {
+        ...partialManifest, bytes: manifestBytes, hash: sha256Hex(manifestBytes)
+    };
+    const chunks = [];
+    let nonDetailBytes = 0n;
+    let detailBytes = 0n;
+    entries.forEach((entry, entryIndex) => {
+        const payload = source[entryIndex].payload;
+        if (entry.applicability === "present") {
+            for (let chunkIndex = 0; chunkIndex < entry.chunkCount; chunkIndex += 1) {
+                const chunkPayload = Buffer.from(payload.subarray(chunkIndex * chunkBytes, Math.min((chunkIndex + 1) * chunkBytes, payload.length)));
+                const partial = {
+                    runId, sessionId, resultOwnerId, snapshotSequence64,
+                    manifestSha256: manifest.hash, kind: entry.kind, artifactId: entry.artifactId,
+                    schema: entry.schema, artifactSha256: entry.artifactSha256,
+                    chunkIndex, chunkCount: entry.chunkCount,
+                    uncompressedTotalLength64: entry.uncompressedLength64,
+                    payload: chunkPayload, chunkSha256: sha256Hex(chunkPayload), bytes: Buffer.alloc(0)
+                };
+                chunks.push({ ...partial, bytes: encodeLoadEngineV2ResultChunk(partial) });
+            }
+        }
+        const length = BigInt(entry.uncompressedLength64);
+        if (entry.kind === "correlation-detail")
+            detailBytes += length;
+        else
+            nonDetailBytes += length;
+    });
+    const partialCommit = {
+        runId, sessionId, resultOwnerId, snapshotSequence64, planHash,
+        manifestLength: manifestBytes.length, manifestSha256: manifest.hash,
+        entryCount: entries.length, totalNonDetailBytes64: nonDetailBytes.toString(),
+        totalDetailBytes64: detailBytes.toString(), bytes: Buffer.alloc(0)
+    };
+    return {
+        manifest, chunks,
+        commit: { ...partialCommit, bytes: encodeLoadEngineV2ResultCommit(partialCommit) }
+    };
+}
+export function decodeLoadEngineV2ResultManifest(bytesValue) {
+    const bytes = Buffer.from(bytesValue);
+    if (bytes.length > LOAD_ENGINE_V2_MAX_MANIFEST_BYTES) {
+        throw new Error("Load Engine V2 manifest exceeds its encoded bound.");
+    }
+    const cursor = new LoadEngineV2ResultCursor(bytes);
+    cursor.requireMagic("LS-M1\n");
+    cursor.require("1", "manifest version");
+    const manifest = {
+        runId: cursor.readText(), sessionId: cursor.readText(), resultOwnerId: cursor.readText(),
+        snapshotSequence64: cursor.readNonNegative("snapshot sequence"), planHash: cursor.readText(),
+        isFinal: cursor.readBit("final bit"), correlationDetailPartCount: cursor.readCount("detail part count", LOAD_ENGINE_V2_MAX_DETAIL_PARTS), entries: [], bytes, hash: sha256Hex(bytes)
+    };
+    const entryCount = cursor.readCount("manifest entry count", LOAD_ENGINE_V2_MAX_MANIFEST_ENTRIES);
+    if (entryCount !== 5 + manifest.correlationDetailPartCount) {
+        throw new Error("Load Engine V2 manifest entry count does not reconcile.");
+    }
+    for (let index = 0; index < entryCount; index += 1) {
+        manifest.entries.push({
+            kind: cursor.readText(), artifactId: cursor.readText(), schema: cursor.readText(),
+            applicability: cursor.readText(),
+            uncompressedLength64: cursor.readNonNegative("artifact length"),
+            chunkCount: cursor.readCount("chunk count", 2147483647), artifactSha256: cursor.readText()
+        });
+    }
+    cursor.requireEnd();
+    validateDecodedV2ResultManifest(manifest);
+    if (!manifest.bytes.equals(encodeLoadEngineV2ResultManifest(manifest))) {
+        throw new Error("Load Engine V2 manifest encoding is invalid.");
+    }
+    return manifest;
+}
+export function decodeLoadEngineV2ResultChunk(bytesValue, maximumChunkBytes) {
+    validateV2ResultChunkBound(maximumChunkBytes);
+    const bytes = Buffer.from(bytesValue);
+    if (bytes.length > maximumChunkBytes + 4096) {
+        throw new Error("Load Engine V2 result chunk exceeds its encoded bound.");
+    }
+    const cursor = new LoadEngineV2ResultCursor(bytes);
+    cursor.requireMagic("LS-RC1\n");
+    cursor.require("1", "result chunk version");
+    const runId = cursor.readText();
+    const sessionId = cursor.readText();
+    const resultOwnerId = cursor.readText();
+    const snapshotSequence64 = cursor.readNonNegative("snapshot sequence");
+    const manifestSha256 = cursor.readText();
+    const kind = cursor.readText();
+    const artifactId = cursor.readText();
+    const schema = cursor.readText();
+    const artifactSha256 = cursor.readText();
+    const chunkIndex = cursor.readCount("chunk index", 2147483647);
+    const chunkCount = cursor.readCount("chunk count", 2147483647);
+    const uncompressedTotalLength64 = cursor.readNonNegative("uncompressed total length");
+    const chunkLength = cursor.readCount("chunk length", maximumChunkBytes);
+    const chunkSha256 = cursor.readText();
+    const payload = cursor.readRaw(chunkLength);
+    cursor.requireEnd();
+    const result = {
+        runId, sessionId, resultOwnerId, snapshotSequence64, manifestSha256, kind,
+        artifactId, schema, artifactSha256, chunkIndex, chunkCount,
+        uncompressedTotalLength64, payload, chunkSha256, bytes
+    };
+    if (!hashEquals(sha256Hex(payload), chunkSha256)
+        || !bytes.equals(encodeLoadEngineV2ResultChunk(result))) {
+        throw new Error("Load Engine V2 result chunk hash or encoding is invalid.");
+    }
+    return result;
+}
+export function decodeLoadEngineV2ResultCommit(bytesValue) {
+    const bytes = Buffer.from(bytesValue);
+    if (bytes.length > 4096)
+        throw new Error("Load Engine V2 snapshot commit exceeds its encoded bound.");
+    const cursor = new LoadEngineV2ResultCursor(bytes);
+    cursor.requireMagic("LS-MC1\n");
+    cursor.require("1", "snapshot commit version");
+    const result = {
+        runId: cursor.readText(), sessionId: cursor.readText(), resultOwnerId: cursor.readText(),
+        snapshotSequence64: cursor.readNonNegative("snapshot sequence"), planHash: cursor.readText(),
+        manifestLength: cursor.readCount("manifest length", LOAD_ENGINE_V2_MAX_MANIFEST_BYTES),
+        manifestSha256: cursor.readText(),
+        entryCount: cursor.readCount("entry count", LOAD_ENGINE_V2_MAX_MANIFEST_ENTRIES),
+        totalNonDetailBytes64: cursor.readNonNegative("non-detail byte total"),
+        totalDetailBytes64: cursor.readNonNegative("detail byte total"), bytes
+    };
+    cursor.requireEnd();
+    if (!bytes.equals(encodeLoadEngineV2ResultCommit(result))) {
+        throw new Error("Load Engine V2 snapshot commit encoding is invalid.");
+    }
+    return result;
+}
+export class LoadEngineV2ResultSnapshotReceiver {
+    constructor(runId, sessionId, resultOwnerId, planHash, chunkBytes, maximumResultBytes) {
+        this.runId = runId;
+        this.sessionId = sessionId;
+        this.resultOwnerId = resultOwnerId;
+        this.planHash = planHash;
+        this.chunkBytes = chunkBytes;
+        this.maximumResultBytes = maximumResultBytes;
+        this.lastSequence = -1n;
+        this.lastManifestHash = "";
+        this.lastCommitBytes = Buffer.alloc(0);
+        this.lastArtifacts = new Map();
+        this.ownerLost = false;
+        validateV2ResultScope(runId, "run ID");
+        validateV2ResultScope(sessionId, "session ID");
+        validateV2ResultOwner(resultOwnerId);
+        validateLowercaseHash(planHash, "plan hash");
+        validateV2ResultChunkBound(chunkBytes);
+        if (!Number.isSafeInteger(maximumResultBytes) || maximumResultBytes <= 0) {
+            throw new RangeError("Load Engine V2 receiver bounds are invalid.");
+        }
+    }
+    begin(manifest) {
+        if (this.ownerLost)
+            throw new Error("Load Engine V2 result owner is sealed as lost.");
+        if (manifest.runId !== this.runId || manifest.sessionId !== this.sessionId
+            || manifest.resultOwnerId !== this.resultOwnerId || manifest.planHash !== this.planHash
+            || !manifest.bytes.equals(encodeLoadEngineV2ResultManifest(manifest))
+            || !hashEquals(manifest.hash, sha256Hex(manifest.bytes))) {
+            throw new Error("Load Engine V2 manifest has an unsigned scope or invalid hash.");
+        }
+        const sequence = BigInt(manifest.snapshotSequence64);
+        if (sequence === this.lastSequence && manifest.hash === this.lastManifestHash)
+            return;
+        if (sequence !== this.lastSequence + 1n) {
+            throw new Error("Load Engine V2 snapshot sequence is stale or skipped.");
+        }
+        if (this.pending) {
+            if (this.pending.manifest.hash === manifest.hash)
+                return;
+            throw new Error("Load Engine V2 result owner already has an uncommitted snapshot.");
+        }
+        let total = 0n;
+        for (const entry of manifest.entries) {
+            const length = BigInt(entry.uncompressedLength64);
+            if (entry.applicability === "present"
+                && entry.chunkCount !== Number((length + BigInt(this.chunkBytes) - 1n) / BigInt(this.chunkBytes))) {
+                throw new Error("Load Engine V2 manifest chunk count is not canonical for the signed chunk size.");
+            }
+            total += length;
+            if (total > BigInt(this.maximumResultBytes)) {
+                throw new Error("Load Engine V2 manifest exceeds receiver quota.");
+            }
+        }
+        this.pending = { manifest, chunks: new Map() };
+    }
+    add(chunk) {
+        const pending = this.pending;
+        if (!pending)
+            throw new Error("Load Engine V2 chunk has no active manifest.");
+        const manifest = pending.manifest;
+        if (chunk.runId !== this.runId || chunk.sessionId !== this.sessionId
+            || chunk.resultOwnerId !== this.resultOwnerId
+            || chunk.snapshotSequence64 !== manifest.snapshotSequence64
+            || chunk.manifestSha256 !== manifest.hash) {
+            throw new Error("Load Engine V2 result chunk identity is invalid.");
+        }
+        const entry = manifest.entries.find((value) => value.kind === chunk.kind && value.artifactId === chunk.artifactId);
+        if (!entry)
+            throw new Error("Load Engine V2 result chunk is undeclared.");
+        const offset = BigInt(chunk.chunkIndex) * BigInt(this.chunkBytes);
+        const length = BigInt(entry.uncompressedLength64);
+        const expectedLength = Number(length - offset < BigInt(this.chunkBytes)
+            ? length - offset : BigInt(this.chunkBytes));
+        if (entry.applicability !== "present" || entry.schema !== chunk.schema
+            || entry.artifactSha256 !== chunk.artifactSha256 || entry.chunkCount !== chunk.chunkCount
+            || entry.uncompressedLength64 !== chunk.uncompressedTotalLength64
+            || chunk.chunkIndex < 0 || chunk.chunkIndex >= chunk.chunkCount
+            || offset < 0n || offset >= length || chunk.payload.length !== expectedLength
+            || !hashEquals(chunk.chunkSha256, sha256Hex(chunk.payload))
+            || !chunk.bytes.equals(encodeLoadEngineV2ResultChunk(chunk))) {
+            throw new Error("Load Engine V2 result chunk hash, bounds, or declaration is invalid.");
+        }
+        const key = `${chunk.kind}/${chunk.artifactId}/${chunk.chunkIndex}`;
+        const existing = pending.chunks.get(key);
+        if (existing) {
+            if (!existing.bytes.equals(chunk.bytes)) {
+                throw new Error("Load Engine V2 result chunk retry changed bytes.");
+            }
+            return;
+        }
+        pending.chunks.set(key, chunk);
+    }
+    get hasCompleteSnapshot() {
+        if (!this.pending)
+            return false;
+        return this.pending.manifest.entries
+            .filter((entry) => entry.applicability === "present")
+            .every((entry) => Array.from({ length: entry.chunkCount }, (_, index) => this.pending.chunks.has(`${entry.kind}/${entry.artifactId}/${index}`)).every(Boolean));
+    }
+    commitSnapshot(commit) {
+        if (BigInt(commit.snapshotSequence64) === this.lastSequence
+            && commit.bytes.equals(this.lastCommitBytes))
+            return this.lastArtifacts;
+        const pending = this.pending;
+        if (!pending)
+            throw new Error("Load Engine V2 commit has no active manifest.");
+        const manifest = pending.manifest;
+        if (commit.runId !== this.runId || commit.sessionId !== this.sessionId
+            || commit.resultOwnerId !== this.resultOwnerId
+            || commit.snapshotSequence64 !== manifest.snapshotSequence64
+            || commit.planHash !== this.planHash || commit.manifestLength !== manifest.bytes.length
+            || commit.manifestSha256 !== manifest.hash || commit.entryCount !== manifest.entries.length
+            || !commit.bytes.equals(encodeLoadEngineV2ResultCommit(commit))) {
+            throw new Error("Load Engine V2 commit does not match its manifest.");
+        }
+        const artifacts = new Map();
+        let nonDetail = 0n;
+        let detail = 0n;
+        for (const entry of manifest.entries) {
+            const artifactKey = `${entry.kind}/${entry.artifactId}`;
+            if (entry.applicability === "present") {
+                const pieces = [];
+                for (let index = 0; index < entry.chunkCount; index += 1) {
+                    const chunk = pending.chunks.get(`${artifactKey}/${index}`);
+                    if (!chunk)
+                        throw new Error("Load Engine V2 commit is missing chunks.");
+                    pieces.push(chunk.payload);
+                }
+                const payload = Buffer.concat(pieces);
+                if (payload.length.toString() !== entry.uncompressedLength64
+                    || !hashEquals(sha256Hex(payload), entry.artifactSha256)) {
+                    throw new Error("Load Engine V2 reassembled artifact is invalid.");
+                }
+                artifacts.set(artifactKey, payload);
+            }
+            else if (entry.applicability === "empty") {
+                artifacts.set(artifactKey, Buffer.alloc(0));
+            }
+            const length = BigInt(entry.uncompressedLength64);
+            if (entry.kind === "correlation-detail")
+                detail += length;
+            else
+                nonDetail += length;
+        }
+        if (nonDetail.toString() !== commit.totalNonDetailBytes64
+            || detail.toString() !== commit.totalDetailBytes64) {
+            throw new Error("Load Engine V2 commit byte totals are invalid.");
+        }
+        this.lastSequence = BigInt(manifest.snapshotSequence64);
+        this.lastManifestHash = manifest.hash;
+        this.lastCommitBytes = Buffer.from(commit.bytes);
+        this.lastArtifacts = artifacts;
+        this.pending = undefined;
+        return artifacts;
+    }
+    sealOwnerLost() {
+        this.ownerLost = true;
+        this.pending = undefined;
+    }
+}
+function encodeLoadEngineV2ResultManifest(value) {
+    const fields = [Buffer.from("LS-M1\n", "ascii")];
+    const write = (textValue) => { fields.push(frameUtf8(textValue)); };
+    ["1", value.runId, value.sessionId, value.resultOwnerId, value.snapshotSequence64,
+        value.planHash, value.isFinal ? "1" : "0", value.correlationDetailPartCount.toString(),
+        value.entries.length.toString()].forEach(write);
+    value.entries.forEach((entry) => {
+        [entry.kind, entry.artifactId, entry.schema, entry.applicability,
+            entry.uncompressedLength64, entry.chunkCount.toString(), entry.artifactSha256].forEach(write);
+    });
+    return Buffer.concat(fields);
+}
+function encodeLoadEngineV2ResultChunk(value) {
+    const fields = [Buffer.from("LS-RC1\n", "ascii")];
+    const write = (textValue) => { fields.push(frameUtf8(textValue)); };
+    ["1", value.runId, value.sessionId, value.resultOwnerId, value.snapshotSequence64,
+        value.manifestSha256, value.kind, value.artifactId, value.schema, value.artifactSha256,
+        value.chunkIndex.toString(), value.chunkCount.toString(), value.uncompressedTotalLength64,
+        value.payload.length.toString(), value.chunkSha256].forEach(write);
+    fields.push(value.payload);
+    return Buffer.concat(fields);
+}
+function encodeLoadEngineV2ResultCommit(value) {
+    const fields = [Buffer.from("LS-MC1\n", "ascii")];
+    const write = (textValue) => { fields.push(frameUtf8(textValue)); };
+    ["1", value.runId, value.sessionId, value.resultOwnerId, value.snapshotSequence64,
+        value.planHash, value.manifestLength.toString(), value.manifestSha256,
+        value.entryCount.toString(), value.totalNonDetailBytes64, value.totalDetailBytes64].forEach(write);
+    return Buffer.concat(fields);
+}
+function validateV2ResultArtifactOrder(artifacts) {
+    if (artifacts.length < 5 || artifacts.length > LOAD_ENGINE_V2_MAX_MANIFEST_ENTRIES) {
+        throw new Error("Load Engine V2 manifest entry count is invalid.");
+    }
+    for (let index = 0; index < 5; index += 1) {
+        const artifact = artifacts[index];
+        const [kind, schema] = LOAD_ENGINE_V2_MAIN_ARTIFACTS[index];
+        if (artifact.kind !== kind || artifact.artifactId !== "main"
+            || (artifact.applicability !== "not-applicable" && artifact.schema !== schema)
+            || (index < 2 && artifact.applicability === "not-applicable")) {
+            throw new Error("Load Engine V2 manifest main entry order or schema is invalid.");
+        }
+    }
+    const detailCount = artifacts.length - 5;
+    if (detailCount > LOAD_ENGINE_V2_MAX_DETAIL_PARTS) {
+        throw new Error("Load Engine V2 detail part count exceeds its bound.");
+    }
+    for (let index = 0; index < detailCount; index += 1) {
+        const artifact = artifacts[index + 5];
+        if (artifact.kind !== "correlation-detail"
+            || artifact.artifactId !== `part-${index.toString().padStart(20, "0")}`
+            || artifact.schema !== "correlation-detail-v1" || artifact.applicability !== "present") {
+            throw new Error("Load Engine V2 correlation detail sequence is invalid.");
+        }
+    }
+}
+function validateDecodedV2ResultManifest(manifest) {
+    validateV2ResultScope(manifest.runId, "run ID");
+    validateV2ResultScope(manifest.sessionId, "session ID");
+    validateV2ResultOwner(manifest.resultOwnerId);
+    validateLowercaseHash(manifest.planHash, "plan hash");
+    validateV2ResultArtifactOrder(manifest.entries.map((entry) => ({
+        kind: entry.kind, artifactId: entry.artifactId, schema: entry.schema,
+        applicability: entry.applicability,
+        payload: entry.applicability === "present" ? Buffer.from([1]) : Buffer.alloc(0)
+    })));
+    for (const entry of manifest.entries) {
+        if (entry.applicability === "present") {
+            validateLowercaseHash(entry.artifactSha256, "artifact hash");
+            if (BigInt(entry.uncompressedLength64) <= 0n || entry.chunkCount <= 0) {
+                throw new Error("Load Engine V2 present manifest entry is invalid.");
+            }
+        }
+        else if (entry.applicability === "empty") {
+            if (entry.uncompressedLength64 !== "0" || entry.chunkCount !== 0
+                || entry.artifactSha256 !== LOAD_ENGINE_V2_RESULT_EMPTY_SHA256) {
+                throw new Error("Load Engine V2 empty manifest entry is invalid.");
+            }
+        }
+        else if (entry.applicability === "not-applicable") {
+            if (entry.schema !== "0" || entry.uncompressedLength64 !== "0"
+                || entry.chunkCount !== 0 || entry.artifactSha256 !== "") {
+                throw new Error("Load Engine V2 not-applicable manifest entry is invalid.");
+            }
+        }
+        else {
+            throw new Error("Load Engine V2 manifest applicability is invalid.");
+        }
+    }
+}
+function validateV2ResultScope(value, label) {
+    validateUnicodeScalars(value);
+    if (!value.trim() || Buffer.byteLength(value, "utf8") > 128) {
+        throw new Error(`Load Engine V2 ${label} is invalid.`);
+    }
+}
+function validateV2ResultOwner(value) {
+    validateUnicodeScalars(value);
+    if (Buffer.byteLength(value, "utf8") > 256) {
+        throw new Error("Load Engine V2 result owner ID is invalid.");
+    }
+}
+function validateV2ResultChunkBound(value) {
+    if (!Number.isSafeInteger(value) || value < 16384 || value > 262144) {
+        throw new RangeError("Load Engine V2 result chunk size must be from 16384 through 262144 bytes.");
+    }
+}
+class LoadEngineV2ResultCursor {
+    constructor(bytes) {
+        this.bytes = bytes;
+        this.position = 0;
+    }
+    requireMagic(value) {
+        const expected = Buffer.from(value, "ascii");
+        if (!this.bytes.subarray(this.position, this.position + expected.length).equals(expected)) {
+            throw new Error("Load Engine V2 artifact magic is invalid.");
+        }
+        this.position += expected.length;
+    }
+    readText() {
+        if (this.bytes.length - this.position < 4)
+            throw new Error("Load Engine V2 artifact is truncated.");
+        const length = this.bytes.readUInt32BE(this.position);
+        this.position += 4;
+        if (this.bytes.length - this.position < length)
+            throw new Error("Load Engine V2 artifact field is truncated.");
+        const raw = this.bytes.subarray(this.position, this.position + length);
+        this.position += length;
+        try {
+            return new TextDecoder("utf-8", { fatal: true }).decode(raw);
+        }
+        catch {
+            throw new Error("Load Engine V2 artifact field is not strict UTF-8.");
+        }
+    }
+    readRaw(length) {
+        if (length < 0 || this.bytes.length - this.position < length) {
+            throw new Error("Load Engine V2 artifact body is truncated.");
+        }
+        const value = Buffer.from(this.bytes.subarray(this.position, this.position + length));
+        this.position += length;
+        return value;
+    }
+    require(expected, field) {
+        if (this.readText() !== expected)
+            throw new Error(`Load Engine V2 ${field} is invalid.`);
+    }
+    readBit(field) {
+        const value = this.readText();
+        if (value === "0")
+            return false;
+        if (value === "1")
+            return true;
+        throw new Error(`Load Engine V2 ${field} is invalid.`);
+    }
+    readNonNegative(field) {
+        const value = this.readText();
+        parseCanonicalNonNegativeInt64(value, field);
+        return value;
+    }
+    readCount(field, maximum) {
+        const value = this.readNonNegative(field);
+        const parsed = BigInt(value);
+        if (parsed > BigInt(maximum))
+            throw new Error(`Load Engine V2 ${field} exceeds its bound.`);
+        return Number(parsed);
+    }
+    requireEnd() {
+        if (this.position !== this.bytes.length)
+            throw new Error("Load Engine V2 artifact has trailing bytes.");
+    }
+}
+export function createLoadEngineV2ResultChunks(result, chunkBytes = LOAD_ENGINE_V2_DEFAULT_CHUNK_BYTES) {
+    if (!Number.isSafeInteger(chunkBytes) || chunkBytes < 16384 || chunkBytes > 262144) {
+        throw new RangeError("Load Engine V2 result chunk size must be from 16384 through 262144 bytes.");
+    }
+    const payload = Buffer.from(JSON.stringify(result), "utf8");
+    if (payload.length > LOAD_ENGINE_V2_MAX_RESULT_BYTES) {
+        throw new Error("Load Engine V2 mergeable result exceeds the bounded result spool.");
+    }
+    const chunkCount = Math.max(1, Math.ceil(payload.length / chunkBytes));
+    const record = result;
+    const chunks = [];
+    for (let index = 0; index < chunkCount; index += 1) {
+        const data = payload.subarray(index * chunkBytes, Math.min((index + 1) * chunkBytes, payload.length));
+        chunks.push({
+            commandId: String(record.commandId ?? record.CommandId ?? ""),
+            agentId: String(record.agentId ?? record.AgentId ?? ""),
+            chunkIndex: index,
+            chunkCount,
+            totalLength64: payload.length.toString(),
+            payloadSha256: sha256Hex(payload),
+            chunkSha256: sha256Hex(data),
+            dataBase64: data.toString("base64")
+        });
+    }
+    return chunks;
+}
+export class LoadEngineV2ResultChunkAccumulator {
+    constructor(maximumResultBytes = LOAD_ENGINE_V2_MAX_RESULT_BYTES) {
+        this.maximumResultBytes = maximumResultBytes;
+        this.chunks = new Map();
+        this.complete = false;
+    }
+    add(message) {
+        const totalLength = Number(parseCanonicalNonNegativeInt64(message.totalLength64, "result total length"));
+        if (!Number.isSafeInteger(totalLength) || totalLength > this.maximumResultBytes
+            || message.chunkCount <= 0 || message.chunkIndex < 0 || message.chunkIndex >= message.chunkCount) {
+            throw new Error("Load Engine V2 result chunk bounds are invalid.");
+        }
+        validateLowercaseHash(message.payloadSha256, "result payload hash");
+        validateLowercaseHash(message.chunkSha256, "result chunk hash");
+        const data = Buffer.from(message.dataBase64, "base64");
+        if (data.length > 262144 || !hashEquals(sha256Hex(data), message.chunkSha256)) {
+            throw new Error("Load Engine V2 result chunk hash does not match its payload.");
+        }
+        const nextManifest = {
+            commandId: message.commandId,
+            agentId: message.agentId,
+            chunkCount: message.chunkCount,
+            totalLength64: message.totalLength64,
+            payloadSha256: message.payloadSha256
+        };
+        if (!this.manifest)
+            this.manifest = nextManifest;
+        else if (JSON.stringify(this.manifest) !== JSON.stringify(nextManifest)) {
+            throw new Error("Load Engine V2 result chunk manifest changed within one snapshot.");
+        }
+        const existing = this.chunks.get(message.chunkIndex);
+        if (existing) {
+            if (!existing.equals(data))
+                throw new Error("Load Engine V2 result chunk retry changed bytes.");
+            return undefined;
+        }
+        if (this.complete)
+            throw new Error("Load Engine V2 result stream is already complete.");
+        this.chunks.set(message.chunkIndex, data);
+        if (this.chunks.size !== message.chunkCount)
+            return undefined;
+        const payload = Buffer.concat(Array.from({ length: message.chunkCount }, (_, index) => {
+            const chunk = this.chunks.get(index);
+            if (!chunk)
+                throw new Error("Load Engine V2 result chunks are incomplete.");
+            return chunk;
+        }));
+        if (payload.length !== totalLength || !hashEquals(sha256Hex(payload), message.payloadSha256)) {
+            throw new Error("Load Engine V2 result snapshot hash or length is invalid.");
+        }
+        this.complete = true;
+        return JSON.parse(payload.toString("utf8"));
+    }
+}
+export function buildLoadEngineV2OwnerLoss(input) {
+    const missing = normalizeExpectedAgentIds(input.missingAgentIds);
+    const assignments = input.assignments.filter((value) => missing.includes(value.agentId));
+    const schedulerSegments = assignments.flatMap((assignment) => assignment.scenarios.flatMap((scenario) => scenario.simulations.map((simulation) => {
+        parseCanonicalNonNegativeInt64(simulation.plannedIterations64, "owned planned iterations");
+        return {
+            scenarioName: scenario.scenarioName,
+            scenarioIndex: Number(parseCanonicalNonNegativeInt64(scenario.scenarioIndex64, "scenario index")),
+            simulationIndex: Number(parseCanonicalNonNegativeInt64(simulation.simulationIndex64, "simulation index")),
+            kind: simulation.kind,
+            shardIndex: Number(parseCanonicalNonNegativeInt64(assignment.shardIndex64, "shard index")),
+            shardCount: Number(parseCanonicalNonNegativeInt64(assignment.shardCount64, "shard count")),
+            plannedIterations64: simulation.plannedIterations64,
+            dueIterations64: "0",
+            startedIterations64: "0",
+            completedIterations64: "0",
+            droppedIterations64: "0",
+            unreachedIterations64: simulation.plannedIterations64,
+            requestedWorkerSlots64: "0",
+            startedWorkerSlots64: "0",
+            unavailableWorkerSlots64: "0",
+            dropReasons: {},
+            unavailableWorkerReasons: {},
+            deliveryPercent: simulation.plannedIterations64 === "0" ? 100 : 0,
+            accountingComplete: false
+        };
+    })));
+    return {
+        reportingComplete: false,
+        applicationFailureCount64: "0",
+        generatorWarnings: missing.map((agentId) => ({ code: "cluster_result_owner_lost", agentId, count64: "1" })),
+        schedulerSegments
+    };
+}
 export class DistributedClusterCoordinator {
     /**
      * Exposes the public constructor operation.
@@ -133,8 +1577,8 @@ export class DistributedClusterCoordinator {
         const timeoutMs = Math.max(this.options.commandTimeoutMs ?? 120000, 1);
         const runSubject = this.buildRunSubject();
         const replySubject = this.buildReplySubject();
-        const commandProducer = EndpointAdapterFactory.create(this.natsEndpoint("Produce", "coordinator-command", runSubject));
-        const resultConsumer = EndpointAdapterFactory.create(this.natsEndpoint("Consume", "coordinator-result", replySubject));
+        const commandProducer = this.createAdapter(this.natsEndpoint("Produce", "coordinator-command", runSubject));
+        const resultConsumer = this.createAdapter(this.natsEndpoint("Consume", "coordinator-result", replySubject));
         try {
             // Prime the reply subscription before commands are published because core NATS subjects do not retain messages.
             await resultConsumer.consume();
@@ -192,12 +1636,19 @@ export class DistributedClusterCoordinator {
             await commandProducer.dispose?.().catch(() => { });
         }
     }
+    /** Runs the native V2 capability, targeted-command, barrier, and chunk-result protocol. */
+    async dispatchV2(assignments, planInput, buildAgentRunToken) {
+        return dispatchDistributedV2(this.options, assignments, planInput, buildAgentRunToken, (definition) => this.createAdapter(definition));
+    }
     buildRunSubject() {
         return `loadstrike.${sanitizeToken(this.options.clusterId)}.${sanitizeToken(this.options.agentGroup ?? "default")}.run`;
     }
     buildReplySubject() {
         return `loadstrike.${sanitizeToken(this.options.clusterId)}.${sanitizeToken(this.options.sessionId)}.reply.${randomUUID().replace(/-/g, "")}`;
     }
+    createAdapter(definition) {
+        return (this.options.adapterFactory ?? EndpointAdapterFactory).create(definition);
+    }
     natsEndpoint(mode, name, subject) {
         return {
             kind: "Nats",
@@ -212,6 +1663,303 @@ export class DistributedClusterCoordinator {
         };
     }
 }
+async function dispatchDistributedV2(options, assignments, planInput, buildAgentRunToken, createAdapter) {
+    if (options.loadEngineContractVersion !== 2) {
+        throw new Error("dispatchV2 requires LoadEngineContractVersion 2.");
+    }
+    const expected = normalizeExpectedAgentIds(options.expectedAgentIds ?? []);
+    if (options.expectedAgentResults !== expected.length || assignments.length !== expected.length) {
+        throw new Error("Load Engine V2 requires assignments for the exact ExpectedAgentIds set.");
+    }
+    if (planInput.sessionId !== options.sessionId) {
+        throw new Error("Load Engine V2 plan session does not match the coordinator session.");
+    }
+    const canonicalInput = { ...planInput, expectedAgentIds: expected };
+    const plan = buildLoadEngineV2Plan(canonicalInput);
+    const segments = orderedLoadEngineV2Segments(canonicalInput);
+    if (!segments.length) {
+        throw new Error("Load Engine V2 distributed execution requires at least one signed simulation segment.");
+    }
+    const timeoutMs = Math.max(options.commandTimeoutMs ?? 120000, 1);
+    const prefix = `loadstrike.${sanitizeToken(options.clusterId)}.${sanitizeToken(options.sessionId)}.v2`;
+    const helloSubject = `${prefix}.hello`;
+    const registerSubject = buildLoadEngineV2ScopedRegistrationSubject(canonicalInput.runId, canonicalInput.sessionId, canonicalInput.registrationNonce);
+    const controlSubject = `${prefix}.control.${sanitizeToken(canonicalInput.registrationNonce)}`;
+    const resultSubject = `${prefix}.result.${sanitizeToken(canonicalInput.registrationNonce)}`;
+    const endpoint = (mode, name, subject) => ({
+        kind: "Nats", mode, name, trackingField: "header:x-cluster-command-id",
+        nats: { ...(options.nats ?? {}), Subject: subject, StartFromEarliest: true }
+    });
+    const registrationConsumer = createAdapter(endpoint("Consume", "coordinator-v2-registration", registerSubject));
+    const controlConsumer = createAdapter(endpoint("Consume", "coordinator-v2-control", controlSubject));
+    const resultConsumer = createAdapter({
+        ...endpoint("Consume", "coordinator-v2-result", resultSubject),
+        contentType: "application/octet-stream", messagePayloadType: "binary"
+    });
+    const producers = [];
+    try {
+        await Promise.all([registrationConsumer.consume(), controlConsumer.consume(), resultConsumer.consume()]);
+        const helloProducer = createAdapter(endpoint("Produce", "coordinator-v2-hello", helloSubject));
+        producers.push(helloProducer);
+        const hello = createLoadEngineV2CoordinatorHello({
+            runId: canonicalInput.runId,
+            sessionId: canonicalInput.sessionId,
+            coordinatorNonce: canonicalInput.registrationNonce,
+            registrationSubject: registerSubject,
+            expiresUtcNs64: (utcNowNs() + BigInt(timeoutMs) * 1000000n).toString(),
+            expectedAgentIds: expected
+        });
+        const registrations = new Map();
+        const registrationDeadline = Date.now() + timeoutMs;
+        let lastHelloMs = 0;
+        while (registrations.size < expected.length && Date.now() < registrationDeadline) {
+            if (Date.now() - lastHelloMs >= 100) {
+                await helloProducer.produce({ headers: {}, body: hello });
+                lastHelloMs = Date.now();
+            }
+            const payload = await registrationConsumer.consume();
+            const body = recordOrUndefined(payload?.body);
+            if (!body) {
+                await sleep(5);
+                continue;
+            }
+            const registration = body;
+            if (!expected.includes(registration.agentId))
+                continue;
+            acceptLoadEngineV2RegistrationRenewal(registrations, registration, canonicalInput.runId, options.sessionId, canonicalInput.registrationNonce, utcNowNs64());
+        }
+        let negotiated = negotiateLoadEngineV2Registrations(canonicalInput.runId, options.sessionId, canonicalInput.registrationNonce, expected, [...registrations.values()], utcNowNs64());
+        const commandId = randomUUID().replace(/-/g, "");
+        const leadTimeMs = Math.max(options.barrierLeadTimeMs ?? 3000, 3000);
+        const assignmentRows = expected.map((agentId, index) => ({
+            agentId,
+            shardIndex64: index.toString(),
+            shardCount64: expected.length.toString(),
+            scenarioNames: [...(assignments[index] ?? [])]
+        }));
+        const commands = new Map();
+        for (const registration of negotiated) {
+            const index = expected.indexOf(registration.agentId);
+            const command = {
+                commandId,
+                sessionId: options.sessionId,
+                testSuite: options.testSuite,
+                testName: options.testName,
+                agentIndex: index,
+                agentCount: expected.length,
+                targetScenarios: [...(assignments[index] ?? [])]
+            };
+            if (buildAgentRunToken)
+                command.agentRunToken = await buildAgentRunToken(command);
+            commands.set(registration.agentId, command);
+        }
+        for (let segmentIndex = 0; segmentIndex < segments.length; segmentIndex += 1) {
+            const segment = segments[segmentIndex];
+            const barrierScopeId = buildLoadEngineV2BarrierScopeId(plan.hash, {
+                kind: "scenario",
+                scenarioIndex64: segment.scenarioIndex64,
+                simulationIndex64: segment.simulationIndex64
+            });
+            const barrierAssignments = expected.map((agentId, shardIndex) => ({
+                scenarioIndex64: segment.scenarioIndex64,
+                simulationIndex64: segment.simulationIndex64,
+                agentId,
+                shardIndex64: shardIndex.toString(),
+                shardCount64: expected.length.toString()
+            }));
+            const assignmentHash = buildLoadEngineV2AssignmentHash(barrierScopeId, barrierAssignments);
+            const barrierEpoch64 = segmentIndex.toString();
+            if (segmentIndex > 0) {
+                const previous = segments[segmentIndex - 1];
+                const previousScope = buildLoadEngineV2BarrierScopeId(plan.hash, {
+                    kind: "scenario", scenarioIndex64: previous.scenarioIndex64,
+                    simulationIndex64: previous.simulationIndex64
+                });
+                const previousAssignments = expected.map((agentId, shardIndex) => ({
+                    scenarioIndex64: previous.scenarioIndex64, simulationIndex64: previous.simulationIndex64,
+                    agentId, shardIndex64: shardIndex.toString(), shardCount64: expected.length.toString()
+                }));
+                const previousAssignmentHash = buildLoadEngineV2AssignmentHash(previousScope, previousAssignments);
+                const drained = await collectV2Acks(controlConsumer, "drained", expected, commandId, timeoutMs);
+                validateV2DrainAcks(expected, drained, plan.hash, previousAssignmentHash, (segmentIndex - 1).toString(), previousScope);
+            }
+            negotiated = await refreshLoadEngineV2Registrations(registrationConsumer, registrations, canonicalInput.runId, options.sessionId, canonicalInput.registrationNonce, expected, timeoutMs, BigInt(Math.max(options.barrierLeadTimeMs ?? 3000, 3000) + 1000) * 1000000n);
+            const coordinatorResolution = options.v2ClockResolutionNs64 ?? "1000000";
+            parseCanonicalNonNegativeInt64(coordinatorResolution, "coordinator clock resolution");
+            const clockSamples = new Map();
+            for (let probeIndex = 0; probeIndex < 5; probeIndex += 1) {
+                for (const registration of negotiated) {
+                    const producer = createAdapter(endpoint("Produce", `coordinator-v2-clock-${segmentIndex}-${registration.agentId}-${probeIndex}`, registration.targetSubject));
+                    producers.push(producer);
+                    await producer.produce({ headers: { "x-cluster-command-id": commandId }, body: {
+                            phase: "clock-probe", commandId, runId: canonicalInput.runId,
+                            sessionId: options.sessionId, coordinatorNonce: canonicalInput.registrationNonce,
+                            agentId: registration.agentId, probeIndex,
+                            coordinatorSendUtcNs64: utcNowNs64(),
+                            coordinatorClockResolutionNs64: coordinatorResolution,
+                            barrierEpoch64, barrierScopeId, replySubject: controlSubject
+                        } });
+                }
+                const round = await collectV2ClockProbeResults(controlConsumer, expected, commandId, probeIndex, timeoutMs, barrierEpoch64);
+                for (const [agentId, sample] of round) {
+                    const rows = clockSamples.get(agentId) ?? [];
+                    rows.push(sample);
+                    clockSamples.set(agentId, rows);
+                }
+            }
+            const selectedClocks = new Map(expected.map((agentId) => [
+                agentId, selectLoadEngineV2ClockProbe(clockSamples.get(agentId) ?? [])
+            ]));
+            const deadlineUtcNs64 = (utcNowNs() + BigInt(leadTimeMs) * 1000000n).toString();
+            for (const registration of negotiated) {
+                const index = expected.indexOf(registration.agentId);
+                const producer = createAdapter(endpoint("Produce", `coordinator-v2-prepare-${segmentIndex}-${index}`, registration.targetSubject));
+                producers.push(producer);
+                await producer.produce({ headers: { "x-cluster-command-id": commandId }, body: {
+                        ...commands.get(registration.agentId), phase: "prepare", agentId: registration.agentId,
+                        runId: canonicalInput.runId, coordinatorNonce: canonicalInput.registrationNonce,
+                        planInput: canonicalInput, planHash: plan.hash, barrierScopeId, barrierAssignments,
+                        assignmentHash, assignments: assignmentRows, barrierEpoch64, deadlineUtcNs64,
+                        replySubject: controlSubject, resultSubject,
+                        resultAckSubject: `${resultSubject}.ack.${sanitizeToken(registration.agentId)}`,
+                        negotiatedResultChunkBytes: LOAD_ENGINE_V2_DEFAULT_CHUNK_BYTES,
+                        leaseExpiresUtcNs64: registration.leaseExpiresUtcNs64,
+                        clockOffsetNs64: selectedClocks.get(registration.agentId).offsetAgentMinusCoordinatorNs64,
+                        clockUncertaintyNs64: selectedClocks.get(registration.agentId).uncertaintyNs64
+                    } });
+            }
+            const armed = await collectV2Acks(controlConsumer, "armed", expected, commandId, timeoutMs);
+            if (utcNowNs() >= parseCanonicalInt64(deadlineUtcNs64, "barrier deadline") - 1000000000n) {
+                throw new Error("Load Engine V2 armed barrier did not retain the required one-second commit window.");
+            }
+            validateLoadEngineV2BarrierAcks("armed", expected, armed, plan.hash, assignmentHash, barrierEpoch64, utcNowNs64(), barrierScopeId);
+            const armedHash = buildV2ArmedHash(armed);
+            for (const registration of negotiated) {
+                const producer = createAdapter(endpoint("Produce", `coordinator-v2-commit-${segmentIndex}-${registration.agentId}`, registration.targetSubject));
+                producers.push(producer);
+                await producer.produce({ headers: { "x-cluster-command-id": commandId }, body: {
+                        phase: "commit", commandId, runId: canonicalInput.runId, sessionId: options.sessionId,
+                        coordinatorNonce: canonicalInput.registrationNonce, agentId: registration.agentId,
+                        planHash: plan.hash, barrierScopeId, assignmentHash, barrierEpoch64,
+                        deadlineUtcNs64, armedHash, armedAcks: armed, replySubject: controlSubject, resultSubject
+                    } });
+            }
+            const committed = await collectV2Acks(controlConsumer, "committed", expected, commandId, timeoutMs);
+            validateLoadEngineV2BarrierAcks("committed", expected, committed, plan.hash, assignmentHash, barrierEpoch64, utcNowNs64(), barrierScopeId);
+        }
+        const finalSegment = segments[segments.length - 1];
+        const finalScope = buildLoadEngineV2BarrierScopeId(plan.hash, {
+            kind: "scenario", scenarioIndex64: finalSegment.scenarioIndex64,
+            simulationIndex64: finalSegment.simulationIndex64
+        });
+        const finalAssignments = expected.map((agentId, shardIndex) => ({
+            scenarioIndex64: finalSegment.scenarioIndex64, simulationIndex64: finalSegment.simulationIndex64,
+            agentId, shardIndex64: shardIndex.toString(), shardCount64: expected.length.toString()
+        }));
+        const finalDrained = await collectV2Acks(controlConsumer, "drained", expected, commandId, timeoutMs);
+        validateV2DrainAcks(expected, finalDrained, plan.hash, buildLoadEngineV2AssignmentHash(finalScope, finalAssignments), (segments.length - 1).toString(), finalScope);
+        const receivers = new Map(expected.map((agentId) => [
+            agentId,
+            new LoadEngineV2ResultSnapshotReceiver(canonicalInput.runId, canonicalInput.sessionId, agentId, plan.hash, LOAD_ENGINE_V2_DEFAULT_CHUNK_BYTES, LOAD_ENGINE_V2_MAX_RESULT_BYTES)
+        ]));
+        const results = new Map();
+        const resultDeadline = Date.now() + timeoutMs;
+        while (results.size < expected.length && Date.now() < resultDeadline) {
+            const payload = await resultConsumer.consume();
+            const bytes = loadEngineV2BinaryBody(payload?.body);
+            if (!bytes) {
+                await sleep(5);
+                continue;
+            }
+            if (bytes.subarray(0, 6).toString("ascii") === "LS-M1\n") {
+                const manifest = decodeLoadEngineV2ResultManifest(bytes);
+                const receiver = receivers.get(manifest.resultOwnerId);
+                if (!receiver || results.has(manifest.resultOwnerId)) {
+                    throw new Error("Load Engine V2 received a manifest for an unallocated result owner.");
+                }
+                receiver.begin(manifest);
+                continue;
+            }
+            if (bytes.subarray(0, 7).toString("ascii") === "LS-RC1\n") {
+                const chunk = decodeLoadEngineV2ResultChunk(bytes, LOAD_ENGINE_V2_DEFAULT_CHUNK_BYTES);
+                const receiver = receivers.get(chunk.resultOwnerId);
+                if (!receiver || results.has(chunk.resultOwnerId)) {
+                    throw new Error("Load Engine V2 received a chunk for an unallocated result owner.");
+                }
+                receiver.add(chunk);
+                continue;
+            }
+            if (bytes.subarray(0, 7).toString("ascii") !== "LS-MC1\n") {
+                throw new Error("Load Engine V2 result subject received an unknown canonical artifact.");
+            }
+            const commit = decodeLoadEngineV2ResultCommit(bytes);
+            const receiver = receivers.get(commit.resultOwnerId);
+            if (!receiver || results.has(commit.resultOwnerId)) {
+                throw new Error("Load Engine V2 received a commit for an unallocated result owner.");
+            }
+            if (!receiver.hasCompleteSnapshot)
+                continue;
+            const artifacts = receiver.commitSnapshot(commit);
+            const scheduler = artifacts.get("scheduler/main");
+            const histograms = artifacts.get("histograms/main");
+            if (!scheduler || !histograms) {
+                throw new Error("Load Engine V2 canonical result omits scheduler or histogram artifacts.");
+            }
+            let decoded;
+            try {
+                decoded = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(scheduler));
+            }
+            catch {
+                throw new Error("Load Engine V2 scheduler result artifact is invalid.");
+            }
+            const decodedRecord = recordOrUndefined(decoded);
+            if (!decodedRecord)
+                throw new Error("Load Engine V2 scheduler result artifact must be an object.");
+            const stats = recordOrUndefined(decodedRecord.stats ?? decodedRecord.Stats) ?? {};
+            decodedRecord.stats = { ...stats, histogramArtifactBase64: histograms.toString("base64") };
+            const parsed = parseRunResult(decodedRecord, true);
+            if (parsed.commandId !== commandId || parsed.agentId !== commit.resultOwnerId) {
+                throw new Error("Load Engine V2 canonical result identity does not match its command owner.");
+            }
+            results.set(commit.resultOwnerId, parsed);
+            const ackProducer = createAdapter(endpoint("Produce", `coordinator-v2-result-ack-${commit.resultOwnerId}`, `${resultSubject}.ack.${sanitizeToken(commit.resultOwnerId)}`));
+            producers.push(ackProducer);
+            await ackProducer.produce({ headers: { "x-cluster-command-id": commandId }, body: {
+                    phase: "result-ack", commandId, resultOwnerId: commit.resultOwnerId,
+                    snapshotSequence64: commit.snapshotSequence64,
+                    manifestSha256: commit.manifestSha256, accepted: true
+                } });
+        }
+        const nodeResults = expected.flatMap((agentId) => {
+            const result = results.get(agentId);
+            return result ? [convertRunResult(result)] : [];
+        });
+        const missingAgentIds = expected.filter((agentId) => !results.has(agentId));
+        const ownerLoss = missingAgentIds.length ? buildLoadEngineV2OwnerLoss({
+            missingAgentIds,
+            assignments: buildOwnerLossAssignments(canonicalInput, missingAgentIds, expected)
+        }) : undefined;
+        return {
+            nodeResults,
+            allRequestCount: nodeResults.reduce((sum, row) => sum + row.allRequestCount, 0),
+            allOkCount: nodeResults.reduce((sum, row) => sum + row.allOkCount, 0),
+            allFailCount: nodeResults.reduce((sum, row) => sum + row.allFailCount, 0),
+            failedNodes: nodeResults.filter((row) => !row.success).length,
+            missingNodes: missingAgentIds.length,
+            runSubject: registerSubject,
+            replySubject: resultSubject,
+            ownerLoss
+        };
+    }
+    finally {
+        await Promise.all([
+            registrationConsumer.dispose?.().catch(() => { }),
+            controlConsumer.dispose?.().catch(() => { }),
+            resultConsumer.dispose?.().catch(() => { }),
+            ...producers.map((producer) => producer.dispose?.().catch(() => { }))
+        ]);
+    }
+}
 export class DistributedClusterAgent {
     /**
      * Exposes the public constructor operation.
@@ -219,17 +1967,36 @@ export class DistributedClusterAgent {
      */
     constructor(options) {
         this.commandConsumer = null;
+        this.v2HelloConsumer = null;
+        this.v2CommandConsumer = null;
+        this.v2RegistrationProducer = null;
+        this.v2LastRegistrationMs = 0;
+        this.v2Hello = null;
+        this.v2CurrentRegistration = null;
+        this.v2RegistrationSequence = -1n;
+        this.v2RenewalTimer = null;
+        this.v2RenewalError = null;
+        this.v2Prepared = null;
         this.options = options;
     }
     async dispose() {
         await this.commandConsumer?.dispose?.().catch(() => { });
+        await this.v2HelloConsumer?.dispose?.().catch(() => { });
+        await this.v2CommandConsumer?.dispose?.().catch(() => { });
+        await this.v2RegistrationProducer?.dispose?.().catch(() => { });
+        if (this.v2RenewalTimer)
+            clearInterval(this.v2RenewalTimer);
         this.commandConsumer = null;
+        this.v2HelloConsumer = null;
+        this.v2CommandConsumer = null;
+        this.v2RegistrationProducer = null;
+        this.v2RenewalTimer = null;
     }
     async pollAndExecuteOnce(execute) {
         const runSubject = `loadstrike.${sanitizeToken(this.options.clusterId)}.${sanitizeToken(this.options.agentGroup ?? "default")}.run`;
         const queueGroup = `loadstrike.${sanitizeToken(this.options.clusterId)}.${sanitizeToken(this.options.agentGroup ?? "default")}.agents`;
         if (!this.commandConsumer) {
-            this.commandConsumer = EndpointAdapterFactory.create({
+            this.commandConsumer = this.createAdapter({
                 kind: "Nats",
                 mode: "Consume",
                 name: `agent-${this.options.agentId}`,
@@ -252,7 +2019,7 @@ export class DistributedClusterAgent {
         }
         const replySubject = stringOrDefault(payload.headers?.["x-cluster-reply-subject"], command.replySubject ?? "");
         const resultProducer = replySubject
-            ? EndpointAdapterFactory.create({
+            ? this.createAdapter({
                 kind: "Nats",
                 mode: "Produce",
                 name: `agent-${this.options.agentId}-result`,
@@ -307,6 +2074,373 @@ export class DistributedClusterAgent {
             await resultProducer?.dispose?.().catch(() => { });
         }
     }
+    /** Polls one targeted V2 message. A callback can run only after a matching commit. */
+    async pollAndExecuteV2Once(execute) {
+        if (this.options.loadEngineContractVersion !== 2) {
+            throw new Error("pollAndExecuteV2Once requires LoadEngineContractVersion 2.");
+        }
+        validateLoadEngineV2AgentId(this.options.agentId);
+        if (!(await this.ensureV2Registration()))
+            return false;
+        if (this.v2RenewalError)
+            throw this.v2RenewalError;
+        const payload = await this.ensureV2CommandConsumer().consume();
+        const body = recordOrUndefined(payload?.body);
+        if (!body)
+            return false;
+        const phase = String(body.phase ?? "");
+        if (String(body.agentId ?? "") !== this.options.agentId || !this.matchesV2Scope(body))
+            return false;
+        if (phase === "clock-probe") {
+            await this.publishV2ClockProbe(body);
+            return false;
+        }
+        if (phase === "abort") {
+            if (this.v2Prepared && body.assignmentHash === this.v2Prepared.assignmentHash
+                && body.barrierEpoch64 === this.v2Prepared.barrierEpoch64)
+                this.v2Prepared = null;
+            return false;
+        }
+        if (phase === "prepare") {
+            await this.acceptV2Prepare(body);
+            return false;
+        }
+        if (phase !== "commit")
+            return false;
+        let activeCommand = await this.acceptV2Commit(body);
+        const command = parseRunCommand(activeCommand);
+        const signedSegments = orderedLoadEngineV2Segments(activeCommand.planInput);
+        let activeSegmentIndex = -1;
+        let activeSegmentDrained = true;
+        const segmentLifecycle = {
+            beforeSegment: async (scenarioIndex, simulationIndex) => {
+                const nextIndex = activeSegmentIndex + 1;
+                const expected = signedSegments[nextIndex];
+                if (!expected || expected.scenarioIndex64 !== scenarioIndex.toString()
+                    || expected.simulationIndex64 !== simulationIndex.toString() || !activeSegmentDrained) {
+                    throw new Error("Load Engine V2 scheduler attempted a segment outside the signed serial order.");
+                }
+                if (nextIndex > 0) {
+                    for (;;) {
+                        const nextPayload = await this.ensureV2CommandConsumer().consume();
+                        const nextBody = recordOrUndefined(nextPayload?.body);
+                        if (!nextBody || String(nextBody.agentId ?? "") !== this.options.agentId
+                            || !this.matchesV2Scope(nextBody)) {
+                            await sleep(2);
+                            continue;
+                        }
+                        const nextPhase = String(nextBody.phase ?? "");
+                        if (nextPhase === "clock-probe") {
+                            if (String(nextBody.barrierEpoch64 ?? "") !== nextIndex.toString()) {
+                                throw new Error("Load Engine V2 clock probe does not match the next scoped epoch.");
+                            }
+                            await this.publishV2ClockProbe(nextBody);
+                            continue;
+                        }
+                        if (nextPhase === "prepare") {
+                            if (String(nextBody.barrierEpoch64 ?? "") !== nextIndex.toString()) {
+                                throw new Error("Load Engine V2 prepare does not match the next scoped epoch.");
+                            }
+                            await this.acceptV2Prepare(nextBody);
+                            continue;
+                        }
+                        if (nextPhase === "abort") {
+                            throw new Error("Load Engine V2 coordinator aborted the next scoped epoch.");
+                        }
+                        if (nextPhase !== "commit") {
+                            await sleep(2);
+                            continue;
+                        }
+                        activeCommand = await this.acceptV2Commit(nextBody);
+                        break;
+                    }
+                }
+                const expectedScope = buildLoadEngineV2BarrierScopeId(String(activeCommand.planHash), {
+                    kind: "scenario", scenarioIndex64: expected.scenarioIndex64,
+                    simulationIndex64: expected.simulationIndex64
+                });
+                if (String(activeCommand.barrierEpoch64) !== nextIndex.toString()
+                    || String(activeCommand.barrierScopeId) !== expectedScope) {
+                    throw new Error("Load Engine V2 committed scope does not match the scheduler segment.");
+                }
+                activeSegmentIndex = nextIndex;
+                activeSegmentDrained = false;
+            },
+            afterSegment: async (scenarioIndex, simulationIndex) => {
+                const expected = signedSegments[activeSegmentIndex];
+                if (!expected || activeSegmentDrained || expected.scenarioIndex64 !== scenarioIndex.toString()
+                    || expected.simulationIndex64 !== simulationIndex.toString()) {
+                    throw new Error("Load Engine V2 scheduler drain does not match the active scoped epoch.");
+                }
+                await this.publishV2Registration(true);
+                await this.publishV2Ack(activeCommand, "drained", true, {
+                    finalDeltaAcknowledged: true,
+                    accountingComplete: true
+                });
+                activeSegmentDrained = true;
+            }
+        };
+        let result;
+        try {
+            const node = await execute({
+                scenarioNames: command.targetScenarios,
+                commandId: command.commandId,
+                agentRunToken: command.agentRunToken,
+                agentIndex: command.agentIndex,
+                agentCount: command.agentCount,
+                segmentLifecycle
+            });
+            if (activeSegmentIndex !== signedSegments.length - 1 || !activeSegmentDrained) {
+                throw new Error("Load Engine V2 execution returned before every signed segment drained.");
+            }
+            result = {
+                commandId: command.commandId,
+                agentId: this.options.agentId,
+                isSuccess: node.success,
+                errorMessage: node.error,
+                stats: node.stats ?? {
+                    allRequestCount: node.allRequestCount,
+                    allOkCount: node.allOkCount,
+                    allFailCount: node.allFailCount
+                }
+            };
+        }
+        catch (error) {
+            result = {
+                commandId: command.commandId,
+                agentId: this.options.agentId,
+                isSuccess: false,
+                errorMessage: String(error ?? "agent execution failed"),
+                stats: {
+                    allRequestCount: 0,
+                    allOkCount: 0,
+                    allFailCount: 0,
+                    histogramArtifactBase64: EMPTY_LOAD_ENGINE_V2_HISTOGRAM_ARTIFACT_BASE64
+                }
+            };
+        }
+        try {
+            await this.publishV2CanonicalResult(activeCommand, result);
+        }
+        finally {
+            this.v2Prepared = null;
+        }
+        return true;
+    }
+    async publishV2CanonicalResult(command, result) {
+        const resultSubject = String(command.resultSubject ?? "");
+        const ackSubject = String(command.resultAckSubject ?? "");
+        const chunkBytes = Number(command.negotiatedResultChunkBytes ?? LOAD_ENGINE_V2_DEFAULT_CHUNK_BYTES);
+        if (!resultSubject || !ackSubject) {
+            throw new Error("Load Engine V2 canonical result subjects are incomplete.");
+        }
+        validateV2ResultChunkBound(chunkBytes);
+        const histogramBase64 = String(result.stats?.histogramArtifactBase64 ?? "");
+        const histogramBytes = Buffer.from(histogramBase64, "base64");
+        if (!histogramBase64 || histogramBytes.toString("base64") !== histogramBase64) {
+            throw new Error("Load Engine V2 canonical result requires a canonical histogram artifact.");
+        }
+        parseLoadEngineV2HistogramArtifact(histogramBytes);
+        const schedulerProjection = JSON.parse(JSON.stringify(result));
+        for (const key of ["stats", "details"]) {
+            const value = recordOrUndefined(schedulerProjection[key]);
+            if (value) {
+                delete value.histogramArtifactBase64;
+            }
+        }
+        const schedulerPayload = Buffer.from(JSON.stringify(schedulerProjection), "utf8");
+        const snapshot = createLoadEngineV2ResultSnapshot(String(command.runId), String(command.sessionId), this.options.agentId, "0", String(command.planHash), true, chunkBytes, [
+            loadEngineV2PresentArtifact("scheduler", "main", "scheduler-snapshot-v2", schedulerPayload),
+            loadEngineV2PresentArtifact("histograms", "main", "histogram-set-v1", histogramBytes),
+            loadEngineV2NotApplicableArtifact("correlations", "main"),
+            loadEngineV2NotApplicableArtifact("portal-deltas", "main"),
+            loadEngineV2NotApplicableArtifact("correlation-detail-index", "main")
+        ]);
+        const producer = this.createAdapter(this.endpoint("Produce", `agent-${this.options.agentId}-v2-result`, resultSubject, true));
+        const acknowledgement = this.createAdapter(this.endpoint("Consume", `agent-${this.options.agentId}-v2-result-ack`, ackSubject));
+        try {
+            await acknowledgement.consume();
+            for (let attempt = 0; attempt < 5; attempt += 1) {
+                for (const bytes of [
+                    snapshot.manifest.bytes,
+                    ...snapshot.chunks.map((chunk) => chunk.bytes),
+                    snapshot.commit.bytes
+                ]) {
+                    await producer.produce({
+                        headers: { "x-cluster-command-id": result.commandId },
+                        body: bytes,
+                        contentType: "application/octet-stream",
+                        messagePayloadType: "binary"
+                    });
+                }
+                const deadline = Date.now() + 100 * (2 ** attempt);
+                while (Date.now() < deadline) {
+                    const payload = await acknowledgement.consume();
+                    const body = recordOrUndefined(payload?.body);
+                    if (body?.phase === "result-ack" && body.accepted === true
+                        && body.commandId === result.commandId && body.resultOwnerId === this.options.agentId
+                        && body.snapshotSequence64 === snapshot.commit.snapshotSequence64
+                        && body.manifestSha256 === snapshot.commit.manifestSha256)
+                        return;
+                    await sleep(5);
+                }
+            }
+            throw new Error("Load Engine V2 canonical result acknowledgement timed out.");
+        }
+        finally {
+            await Promise.all([
+                producer.dispose?.().catch(() => { }),
+                acknowledgement.dispose?.().catch(() => { })
+            ]);
+        }
+    }
+    async publishV2ClockProbe(body) {
+        const a1 = utcNowNs64();
+        const agentResolution = this.options.v2ClockResolutionNs64 ?? "1000000";
+        parseCanonicalNonNegativeInt64(agentResolution, "agent clock resolution");
+        const producer = this.createAdapter(this.endpoint("Produce", `agent-${this.options.agentId}-v2-clock`, String(body.replySubject)));
+        try {
+            await producer.produce({ headers: { "x-cluster-command-id": String(body.commandId) }, body: {
+                    phase: "clock-probe-result", commandId: String(body.commandId), agentId: this.options.agentId,
+                    probeIndex: Number(body.probeIndex), barrierEpoch64: String(body.barrierEpoch64 ?? "0"),
+                    coordinatorSendUtcNs64: String(body.coordinatorSendUtcNs64),
+                    agentReceiveUtcNs64: a1, agentSendUtcNs64: utcNowNs64(),
+                    coordinatorClockResolutionNs64: String(body.coordinatorClockResolutionNs64),
+                    agentClockResolutionNs64: agentResolution
+                } });
+        }
+        finally {
+            await producer.dispose?.().catch(() => { });
+        }
+    }
+    async acceptV2Prepare(body) {
+        const planInput = body.planInput;
+        this.options.validateV2Plan?.(planInput);
+        const recomputed = buildLoadEngineV2Plan(planInput);
+        const barrierAssignments = body.barrierAssignments;
+        const assignmentHash = buildLoadEngineV2AssignmentHash(String(body.barrierScopeId), barrierAssignments);
+        const deadline = parseCanonicalInt64(String(body.deadlineUtcNs64), "barrier deadline");
+        const leaseExpiry = parseCanonicalInt64(String(body.leaseExpiresUtcNs64), "registration lease expiry");
+        const now = utcNowNs();
+        if (!hashEquals(recomputed.hash, String(body.planHash))
+            || !hashEquals(assignmentHash, String(body.assignmentHash))
+            || !barrierAssignments.some((row) => row.agentId === this.options.agentId)
+            || deadline - now < 1000000000n || leaseExpiry <= now) {
+            throw new Error("Load Engine V2 targeted prepare failed signed plan, assignment, lead-time, or lease validation.");
+        }
+        this.v2Prepared = { ...body, receivedMonotonicNs64: process.hrtime.bigint().toString() };
+        await this.publishV2Ack(body, "armed", true);
+    }
+    async acceptV2Commit(body) {
+        const prepared = this.v2Prepared;
+        if (!prepared || prepared.commandId !== body.commandId || prepared.planHash !== body.planHash
+            || prepared.barrierScopeId !== body.barrierScopeId || prepared.assignmentHash !== body.assignmentHash
+            || prepared.barrierEpoch64 !== body.barrierEpoch64 || prepared.deadlineUtcNs64 !== body.deadlineUtcNs64) {
+            throw new Error("Load Engine V2 commit does not match a prepared scoped epoch.");
+        }
+        const armedAcks = Array.isArray(body.armedAcks) ? body.armedAcks : [];
+        if (!hashEquals(buildV2ArmedHash(armedAcks), String(body.armedHash))) {
+            throw new Error("Load Engine V2 commit armed-acknowledgement hash is invalid.");
+        }
+        const deadline = parseCanonicalInt64(String(body.deadlineUtcNs64), "barrier deadline");
+        const leaseExpiry = parseCanonicalNonNegativeInt64(String(prepared.leaseExpiresUtcNs64), "registration lease expiry");
+        if (deadline - utcNowNs() < 100000000n || leaseExpiry <= utcNowNs()) {
+            throw new Error("Load Engine V2 commit arrived too late to start traffic.");
+        }
+        const committed = { ...prepared, ...body };
+        await this.publishV2Ack(committed, "committed", true);
+        const delayMs = Number((deadline - utcNowNs()) / 1000000n);
+        if (delayMs > 0)
+            await sleep(delayMs);
+        return committed;
+    }
+    async ensureV2Registration() {
+        const prefix = `loadstrike.${sanitizeToken(this.options.clusterId)}.${sanitizeToken(this.options.sessionId)}.v2`;
+        if (!this.v2HelloConsumer) {
+            this.v2HelloConsumer = this.createAdapter(this.endpoint("Consume", `agent-${this.options.agentId}-v2-hello`, `${prefix}.hello`));
+        }
+        if (!this.v2Hello) {
+            const payload = await this.v2HelloConsumer.consume();
+            const body = recordOrUndefined(payload?.body);
+            if (!body)
+                return false;
+            const hello = body;
+            validateLoadEngineV2CoordinatorHello(hello, this.options.sessionId, this.options.agentId, utcNowNs64());
+            this.v2Hello = hello;
+            this.v2RegistrationProducer = this.createAdapter(this.endpoint("Produce", `agent-${this.options.agentId}-v2-registration`, hello.registrationSubject));
+            this.v2CommandConsumer = this.createAdapter(this.endpoint("Consume", `agent-${this.options.agentId}-v2-command`, buildLoadEngineV2ScopedTargetSubject(hello.runId, hello.sessionId, hello.coordinatorNonce, this.options.agentId)));
+            await this.v2CommandConsumer.initialize?.();
+            await this.publishV2Registration(true);
+            this.v2RenewalTimer = setInterval(() => {
+                void this.publishV2Registration(true).catch((error) => { this.v2RenewalError = error; });
+            }, 10000);
+            this.v2RenewalTimer.unref?.();
+            return true;
+        }
+        if (Date.now() - this.v2LastRegistrationMs >= 100)
+            await this.publishV2Registration(false);
+        return true;
+    }
+    ensureV2CommandConsumer() {
+        if (!this.v2CommandConsumer) {
+            throw new Error("Load Engine V2 command consumer requires an authenticated coordinator hello.");
+        }
+        return this.v2CommandConsumer;
+    }
+    async publishV2Registration(renewLease) {
+        const hello = this.v2Hello;
+        const producer = this.v2RegistrationProducer;
+        if (!hello || !producer)
+            throw new Error("Load Engine V2 registration requires an authenticated coordinator hello.");
+        if (!this.v2CurrentRegistration || renewLease) {
+            this.v2RegistrationSequence += 1n;
+            const issued = utcNowNs();
+            this.v2CurrentRegistration = createLoadEngineV2Registration({
+                runId: hello.runId,
+                sessionId: hello.sessionId,
+                coordinatorNonce: hello.coordinatorNonce,
+                agentId: this.options.agentId,
+                targetSubject: buildLoadEngineV2ScopedTargetSubject(hello.runId, hello.sessionId, hello.coordinatorNonce, this.options.agentId),
+                registrationSequence64: this.v2RegistrationSequence.toString(),
+                leaseIssuedUtcNs64: issued.toString(),
+                leaseExpiresUtcNs64: (issued + 30000000000n).toString(),
+                capabilities: this.options.v2Capabilities
+            });
+        }
+        await producer.produce({ headers: {}, body: this.v2CurrentRegistration });
+        this.v2LastRegistrationMs = Date.now();
+    }
+    matchesV2Scope(body) {
+        const hello = this.v2Hello;
+        return !!hello && String(body.runId ?? "") === hello.runId
+            && String(body.sessionId ?? "") === hello.sessionId
+            && String(body.coordinatorNonce ?? "") === hello.coordinatorNonce;
+    }
+    async publishV2Ack(command, phase, accepted, extra = {}) {
+        const producer = this.createAdapter(this.endpoint("Produce", `agent-${this.options.agentId}-v2-${phase}`, String(command.replySubject)));
+        try {
+            await producer.produce({ headers: { "x-cluster-command-id": String(command.commandId) }, body: {
+                    phase, commandId: String(command.commandId), agentId: this.options.agentId, accepted,
+                    planHash: String(command.planHash), barrierScopeId: String(command.barrierScopeId),
+                    assignmentHash: String(command.assignmentHash), barrierEpoch64: String(command.barrierEpoch64),
+                    deadlineUtcNs64: String(command.deadlineUtcNs64), acknowledgedUtcNs64: utcNowNs64(),
+                    ...extra
+                } });
+        }
+        finally {
+            await producer.dispose?.().catch(() => { });
+        }
+    }
+    endpoint(mode, name, subject, binary = false) {
+        return {
+            kind: "Nats", mode, name, trackingField: "header:x-cluster-command-id",
+            nats: { ...(this.options.nats ?? {}), Subject: subject, StartFromEarliest: true },
+            ...(binary ? { contentType: "application/octet-stream", messagePayloadType: "binary" } : {})
+        };
+    }
+    createAdapter(definition) {
+        return (this.options.adapterFactory ?? EndpointAdapterFactory).create(definition);
+    }
 }
 function parseRunCommand(value) {
     const targetScenarios = Array.isArray(value.targetScenarios)
@@ -326,11 +2460,24 @@ function parseRunCommand(value) {
         replySubject: stringOrDefault(value.replySubject, stringOrDefault(value.ReplySubject, ""))
     };
 }
-function parseRunResult(value) {
+function parseRunResult(value, requireHistogramArtifact = false) {
     const statsValue = value.stats ?? value.Stats;
     const statsRecord = statsValue && typeof statsValue === "object" && !Array.isArray(statsValue)
         ? statsValue
         : null;
+    const histogramArtifactBase64 = statsRecord
+        ? stringOrDefault(statsRecord.histogramArtifactBase64, stringOrDefault(statsRecord.HistogramArtifactBase64, ""))
+        : "";
+    if (requireHistogramArtifact && !histogramArtifactBase64) {
+        throw new Error("Load Engine V2 completed result requires a canonical histogram artifact.");
+    }
+    if (histogramArtifactBase64) {
+        const decoded = Buffer.from(histogramArtifactBase64, "base64");
+        if (decoded.toString("base64") !== histogramArtifactBase64) {
+            throw new Error("Load Engine V2 histogram artifact base64 is not canonical.");
+        }
+        parseLoadEngineV2HistogramArtifact(decoded);
+    }
     return {
         commandId: stringOrDefault(value.commandId, stringOrDefault(value.CommandId, "")),
         agentId: stringOrDefault(value.agentId, stringOrDefault(value.AgentId, "")),
@@ -348,7 +2495,20 @@ function parseRunResult(value) {
                 thresholds: arrayOrUndefined(statsRecord.thresholds ?? statsRecord.Thresholds),
                 pluginsData: arrayOrUndefined(statsRecord.pluginsData ?? statsRecord.PluginsData),
                 nodeInfo: recordOrUndefined(statsRecord.nodeInfo ?? statsRecord.NodeInfo),
-                testInfo: recordOrUndefined(statsRecord.testInfo ?? statsRecord.TestInfo)
+                testInfo: recordOrUndefined(statsRecord.testInfo ?? statsRecord.TestInfo),
+                logFiles: arrayOrUndefined(statsRecord.logFiles ?? statsRecord.LogFiles)?.map((value) => String(value)),
+                generatorWarnings: arrayOrUndefined(statsRecord.generatorWarnings ?? statsRecord.GeneratorWarnings),
+                observationDeliveryStats: recordOrUndefined(statsRecord.observationDeliveryStats ?? statsRecord.ObservationDeliveryStats),
+                schedulerSegments: arrayOrUndefined(statsRecord.schedulerSegments ?? statsRecord.SchedulerSegments),
+                schedulerStats: recordOrUndefined(statsRecord.schedulerStats ?? statsRecord.SchedulerStats),
+                histogramSidecars: arrayOrUndefined(statsRecord.histogramSidecars ?? statsRecord.HistogramSidecars),
+                ...(histogramArtifactBase64 ? { histogramArtifactBase64 } : {}),
+                ...(Object.prototype.hasOwnProperty.call(statsRecord, "reportingComplete")
+                    || Object.prototype.hasOwnProperty.call(statsRecord, "ReportingComplete")
+                    ? {
+                        reportingComplete: booleanOrDefault(statsRecord.reportingComplete, booleanOrDefault(statsRecord.ReportingComplete, false))
+                    }
+                    : {})
             }
             : undefined
     };
@@ -364,12 +2524,224 @@ function convertRunResult(result) {
         error: result.errorMessage ?? ""
     };
 }
+function utcNowNs() {
+    return BigInt(Date.now()) * 1000000n;
+}
+function utcNowNs64() {
+    return utcNowNs().toString();
+}
+async function collectV2Acks(consumer, phase, expectedAgentIds, commandId, timeoutMs) {
+    const byAgent = new Map();
+    const deadline = Date.now() + timeoutMs;
+    while (byAgent.size < expectedAgentIds.length && Date.now() < deadline) {
+        const payload = await consumer.consume();
+        const body = recordOrUndefined(payload?.body);
+        if (!body || body.phase !== phase || body.commandId !== commandId) {
+            await sleep(5);
+            continue;
+        }
+        const acknowledgement = body;
+        if (!expectedAgentIds.includes(acknowledgement.agentId))
+            continue;
+        const previous = byAgent.get(acknowledgement.agentId);
+        if (previous && JSON.stringify(previous) !== JSON.stringify(acknowledgement)) {
+            throw new Error(`Load Engine V2 ${phase} acknowledgement changed during retry.`);
+        }
+        byAgent.set(acknowledgement.agentId, acknowledgement);
+    }
+    return [...byAgent.values()];
+}
+async function collectV2ClockProbeResults(consumer, expectedAgentIds, commandId, probeIndex, timeoutMs, barrierEpoch64) {
+    const results = new Map();
+    const deadline = Date.now() + timeoutMs;
+    while (results.size < expectedAgentIds.length && Date.now() < deadline) {
+        const payload = await consumer.consume();
+        const body = recordOrUndefined(payload?.body);
+        if (!body || body.phase !== "clock-probe-result" || body.commandId !== commandId
+            || Number(body.probeIndex) !== probeIndex
+            || (barrierEpoch64 !== undefined && String(body.barrierEpoch64 ?? "") !== barrierEpoch64)) {
+            await sleep(2);
+            continue;
+        }
+        const agentId = String(body.agentId ?? "");
+        if (!expectedAgentIds.includes(agentId))
+            continue;
+        results.set(agentId, {
+            probeIndex,
+            coordinatorSendUtcNs64: String(body.coordinatorSendUtcNs64),
+            agentReceiveUtcNs64: String(body.agentReceiveUtcNs64),
+            agentSendUtcNs64: String(body.agentSendUtcNs64),
+            coordinatorReceiveUtcNs64: utcNowNs64(),
+            coordinatorClockResolutionNs64: String(body.coordinatorClockResolutionNs64),
+            agentClockResolutionNs64: String(body.agentClockResolutionNs64)
+        });
+    }
+    if (results.size !== expectedAgentIds.length) {
+        throw new Error("Load Engine V2 clock negotiation is missing an exact participant probe response.");
+    }
+    return results;
+}
+function validateV2DrainAcks(expectedAgentIds, acknowledgements, planHash, assignmentHash, barrierEpoch64, barrierScopeId) {
+    const expected = normalizeExpectedAgentIds(expectedAgentIds);
+    const ordered = [...acknowledgements].sort((left, right) => compareAgentIds(left.agentId, right.agentId));
+    if (ordered.length !== expected.length || ordered.some((value, index) => value.agentId !== expected[index])) {
+        throw new Error("Load Engine V2 drained barrier is missing an exact participant acknowledgement.");
+    }
+    for (const acknowledgement of ordered) {
+        const row = acknowledgement;
+        parseCanonicalInt64(row.acknowledgedUtcNs64, "drain acknowledgement time");
+        if (!row.accepted || row.phase !== "drained" || row.planHash !== planHash
+            || row.assignmentHash !== assignmentHash || row.barrierScopeId !== barrierScopeId
+            || row.barrierEpoch64 !== barrierEpoch64 || row.finalDeltaAcknowledged !== true
+            || row.accountingComplete !== true) {
+            throw new Error("Load Engine V2 drained acknowledgement is invalid.");
+        }
+    }
+}
+function buildV2ArmedHash(acknowledgements) {
+    const fields = [Buffer.from("LS-AR1\n", "ascii"), frameUtf8("1")];
+    const ordered = [...acknowledgements].sort((left, right) => compareAgentIds(left.agentId, right.agentId));
+    fields.push(frameUtf8(ordered.length.toString()));
+    for (const acknowledgement of ordered) {
+        for (const value of [
+            acknowledgement.agentId,
+            acknowledgement.planHash,
+            acknowledgement.barrierScopeId ?? "",
+            acknowledgement.assignmentHash,
+            acknowledgement.barrierEpoch64,
+            acknowledgement.deadlineUtcNs64,
+            acknowledgement.acknowledgedUtcNs64
+        ])
+            fields.push(frameUtf8(value));
+    }
+    return sha256Hex(Buffer.concat(fields));
+}
+function buildOwnerLossAssignments(plan, missingAgentIds, expectedAgentIds) {
+    return missingAgentIds.map((agentId) => {
+        const shardIndex = expectedAgentIds.indexOf(agentId);
+        return {
+            agentId,
+            shardIndex64: shardIndex.toString(),
+            shardCount64: expectedAgentIds.length.toString(),
+            scenarios: plan.scenarios.filter((scenario) => scenario.target === "agent").map((scenario) => ({
+                scenarioName: scenario.scenarioName,
+                scenarioIndex64: scenario.scenarioIndex64,
+                simulations: scenario.simulations.map((simulation) => ({
+                    simulationIndex64: simulation.simulationIndex64,
+                    kind: simulation.kind,
+                    plannedIterations64: ownedPlannedIterations(simulation, shardIndex, expectedAgentIds.length).toString()
+                }))
+            }))
+        };
+    });
+}
+function ownedPlannedIterations(simulation, shardIndex, shardCount) {
+    let global = 0n;
+    if (simulation.kind === "iterations-for-inject" || simulation.kind === "iterations-for-constant") {
+        global = parseCanonicalNonNegativeInt64(simulation.iterations64, "planned iterations");
+    }
+    else if (simulation.kind === "inject") {
+        const duration = parseCanonicalNonNegativeInt64(simulation.durationNs64, "duration");
+        const interval = parseCanonicalNonNegativeInt64(simulation.intervalNs64, "interval");
+        const rate = parseCanonicalNonNegativeInt64(simulation.rate64, "rate");
+        if (duration > 0n && interval > 0n)
+            global = ((duration + interval - 1n) / interval) * rate;
+    }
+    const index = BigInt(shardIndex);
+    const count = BigInt(shardCount);
+    return global <= index ? 0n : ((global - 1n - index) / count) + 1n;
+}
 function sanitizeToken(value) {
     if (!value.trim()) {
         return "default";
     }
     return value.replace(/[^a-zA-Z0-9\-_]/g, "_");
 }
+function validateLoadEngineV2AgentId(agentId) {
+    if (!agentId)
+        throw new Error("Load Engine V2 remote agents require an explicit stable AgentId.");
+    validateUnicodeScalars(agentId);
+    if (Buffer.byteLength(agentId, "utf8") > 256) {
+        throw new Error("Load Engine V2 AgentId must be at most 256 UTF-8 bytes.");
+    }
+}
+function normalizeExpectedAgentIds(values) {
+    if (!values.length)
+        throw new Error("Load Engine V2 requires an exact ExpectedAgentIds participant set.");
+    values.forEach(validateLoadEngineV2AgentId);
+    if (new Set(values).size !== values.length) {
+        throw new Error("Load Engine V2 expected agent identities must be unique.");
+    }
+    return [...values].sort(compareUtf8);
+}
+function compareUtf8(left, right) {
+    validateUnicodeScalars(left);
+    validateUnicodeScalars(right);
+    return Buffer.compare(Buffer.from(left, "utf8"), Buffer.from(right, "utf8"));
+}
+function compareAgentIds(left, right) {
+    return compareUtf8(left, right);
+}
+function validateUnicodeScalars(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (code >= 0xd800 && code <= 0xdbff) {
+            const next = value.charCodeAt(index + 1);
+            if (next < 0xdc00 || next > 0xdfff)
+                throw new Error("Load Engine V2 text must contain valid Unicode scalars.");
+            index += 1;
+        }
+        else if (code >= 0xdc00 && code <= 0xdfff) {
+            throw new Error("Load Engine V2 text must contain valid Unicode scalars.");
+        }
+    }
+}
+function frameUtf8(value) {
+    validateUnicodeScalars(value);
+    const bytes = Buffer.from(value, "utf8");
+    const frame = Buffer.allocUnsafe(4 + bytes.length);
+    frame.writeUInt32BE(bytes.length, 0);
+    bytes.copy(frame, 4);
+    return frame;
+}
+function parseCanonicalInt64(value, field) {
+    if (!/^-?(0|[1-9][0-9]*)$/.test(value) || value === "-0") {
+        throw new Error(`${field} must be a canonical decimal string.`);
+    }
+    const parsed = BigInt(value);
+    if (parsed < -9223372036854775808n || parsed > 9223372036854775807n) {
+        throw new Error(`${field} exceeds signed 64-bit storage.`);
+    }
+    return parsed;
+}
+function parseCanonicalNonNegativeInt64(value, field) {
+    const parsed = parseCanonicalInt64(value, field);
+    if (parsed < 0n)
+        throw new Error(`${field} must be non-negative.`);
+    return parsed;
+}
+function compareCanonicalIntegers(left, right) {
+    const leftValue = parseCanonicalNonNegativeInt64(left, "canonical index");
+    const rightValue = parseCanonicalNonNegativeInt64(right, "canonical index");
+    return leftValue < rightValue ? -1 : leftValue > rightValue ? 1 : 0;
+}
+function validateLowercaseHash(value, field) {
+    if (!/^[0-9a-f]{64}$/.test(value)) {
+        throw new Error(`Load Engine V2 ${field} must be 64 lowercase hexadecimal characters.`);
+    }
+}
+function sha256Hex(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function hashEquals(left, right) {
+    validateLowercaseHash(left, "hash");
+    validateLowercaseHash(right, "hash");
+    return timingSafeEqual(Buffer.from(left, "hex"), Buffer.from(right, "hex"));
+}
+function requireCapability(offered, required, display) {
+    if (!offered.includes(required))
+        throw new Error(`Load Engine V2 capability negotiation requires ${display}.`);
+}
 function buildWeightedCycle(weights) {
     const cycle = [];
     for (let i = 0; i < weights.length; i += 1) {
@@ -402,6 +2774,13 @@ function recordOrUndefined(value) {
         ? value
         : undefined;
 }
+function loadEngineV2BinaryBody(value) {
+    if (value instanceof Uint8Array)
+        return Buffer.from(value);
+    if (value instanceof ArrayBuffer)
+        return Buffer.from(value);
+    return undefined;
+}
 function arrayOrUndefined(value) {
     return Array.isArray(value) ? value : undefined;
 }