@distrohelena/canton-typescript-sdk 0.1.28 → 0.1.30

package/dist/cjs/testing/daml/daml-value-arbitrary.js

@@ -0,0 +1,79 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDamlValueArbitrary = createDamlValueArbitrary;
+const fc = __importStar(require("fast-check"));
+const daml_numeric_js_1 = require("../../core/types/daml-numeric.js");
+const daml_party_js_1 = require("../../core/types/daml-party.js");
+const daml_lf_builtin_type_js_1 = require("../../daml-lf/model/daml-lf-builtin-type.js");
+const testing_configuration_error_js_1 = require("../errors/testing-configuration-error.js");
+function createDamlValueArbitrary(type, options = {}) {
+    if (type.typeConReference !== undefined) {
+        throw new testing_configuration_error_js_1.TestingConfigurationError("Automatic DAML value generation does not yet support type constructors.");
+    }
+    switch (type.builtinType) {
+        case daml_lf_builtin_type_js_1.DamlLfBuiltinType.text:
+            return fc.string({ maxLength: 64 });
+        case daml_lf_builtin_type_js_1.DamlLfBuiltinType.int64:
+            return fc.bigInt({
+                min: -(2n ** 63n),
+                max: (2n ** 63n) - 1n,
+            });
+        case daml_lf_builtin_type_js_1.DamlLfBuiltinType.numeric:
+            return createNumericArbitrary(type.numericScale);
+        case daml_lf_builtin_type_js_1.DamlLfBuiltinType.party:
+            if (options.valueParties === undefined || options.valueParties.length === 0) {
+                throw new testing_configuration_error_js_1.TestingConfigurationError("Automatic DAML party generation requires non-empty valueParties.");
+            }
+            return fc.constantFrom(...options.valueParties).map((party) => new daml_party_js_1.DamlParty(party));
+        default:
+            throw new testing_configuration_error_js_1.TestingConfigurationError(`Automatic DAML value generation does not support '${type.builtinType}'.`);
+    }
+}
+function createNumericArbitrary(scale) {
+    const fractionScale = Math.min(scale ?? 6, 6);
+    if (fractionScale < 1) {
+        throw new testing_configuration_error_js_1.TestingConfigurationError("Automatic DAML numeric generation requires a Numeric scale of at least one.");
+    }
+    const denominator = 10 ** fractionScale;
+    return fc.integer({ min: -1_000_000, max: 1_000_000 })
+        .filter((value) => value % denominator !== 0)
+        .map((value) => new daml_numeric_js_1.DamlNumeric(formatNumeric(value, fractionScale)));
+}
+function formatNumeric(value, scale) {
+    const sign = value < 0 ? "-" : "";
+    const digits = Math.abs(value).toString().padStart(scale + 1, "0");
+    return `${sign}${digits.slice(0, -scale)}.${digits.slice(-scale)}`;
+}

package/dist/cjs/testing/daml/declarative-campaign-arbitrary.js

@@ -0,0 +1,66 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeclarativeCampaignArbitrary = createDeclarativeCampaignArbitrary;
+const fc = __importStar(require("fast-check"));
+const testing_configuration_error_js_1 = require("../errors/testing-configuration-error.js");
+const daml_action_arbitrary_js_1 = require("./daml-action-arbitrary.js");
+/**
+ * Produces exact-depth declarative action sequences for a campaign. Every
+ * resolved target must be declared by the campaign and every generated actor
+ * must be eligible for that target before execution starts.
+ */
+function createDeclarativeCampaignArbitrary(init) {
+    validateTargets(init.campaign, init.targets);
+    return fc.array((0, daml_action_arbitrary_js_1.createDeclarativeActionArbitrary)(init.catalog, init.targets, init), {
+        minLength: init.campaign.config.depth,
+        maxLength: init.campaign.config.depth,
+    });
+}
+function validateTargets(campaign, targets) {
+    const declaredTargets = new Map(campaign.targets.map((target) => [target.key, target]));
+    const allActors = Object.keys(campaign.runtime.actors);
+    for (const target of targets) {
+        const declared = declaredTargets.get(target.key);
+        if (declared === undefined) {
+            throw new testing_configuration_error_js_1.TestingConfigurationError(`Declarative target '${target.key}' is absent from the campaign definition.`);
+        }
+        const eligibleActors = new Set(declared.actors ?? allActors);
+        const invalidActor = target.actors.find((actor) => !eligibleActors.has(actor));
+        if (invalidActor !== undefined) {
+            throw new testing_configuration_error_js_1.TestingConfigurationError(`Declarative target '${target.key}' assigns ineligible actor '${invalidActor}'.`);
+        }
+    }
+}

package/dist/cjs/testing/errors/invariant-campaign-failure.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvariantCampaignFailure = void 0;
+/**
+ * A safe public summary of a failed invariant campaign.
+ *
+ * The original cause is intentionally retained in a private field so that
+ * credentials or transport details cannot be serialized with this error.
+ */
+class InvariantCampaignFailure extends Error {
+    artifactPath;
+    failures;
+    metrics;
+    trace;
+    #cause;
+    constructor(init) {
+        super(init.message);
+        this.name = "InvariantCampaignFailure";
+        this.artifactPath = init.artifactPath;
+        this.failures = Object.freeze(init.failures.map((failure) => Object.freeze({
+            ...failure,
+        })));
+        this.metrics = snapshotMetrics(init.metrics);
+        this.trace = init.trace;
+        this.#cause = init.cause;
+        Object.freeze(this);
+    }
+}
+exports.InvariantCampaignFailure = InvariantCampaignFailure;
+function snapshotMetrics(metrics) {
+    return Object.freeze({
+        byActor: snapshotMetricGroup(metrics.byActor),
+        byTarget: snapshotMetricGroup(metrics.byTarget),
+    });
+}
+function snapshotMetricGroup(group) {
+    return Object.freeze(Object.fromEntries(Object.entries(group).map(([key, values]) => [
+        key,
+        Object.freeze({ ...values }),
+    ])));
+}

package/dist/cjs/testing/errors/testing-configuration-error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestingConfigurationError = void 0;
+class TestingConfigurationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TestingConfigurationError";
+    }
+}
+exports.TestingConfigurationError = TestingConfigurationError;

package/dist/cjs/testing/handlers/handler.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = handler;
+exports.evaluateHandlerAssumptionAsync = evaluateHandlerAssumptionAsync;
+exports.bound = bound;
+function handler(name, init) {
+    if (name.length === 0) {
+        throw new Error("Invariant campaign handler names must not be empty.");
+    }
+    return Object.freeze({
+        name,
+        cleanup: init.cleanup,
+        ...(init.assume === undefined ? {} : { assume: init.assume }),
+    });
+}
+async function evaluateHandlerAssumptionAsync(value, context, input) {
+    if (value.assume === undefined || await value.assume(context, input)) {
+        return { kind: "eligible" };
+    }
+    return {
+        kind: "discarded",
+        reason: "handler assumption returned false",
+    };
+}
+function bound(value, minimum, maximum) {
+    if (minimum > maximum) {
+        throw new Error("Invariant campaign bounds require minimum <= maximum.");
+    }
+    else if (value < minimum) {
+        return minimum;
+    }
+    else if (value > maximum) {
+        return maximum;
+    }
+    return value;
+}

package/dist/cjs/testing/index.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvariantCampaignFailure = exports.TestingConfigurationError = exports.invariant = exports.resolveDeclarativeTargets = exports.targetTemplate = exports.targetChoice = exports.targetCreate = exports.excludeTemplate = exports.excludeChoice = exports.runWithCampaignIsolationAsync = exports.executeDeclarativeActionAsync = exports.toCampaignMetricOutcome = exports.pollUntilAsync = exports.createCantonTestRuntime = exports.classifyCantonCommandOutcome = exports.handler = exports.evaluateHandlerAssumptionAsync = exports.bound = exports.createDeclarativeCreateActionArbitrary = exports.createDeclarativeChoiceActionArbitrary = exports.createDeclarativeCampaignArbitrary = exports.createDeclarativeActionArbitrary = exports.DamlParty = exports.DamlNumeric = exports.createDamlValueArbitrary = exports.createDamlTestingCatalog = exports.scheduleCampaignSlots = exports.createInvariantCampaignScheduleArbitrary = exports.createCampaignScheduleArbitrary = exports.recordCampaignAction = exports.createCampaignMetrics = exports.runCampaignCheckAsync = exports.runInvariantCampaignCheckAsync = exports.runCampaignLifecycleCheckAsync = exports.evaluateCampaignInvariantsAsync = exports.reconcileCampaignModel = exports.createCampaignModel = exports.applyAcceptedGhostTransition = exports.writeCampaignReplayArtifactAsync = exports.serializeCampaignReplayArtifact = exports.selectCampaignCounterexampleTrace = exports.loadCampaignReplayArtifactAsync = exports.createCampaignFingerprint = exports.defineInvariantCampaign = void 0;
+var campaign_definition_js_1 = require("./campaign/campaign-definition.js");
+Object.defineProperty(exports, "defineInvariantCampaign", { enumerable: true, get: function () { return campaign_definition_js_1.defineInvariantCampaign; } });
+var campaign_artifact_js_1 = require("./campaign/campaign-artifact.js");
+Object.defineProperty(exports, "createCampaignFingerprint", { enumerable: true, get: function () { return campaign_artifact_js_1.createCampaignFingerprint; } });
+Object.defineProperty(exports, "loadCampaignReplayArtifactAsync", { enumerable: true, get: function () { return campaign_artifact_js_1.loadCampaignReplayArtifactAsync; } });
+Object.defineProperty(exports, "selectCampaignCounterexampleTrace", { enumerable: true, get: function () { return campaign_artifact_js_1.selectCampaignCounterexampleTrace; } });
+Object.defineProperty(exports, "serializeCampaignReplayArtifact", { enumerable: true, get: function () { return campaign_artifact_js_1.serializeCampaignReplayArtifact; } });
+Object.defineProperty(exports, "writeCampaignReplayArtifactAsync", { enumerable: true, get: function () { return campaign_artifact_js_1.writeCampaignReplayArtifactAsync; } });
+var campaign_model_js_1 = require("./campaign/campaign-model.js");
+Object.defineProperty(exports, "applyAcceptedGhostTransition", { enumerable: true, get: function () { return campaign_model_js_1.applyAcceptedGhostTransition; } });
+Object.defineProperty(exports, "createCampaignModel", { enumerable: true, get: function () { return campaign_model_js_1.createCampaignModel; } });
+Object.defineProperty(exports, "reconcileCampaignModel", { enumerable: true, get: function () { return campaign_model_js_1.reconcileCampaignModel; } });
+var campaign_runner_js_1 = require("./campaign/campaign-runner.js");
+Object.defineProperty(exports, "evaluateCampaignInvariantsAsync", { enumerable: true, get: function () { return campaign_runner_js_1.evaluateCampaignInvariantsAsync; } });
+Object.defineProperty(exports, "runCampaignLifecycleCheckAsync", { enumerable: true, get: function () { return campaign_runner_js_1.runCampaignLifecycleCheckAsync; } });
+Object.defineProperty(exports, "runInvariantCampaignCheckAsync", { enumerable: true, get: function () { return campaign_runner_js_1.runInvariantCampaignCheckAsync; } });
+Object.defineProperty(exports, "runCampaignCheckAsync", { enumerable: true, get: function () { return campaign_runner_js_1.runCampaignCheckAsync; } });
+var campaign_metrics_js_1 = require("./campaign/campaign-metrics.js");
+Object.defineProperty(exports, "createCampaignMetrics", { enumerable: true, get: function () { return campaign_metrics_js_1.createCampaignMetrics; } });
+Object.defineProperty(exports, "recordCampaignAction", { enumerable: true, get: function () { return campaign_metrics_js_1.recordCampaignAction; } });
+var campaign_scheduler_js_1 = require("./campaign/campaign-scheduler.js");
+Object.defineProperty(exports, "createCampaignScheduleArbitrary", { enumerable: true, get: function () { return campaign_scheduler_js_1.createCampaignScheduleArbitrary; } });
+Object.defineProperty(exports, "createInvariantCampaignScheduleArbitrary", { enumerable: true, get: function () { return campaign_scheduler_js_1.createInvariantCampaignScheduleArbitrary; } });
+Object.defineProperty(exports, "scheduleCampaignSlots", { enumerable: true, get: function () { return campaign_scheduler_js_1.scheduleCampaignSlots; } });
+var daml_testing_catalog_js_1 = require("./daml/daml-testing-catalog.js");
+Object.defineProperty(exports, "createDamlTestingCatalog", { enumerable: true, get: function () { return daml_testing_catalog_js_1.createDamlTestingCatalog; } });
+var daml_value_arbitrary_js_1 = require("./daml/daml-value-arbitrary.js");
+Object.defineProperty(exports, "createDamlValueArbitrary", { enumerable: true, get: function () { return daml_value_arbitrary_js_1.createDamlValueArbitrary; } });
+var daml_numeric_js_1 = require("../core/types/daml-numeric.js");
+Object.defineProperty(exports, "DamlNumeric", { enumerable: true, get: function () { return daml_numeric_js_1.DamlNumeric; } });
+var daml_party_js_1 = require("../core/types/daml-party.js");
+Object.defineProperty(exports, "DamlParty", { enumerable: true, get: function () { return daml_party_js_1.DamlParty; } });
+var daml_action_arbitrary_js_1 = require("./daml/daml-action-arbitrary.js");
+Object.defineProperty(exports, "createDeclarativeActionArbitrary", { enumerable: true, get: function () { return daml_action_arbitrary_js_1.createDeclarativeActionArbitrary; } });
+var declarative_campaign_arbitrary_js_1 = require("./daml/declarative-campaign-arbitrary.js");
+Object.defineProperty(exports, "createDeclarativeCampaignArbitrary", { enumerable: true, get: function () { return declarative_campaign_arbitrary_js_1.createDeclarativeCampaignArbitrary; } });
+var daml_choice_action_arbitrary_js_1 = require("./daml/daml-choice-action-arbitrary.js");
+Object.defineProperty(exports, "createDeclarativeChoiceActionArbitrary", { enumerable: true, get: function () { return daml_choice_action_arbitrary_js_1.createDeclarativeChoiceActionArbitrary; } });
+var daml_create_action_arbitrary_js_1 = require("./daml/daml-create-action-arbitrary.js");
+Object.defineProperty(exports, "createDeclarativeCreateActionArbitrary", { enumerable: true, get: function () { return daml_create_action_arbitrary_js_1.createDeclarativeCreateActionArbitrary; } });
+var handler_js_1 = require("./handlers/handler.js");
+Object.defineProperty(exports, "bound", { enumerable: true, get: function () { return handler_js_1.bound; } });
+Object.defineProperty(exports, "evaluateHandlerAssumptionAsync", { enumerable: true, get: function () { return handler_js_1.evaluateHandlerAssumptionAsync; } });
+Object.defineProperty(exports, "handler", { enumerable: true, get: function () { return handler_js_1.handler; } });
+var canton_test_runtime_js_1 = require("./runtime/canton-test-runtime.js");
+Object.defineProperty(exports, "classifyCantonCommandOutcome", { enumerable: true, get: function () { return canton_test_runtime_js_1.classifyCantonCommandOutcome; } });
+Object.defineProperty(exports, "createCantonTestRuntime", { enumerable: true, get: function () { return canton_test_runtime_js_1.createCantonTestRuntime; } });
+Object.defineProperty(exports, "pollUntilAsync", { enumerable: true, get: function () { return canton_test_runtime_js_1.pollUntilAsync; } });
+Object.defineProperty(exports, "toCampaignMetricOutcome", { enumerable: true, get: function () { return canton_test_runtime_js_1.toCampaignMetricOutcome; } });
+var declarative_action_executor_js_1 = require("./runtime/declarative-action-executor.js");
+Object.defineProperty(exports, "executeDeclarativeActionAsync", { enumerable: true, get: function () { return declarative_action_executor_js_1.executeDeclarativeActionAsync; } });
+var campaign_isolation_js_1 = require("./runtime/campaign-isolation.js");
+Object.defineProperty(exports, "runWithCampaignIsolationAsync", { enumerable: true, get: function () { return campaign_isolation_js_1.runWithCampaignIsolationAsync; } });
+var target_js_1 = require("./targets/target.js");
+Object.defineProperty(exports, "excludeChoice", { enumerable: true, get: function () { return target_js_1.excludeChoice; } });
+Object.defineProperty(exports, "excludeTemplate", { enumerable: true, get: function () { return target_js_1.excludeTemplate; } });
+Object.defineProperty(exports, "targetCreate", { enumerable: true, get: function () { return target_js_1.targetCreate; } });
+Object.defineProperty(exports, "targetChoice", { enumerable: true, get: function () { return target_js_1.targetChoice; } });
+Object.defineProperty(exports, "targetTemplate", { enumerable: true, get: function () { return target_js_1.targetTemplate; } });
+Object.defineProperty(exports, "resolveDeclarativeTargets", { enumerable: true, get: function () { return target_js_1.resolveDeclarativeTargets; } });
+var campaign_types_js_1 = require("./campaign/campaign-types.js");
+Object.defineProperty(exports, "invariant", { enumerable: true, get: function () { return campaign_types_js_1.invariant; } });
+var testing_configuration_error_js_1 = require("./errors/testing-configuration-error.js");
+Object.defineProperty(exports, "TestingConfigurationError", { enumerable: true, get: function () { return testing_configuration_error_js_1.TestingConfigurationError; } });
+var invariant_campaign_failure_js_1 = require("./errors/invariant-campaign-failure.js");
+Object.defineProperty(exports, "InvariantCampaignFailure", { enumerable: true, get: function () { return invariant_campaign_failure_js_1.InvariantCampaignFailure; } });

package/dist/cjs/testing/runtime/campaign-isolation.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWithCampaignIsolationAsync = runWithCampaignIsolationAsync;
+async function runWithCampaignIsolationAsync(init) {
+    if (init.isolation.kind === "external") {
+        await init.isolation.reset("before-run");
+        try {
+            await init.runAsync();
+        }
+        finally {
+            await init.isolation.reset("after-run");
+        }
+        return;
+    }
+    else if (init.isolation.kind === "snapshot") {
+        const snapshot = await init.isolation.create();
+        try {
+            await init.runAsync();
+        }
+        finally {
+            await init.isolation.restore(snapshot);
+        }
+        return;
+    }
+    await init.runAsync();
+}

package/dist/cjs/testing/runtime/canton-test-runtime.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCantonTestRuntime = createCantonTestRuntime;
+exports.classifyCantonCommandOutcome = classifyCantonCommandOutcome;
+exports.toCampaignMetricOutcome = toCampaignMetricOutcome;
+exports.pollUntilAsync = pollUntilAsync;
+const testing_configuration_error_js_1 = require("../errors/testing-configuration-error.js");
+function createCantonTestRuntime(init) {
+    for (const [name, actor] of Object.entries(init.actors)) {
+        if (init.participants[actor.participant] === undefined) {
+            throw new testing_configuration_error_js_1.TestingConfigurationError(`Canton test actor '${name}' references unknown participant '${actor.participant}'.`);
+        }
+    }
+    const actors = Object.freeze({ ...init.actors });
+    const participants = Object.freeze({ ...init.participants });
+    const resolveRoute = (actorName) => {
+        const actor = actors[actorName];
+        if (actor === undefined) {
+            throw new testing_configuration_error_js_1.TestingConfigurationError(`Canton test runtime has no actor '${actorName}'.`);
+        }
+        return Object.freeze({
+            actor: actorName,
+            participant: actor.participant,
+            party: actor.party,
+            actAs: Object.freeze([...(actor.actAs ?? [actor.party])]),
+            readAs: Object.freeze([...(actor.readAs ?? [])]),
+        });
+    };
+    return Object.freeze({
+        actors,
+        participants,
+        isolation: init.isolation,
+        async readLedgerEndAsync(participantName) {
+            const participant = participants[participantName];
+            const stateService = readObjectProperty(participant, "stateService");
+            const getLedgerEndAsync = readFunctionProperty(stateService, "getLedgerEndAsync");
+            if (getLedgerEndAsync === undefined) {
+                throw new testing_configuration_error_js_1.TestingConfigurationError(`Canton test participant '${participantName}' has no stateService.getLedgerEndAsync method.`);
+            }
+            const response = await getLedgerEndAsync.call(stateService);
+            const offset = readStringProperty(response, "offset");
+            if (offset === undefined) {
+                throw new testing_configuration_error_js_1.TestingConfigurationError(`Canton test participant '${participantName}' returned no ledger end offset.`);
+            }
+            return offset;
+        },
+        resolveRoute,
+        async submitAndWaitAsync(actorName, request) {
+            const route = resolveRoute(actorName);
+            const participant = participants[route.participant];
+            const commandService = readObjectProperty(participant, "commandService");
+            const submitAndWaitAsync = readFunctionProperty(commandService, "submitAndWaitAsync");
+            if (submitAndWaitAsync === undefined) {
+                throw new testing_configuration_error_js_1.TestingConfigurationError(`Canton test participant '${route.participant}' has no commandService.submitAndWaitAsync method.`);
+            }
+            try {
+                return classifyCantonCommandOutcome({
+                    response: await submitAndWaitAsync.call(commandService, request),
+                });
+            }
+            catch (error) {
+                return classifyCantonCommandOutcome({ error });
+            }
+        },
+    });
+}
+function classifyCantonCommandOutcome(input) {
+    if (input.error === undefined) {
+        const transactionId = readStringProperty(input.response, "transactionId");
+        const commandId = readStringProperty(input.response, "commandId");
+        return {
+            kind: "accepted",
+            ...(transactionId === undefined ? {} : { transactionId }),
+            ...(commandId === undefined ? {} : { commandId }),
+        };
+    }
+    const statusCode = readNumberProperty(input.error, "code");
+    const details = readStringProperty(input.error, "details") ?? "Unknown command failure.";
+    if ((statusCode === 9 && details.startsWith("DAML_INTERPRETATION_ERROR("))
+        || (statusCode === 3 && details.startsWith("DAML_AUTHORIZATION_ERROR("))) {
+        return { kind: "protocol-revert", statusCode, details };
+    }
+    else if (statusCode === 14 || statusCode === 13) {
+        return { kind: "transport-error", statusCode, details };
+    }
+    else if (statusCode === 4) {
+        return { kind: "timeout", statusCode, details };
+    }
+    return { kind: "unknown-commit-outcome", statusCode, details };
+}
+/** Converts the runtime's transport-safe outcome into the campaign metric union. */
+function toCampaignMetricOutcome(outcome) {
+    if (outcome.kind !== "accepted") {
+        return {
+            kind: outcome.kind,
+            reason: outcome.details,
+        };
+    }
+    const updateId = outcome.transactionId ?? outcome.commandId;
+    return updateId === undefined
+        ? {
+            kind: "malformed-response",
+            reason: "Canton command response has no transaction or command ID.",
+        }
+        : { kind: "accepted", updateId };
+}
+async function pollUntilAsync(init) {
+    const deadline = Date.now() + init.timeoutMs;
+    while (true) {
+        const value = await init.readAsync();
+        if (init.isReady(value)) {
+            return value;
+        }
+        else if (Date.now() >= deadline) {
+            throw new Error("Canton test runtime polling timed out.");
+        }
+        await new Promise((resolveDelay) => {
+            setTimeout(resolveDelay, init.intervalMs);
+        });
+    }
+}
+function readNumberProperty(value, key) {
+    const candidate = value;
+    const property = candidate?.[key];
+    return typeof property === "number" ? property : undefined;
+}
+function readObjectProperty(value, key) {
+    const candidate = value;
+    const property = candidate?.[key];
+    return property !== null && typeof property === "object"
+        ? property
+        : undefined;
+}
+function readFunctionProperty(value, key) {
+    const property = value?.[key];
+    return typeof property === "function"
+        ? property
+        : undefined;
+}
+function readStringProperty(value, key) {
+    const candidate = value;
+    const property = candidate?.[key];
+    return typeof property === "string" ? property : undefined;
+}

package/dist/cjs/testing/runtime/declarative-action-executor.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeDeclarativeActionAsync = executeDeclarativeActionAsync;
+const create_command_js_1 = require("../../core/types/commands/create-command.js");
+const exercise_command_js_1 = require("../../core/types/commands/exercise-command.js");
+const daml_values_js_1 = require("../../core/types/daml-values.js");
+const submit_command_request_js_1 = require("../../core/types/requests/submit-command-request.js");
+const testing_configuration_error_js_1 = require("../errors/testing-configuration-error.js");
+const canton_test_runtime_js_1 = require("./canton-test-runtime.js");
+/**
+ * Converts a generated declarative action into SDK command types and submits
+ * it over the actor's configured Canton route. Choice actions deliberately
+ * require an explicit contract resolver: the testing SDK never guesses an
+ * active contract ID from stale local state.
+ */
+async function executeDeclarativeActionAsync(init) {
+    const route = init.runtime.resolveRoute(init.action.actor);
+    const command = "choice" in init.action
+        ? await createExerciseCommandAsync(init.action, init.resolveContractIdAsync)
+        : new create_command_js_1.CreateCommand({
+            templateId: init.action.templateId,
+            createArguments: new daml_values_js_1.DamlRecord({ ...init.action.payload }),
+        });
+    return (0, canton_test_runtime_js_1.toCampaignMetricOutcome)(await init.runtime.submitAndWaitAsync(init.action.actor, new submit_command_request_js_1.SubmitCommandRequest({
+        applicationId: init.applicationId,
+        actAs: route.actAs,
+        readAs: route.readAs,
+        command,
+    })));
+}
+async function createExerciseCommandAsync(action, resolveContractIdAsync) {
+    if (resolveContractIdAsync === undefined) {
+        throw new testing_configuration_error_js_1.TestingConfigurationError(`Declarative choice target '${action.targetKey}' requires resolveContractIdAsync.`);
+    }
+    const contractId = await resolveContractIdAsync(action);
+    if (contractId.length === 0) {
+        throw new testing_configuration_error_js_1.TestingConfigurationError(`Declarative choice target '${action.targetKey}' resolved an empty contract ID.`);
+    }
+    return new exercise_command_js_1.ExerciseCommand({
+        templateId: action.templateId,
+        contractId,
+        choice: action.choice,
+        choiceArgument: action.argument,
+    });
+}

package/dist/cjs/testing/targets/target.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.targetTemplate = targetTemplate;
+exports.targetChoice = targetChoice;
+exports.targetCreate = targetCreate;
+exports.excludeChoice = excludeChoice;
+exports.excludeTemplate = excludeTemplate;
+exports.resolveDeclarativeTargets = resolveDeclarativeTargets;
+const testing_configuration_error_js_1 = require("../errors/testing-configuration-error.js");
+function targetTemplate(templateId) {
+    let actors = [];
+    return Object.freeze({
+        allChoices() {
+            return Object.freeze({
+                kind: "template",
+                templateId,
+                actors,
+                choices: Object.freeze([]),
+                allChoices: true,
+            });
+        },
+        actors(value) {
+            actors = Object.freeze([...value]);
+            return this;
+        },
+        choice(choice) {
+            return Object.freeze({
+                kind: "template",
+                templateId,
+                actors,
+                choices: Object.freeze([choice]),
+            });
+        },
+        create() {
+            return Object.freeze({
+                kind: "template-create",
+                templateId,
+                actors,
+            });
+        },
+    });
+}
+/** Builds one immutable declarative template-choice target without a builder chain. */
+function targetChoice(templateId, choice, actors) {
+    return Object.freeze({
+        kind: "template",
+        templateId,
+        actors: Object.freeze([...actors]),
+        choices: Object.freeze([choice]),
+    });
+}
+/** Builds one immutable declarative contract-create target without a builder chain. */
+function targetCreate(templateId, actors) {
+    return Object.freeze({
+        kind: "template-create",
+        templateId,
+        actors: Object.freeze([...actors]),
+    });
+}
+function excludeChoice(templateId, choice) {
+    return Object.freeze({
+        kind: "exclude-choice",
+        templateId,
+        choice,
+    });
+}
+function excludeTemplate(templateId) {
+    return Object.freeze({
+        kind: "exclude-template",
+        templateId,
+    });
+}
+function resolveDeclarativeTargets(catalog, descriptors) {
+    for (const descriptor of descriptors) {
+        if (descriptor.kind === "template") {
+            continue;
+        }
+        const template = catalog.getTemplate(formatTemplateId(descriptor.templateId));
+        if (template === undefined) {
+            throw new testing_configuration_error_js_1.TestingConfigurationError(`Declarative target '${formatTemplateId(descriptor.templateId)}' is absent from the DAML catalog.`);
+        }
+        else if (descriptor.kind === "exclude-choice"
+            && !template.choices.includes(descriptor.choice)) {
+            throw new testing_configuration_error_js_1.TestingConfigurationError(`Declarative target '${formatTemplateId(descriptor.templateId)}:${descriptor.choice}' is absent from the DAML catalog.`);
+        }
+    }
+    const excludedTemplates = new Set(descriptors
+        .filter((descriptor) => descriptor.kind === "exclude-template")
+        .map((descriptor) => formatTemplateId(descriptor.templateId)));
+    const excluded = new Set(descriptors
+        .filter((descriptor) => descriptor.kind === "exclude-choice")
+        .map((descriptor) => `${formatTemplateId(descriptor.templateId)}:${descriptor.choice}`));
+    return descriptors
+        .filter((descriptor) => descriptor.kind === "template" || descriptor.kind === "template-create")
+        .flatMap((descriptor) => {
+        const template = catalog.getTemplate(formatTemplateId(descriptor.templateId));
+        if (template === undefined) {
+            throw new testing_configuration_error_js_1.TestingConfigurationError(`Declarative target '${formatTemplateId(descriptor.templateId)}' is absent from the DAML catalog.`);
+        }
+        else if (descriptor.kind === "template-create") {
+            return [Object.freeze({
+                    key: `${formatTemplateId(descriptor.templateId)}:create`,
+                    templateId: descriptor.templateId,
+                    actors: descriptor.actors,
+                    kind: "create",
+                })];
+        }
+        else {
+            if (descriptor.allChoices === true && excludedTemplates.has(formatTemplateId(descriptor.templateId))) {
+                return [];
+            }
+            const choices = (descriptor.allChoices === true
+                ? template.choices.filter((choice) => !excluded.has(`${formatTemplateId(descriptor.templateId)}:${choice}`))
+                : descriptor.choices);
+            const missingChoice = choices.find((choice) => !template.choices.includes(choice));
+            if (missingChoice !== undefined) {
+                throw new testing_configuration_error_js_1.TestingConfigurationError(`Declarative target '${formatTemplateId(descriptor.templateId)}:${missingChoice}' is absent from the DAML catalog.`);
+            }
+            return choices
+                .map((choice) => Object.freeze({
+                key: `${formatTemplateId(descriptor.templateId)}:${choice}`,
+                templateId: descriptor.templateId,
+                choice,
+                actors: descriptor.actors,
+            }));
+        }
+    })
+        .sort((left, right) => left.key.localeCompare(right.key));
+}
+function formatTemplateId(templateId) {
+    return `${templateId.packageId}:${templateId.moduleName}:${templateId.entityName}`;
+}