@distrohelena/canton-typescript-sdk 0.1.5 → 0.1.7

package/dist/testing/campaign/campaign-definition.js

@@ -0,0 +1,78 @@
+import { TestingConfigurationError } from "../errors/testing-configuration-error.js";
+export function defineInvariantCampaign(init) {
+    const config = resolveConfig(init.config);
+    const targetKeys = new Set();
+    const targets = init.targets.map((target) => {
+        validateTarget(target, init.runtime);
+        if (targetKeys.has(target.key)) {
+            throw new TestingConfigurationError(`Invariant campaign target '${target.key}' is duplicated.`);
+        }
+        targetKeys.add(target.key);
+        return Object.freeze({
+            key: target.key,
+            ...(target.actors === undefined
+                ? {}
+                : { actors: Object.freeze([...target.actors]) }),
+        });
+    });
+    if (targets.length === 0) {
+        throw new TestingConfigurationError("Invariant campaigns require at least one target.");
+    }
+    const handlers = Object.freeze([...(init.handlers ?? [])]);
+    validateHandlers(handlers, init.runtime);
+    return Object.freeze({
+        runtime: init.runtime,
+        config,
+        targets: Object.freeze(targets),
+        handlers,
+        invariants: Object.freeze([...init.invariants]),
+    });
+}
+function validateHandlers(handlers, runtime) {
+    const names = new Set();
+    for (const handler of handlers) {
+        if (names.has(handler.name)) {
+            throw new TestingConfigurationError(`Invariant campaign handler '${handler.name}' is duplicated.`);
+        }
+        names.add(handler.name);
+        if (runtime.isolation.kind === "cleanup" && handler.cleanup === "none") {
+            throw new TestingConfigurationError(`Invariant campaign handler '${handler.name}' requires discovery cleanup under cleanup isolation.`);
+        }
+    }
+}
+function resolveConfig(config) {
+    if (!Number.isSafeInteger(config.runs) || config.runs < 1) {
+        throw new TestingConfigurationError("Invariant campaign runs must be a positive safe integer.");
+    }
+    else if (!Number.isSafeInteger(config.depth) || config.depth < 1) {
+        throw new TestingConfigurationError("Invariant campaign depth must be a positive safe integer.");
+    }
+    else if (config.seed !== undefined && !Number.isSafeInteger(config.seed)) {
+        throw new TestingConfigurationError("Invariant campaign seed must be a safe integer.");
+    }
+    else if (config.timeoutMs !== undefined
+        && (!Number.isSafeInteger(config.timeoutMs) || config.timeoutMs < 1)) {
+        throw new TestingConfigurationError("Invariant campaign timeout must be a positive safe integer.");
+    }
+    return Object.freeze({
+        runs: config.runs,
+        depth: config.depth,
+        failOnRevert: config.failOnRevert ?? false,
+        ...(config.path === undefined ? {} : { path: config.path }),
+        ...(config.seed === undefined ? {} : { seed: config.seed }),
+        ...(config.timeoutMs === undefined ? {} : { timeoutMs: config.timeoutMs }),
+    });
+}
+function validateTarget(target, runtime) {
+    if (target.key.length === 0) {
+        throw new TestingConfigurationError("Invariant campaign target keys must not be empty.");
+    }
+    else if (target.actors !== undefined && target.actors.length === 0) {
+        throw new TestingConfigurationError(`Invariant campaign target '${target.key}' requires at least one actor.`);
+    }
+    for (const actor of target.actors ?? []) {
+        if (runtime.actors[actor] === undefined) {
+            throw new TestingConfigurationError(`Invariant campaign target '${target.key}' references unknown actor '${actor}'.`);
+        }
+    }
+}

package/dist/testing/campaign/campaign-metrics.d.ts

@@ -0,0 +1,32 @@
+export type CampaignMetricOutcome = {
+    readonly kind: "accepted";
+    readonly updateId: string;
+} | {
+    readonly kind: "discarded";
+    readonly reason: string;
+} | {
+    readonly kind: "malformed-response";
+    readonly reason: string;
+} | {
+    readonly kind: "protocol-revert";
+    readonly reason: string;
+} | {
+    readonly kind: "timeout";
+    readonly reason: string;
+} | {
+    readonly kind: "transport-error";
+    readonly reason: string;
+} | {
+    readonly kind: "unknown-commit-outcome";
+    readonly reason: string;
+};
+export interface CampaignMetrics {
+    readonly byActor: Readonly<Record<string, Readonly<Record<string, number>>>>;
+    readonly byTarget: Readonly<Record<string, Readonly<Record<string, number>>>>;
+}
+export declare function createCampaignMetrics(): CampaignMetrics;
+export declare function recordCampaignAction(metrics: CampaignMetrics, action: {
+    readonly actor: string;
+    readonly outcome: CampaignMetricOutcome;
+    readonly targetKey: string;
+}): void;

package/dist/testing/campaign/campaign-metrics.js

@@ -0,0 +1,26 @@
+export function createCampaignMetrics() {
+    return {
+        byActor: {},
+        byTarget: {},
+    };
+}
+export function recordCampaignAction(metrics, action) {
+    const mutableMetrics = metrics;
+    mutableMetrics.byActor = incrementMetric(mutableMetrics.byActor, action.actor, action.outcome.kind);
+    mutableMetrics.byTarget = incrementMetric(mutableMetrics.byTarget, action.targetKey, action.outcome.kind);
+}
+function incrementMetric(metric, key, outcome) {
+    const next = {
+        ...metric,
+        [key]: {
+            ...metric[key],
+            [outcome]: (metric[key]?.[outcome] ?? 0) + 1,
+        },
+    };
+    return Object.fromEntries(Object.entries(next)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([metricKey, outcomes]) => [
+        metricKey,
+        Object.fromEntries(Object.entries(outcomes).sort(([left], [right]) => left.localeCompare(right))),
+    ]));
+}

package/dist/testing/campaign/campaign-model.d.ts

@@ -0,0 +1,11 @@
+import { CampaignMetricOutcome } from "./campaign-metrics.js";
+export interface CampaignModel<Ledger, Ghost> {
+    readonly ghost: Ghost;
+    readonly ledger: Ledger;
+}
+export declare function createCampaignModel<Ledger, Ghost>(init: {
+    readonly ghost: Ghost;
+    readonly ledger: Ledger;
+}): CampaignModel<Ledger, Ghost>;
+export declare function reconcileCampaignModel<Ledger, Ghost>(model: CampaignModel<Ledger, Ghost>, ledger: Ledger): CampaignModel<Ledger, Ghost>;
+export declare function applyAcceptedGhostTransition<Ledger, Ghost>(model: CampaignModel<Ledger, Ghost>, outcome: CampaignMetricOutcome, transition: (ghost: Ghost) => Ghost): CampaignModel<Ledger, Ghost>;

package/dist/testing/campaign/campaign-model.js

@@ -0,0 +1,21 @@
+export function createCampaignModel(init) {
+    return Object.freeze({
+        ledger: init.ledger,
+        ghost: init.ghost,
+    });
+}
+export function reconcileCampaignModel(model, ledger) {
+    return Object.freeze({
+        ledger,
+        ghost: model.ghost,
+    });
+}
+export function applyAcceptedGhostTransition(model, outcome, transition) {
+    if (outcome.kind !== "accepted") {
+        return model;
+    }
+    return Object.freeze({
+        ledger: model.ledger,
+        ghost: transition(model.ghost),
+    });
+}

package/dist/testing/campaign/campaign-runner.d.ts

@@ -0,0 +1,99 @@
+import * as fc from "fast-check";
+import { CampaignMetricOutcome, CampaignMetrics } from "./campaign-metrics.js";
+import { InvariantCampaign } from "./campaign-types.js";
+export interface CampaignInvariantFailure {
+    readonly code: string;
+    readonly invariant: string;
+    readonly message: string;
+}
+export declare function evaluateCampaignInvariantsAsync(init: readonly {
+    readonly check: () => Promise<{
+        readonly code: string;
+        readonly message: string;
+    } | undefined>;
+    readonly name: string;
+}[]): Promise<readonly CampaignInvariantFailure[]>;
+export declare function runCampaignCheckAsync<Input, Trace>(init: {
+    readonly arbitrary: fc.Arbitrary<Input>;
+    readonly executeAsync: (input: Input) => Promise<{
+        readonly passed: boolean;
+        readonly trace: Trace;
+    }>;
+    readonly key: (input: Input) => string;
+    readonly numRuns: number;
+    readonly path?: string;
+    readonly seed?: number;
+    readonly timeoutMs?: number;
+}): Promise<{
+    readonly counterexampleTrace?: Trace;
+    readonly details: fc.RunDetails<[Input]>;
+}>;
+export interface CampaignExecutableAction {
+    readonly actor: string;
+    readonly targetKey: string;
+}
+export type CampaignLifecyclePhase<Action> = {
+    readonly kind: "before-run";
+} | {
+    readonly action: Action;
+    readonly kind: "after-action";
+} | {
+    readonly kind: "after-run";
+} | {
+    readonly kind: "post-cleanup";
+};
+export interface CampaignLifecycleTrace<Action> {
+    readonly actions: readonly {
+        readonly action: Action;
+        readonly outcome: CampaignMetricOutcome;
+    }[];
+    readonly failures: readonly CampaignInvariantFailure[];
+    readonly metrics: CampaignMetrics;
+    readonly failureKind?: "execution-error" | "invalid-depth";
+}
+/**
+ * Runs generated fixed-depth action sequences with Foundry-style revert
+ * handling. Runtime-specific setup, reconciliation, and cleanup stay in
+ * caller-provided hooks so this remains usable with any ledger adapter.
+ */
+export declare function runCampaignLifecycleCheckAsync<Context, Action extends CampaignExecutableAction>(init: {
+    readonly arbitrary: fc.Arbitrary<readonly Action[]>;
+    readonly checkInvariantsAsync?: (context: Context, phase: CampaignLifecyclePhase<Action>) => Promise<readonly CampaignInvariantFailure[]>;
+    readonly cleanupAsync?: (context: Context) => Promise<void>;
+    readonly depth: number;
+    readonly executeAsync: (context: Context, action: Action) => Promise<CampaignMetricOutcome>;
+    readonly failOnRevert: boolean;
+    readonly key: (actions: readonly Action[]) => string;
+    readonly numRuns: number;
+    readonly path?: string;
+    readonly reconcileAsync?: (context: Context, phase: CampaignLifecyclePhase<Action>) => Promise<void>;
+    readonly seed?: number;
+    /** Receives the candidate so setup can derive deterministic run state. */
+    readonly setupAsync: (actions: readonly Action[]) => Promise<Context>;
+    readonly timeoutMs?: number;
+}): Promise<{
+    readonly counterexampleTrace?: CampaignLifecycleTrace<Action>;
+    readonly details: fc.RunDetails<[readonly Action[]]>;
+}>;
+/**
+ * Runs a declared invariant campaign and evaluates its invariant functions at
+ * every lifecycle checkpoint. The caller supplies the ledger-specific action
+ * executor and model hydration hooks; the campaign supplies runs, depth,
+ * seed, revert policy, and declared invariants.
+ */
+export declare function runInvariantCampaignCheckAsync<Model, Ghost, Action extends CampaignExecutableAction, Context extends {
+    readonly ghost: Ghost;
+    readonly model: Model;
+}>(init: {
+    readonly arbitrary: fc.Arbitrary<readonly Action[]>;
+    readonly campaign: InvariantCampaign<Model, Ghost>;
+    readonly checkInvariantsAsync?: (context: Context, phase: CampaignLifecyclePhase<Action>) => Promise<readonly CampaignInvariantFailure[]>;
+    readonly cleanupAsync?: (context: Context) => Promise<void>;
+    readonly executeAsync: (context: Context, action: Action) => Promise<CampaignMetricOutcome>;
+    readonly key: (actions: readonly Action[]) => string;
+    readonly reconcileAsync?: (context: Context, phase: CampaignLifecyclePhase<Action>) => Promise<void>;
+    readonly setupAsync: (actions: readonly Action[]) => Promise<Context>;
+}): Promise<{
+    readonly counterexampleTrace?: CampaignLifecycleTrace<Action>;
+    readonly details: fc.RunDetails<[readonly Action[]]>;
+}>;

package/dist/testing/campaign/campaign-runner.js

@@ -0,0 +1,194 @@
+import * as fc from "fast-check";
+import { createCampaignMetrics, recordCampaignAction, } from "./campaign-metrics.js";
+export async function evaluateCampaignInvariantsAsync(init) {
+    const failures = [];
+    for (const invariant of init) {
+        try {
+            const failure = await invariant.check();
+            if (failure !== undefined) {
+                failures.push({ invariant: invariant.name, ...failure });
+            }
+        }
+        catch (error) {
+            failures.push({
+                invariant: invariant.name,
+                code: "thrown",
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return failures;
+}
+export async function runCampaignCheckAsync(init) {
+    const traces = new Map();
+    const details = await fc.check(fc.asyncProperty(init.arbitrary, async (input) => {
+        const result = await init.executeAsync(input);
+        traces.set(init.key(input), result.trace);
+        return result.passed;
+    }), {
+        numRuns: init.numRuns,
+        ...(init.seed === undefined ? {} : { seed: init.seed }),
+        ...(init.path === undefined ? {} : { path: init.path }),
+        ...(init.timeoutMs === undefined
+            ? {}
+            : { interruptAfterTimeLimit: init.timeoutMs }),
+    });
+    const counterexample = details.counterexample?.[0];
+    return {
+        details,
+        ...(counterexample === undefined
+            ? {}
+            : { counterexampleTrace: traces.get(init.key(counterexample)) }),
+    };
+}
+/**
+ * Runs generated fixed-depth action sequences with Foundry-style revert
+ * handling. Runtime-specific setup, reconciliation, and cleanup stay in
+ * caller-provided hooks so this remains usable with any ledger adapter.
+ */
+export async function runCampaignLifecycleCheckAsync(init) {
+    return runCampaignCheckAsync({
+        arbitrary: init.arbitrary,
+        key: init.key,
+        numRuns: init.numRuns,
+        path: init.path,
+        seed: init.seed,
+        timeoutMs: init.timeoutMs,
+        executeAsync: async (actions) => runCampaignCandidateAsync(init, actions),
+    });
+}
+/**
+ * Runs a declared invariant campaign and evaluates its invariant functions at
+ * every lifecycle checkpoint. The caller supplies the ledger-specific action
+ * executor and model hydration hooks; the campaign supplies runs, depth,
+ * seed, revert policy, and declared invariants.
+ */
+export async function runInvariantCampaignCheckAsync(init) {
+    return runCampaignLifecycleCheckAsync({
+        arbitrary: init.arbitrary,
+        depth: init.campaign.config.depth,
+        failOnRevert: init.campaign.config.failOnRevert,
+        key: init.key,
+        numRuns: init.campaign.config.runs,
+        path: init.campaign.config.path,
+        seed: init.campaign.config.seed,
+        timeoutMs: init.campaign.config.timeoutMs,
+        setupAsync: init.setupAsync,
+        executeAsync: init.executeAsync,
+        cleanupAsync: init.cleanupAsync,
+        reconcileAsync: init.reconcileAsync,
+        checkInvariantsAsync: async (context, phase) => {
+            const declaredFailures = await evaluateCampaignInvariantsAsync(init.campaign.invariants.map((invariant, index) => ({
+                name: invariant.label ?? (invariant.name || `invariant-${index + 1}`),
+                check: async () => {
+                    await invariant({
+                        model: context.model,
+                        ghost: context.ghost,
+                    });
+                    return undefined;
+                },
+            })));
+            const additionalFailures = await init.checkInvariantsAsync?.(context, phase) ?? [];
+            return [...declaredFailures, ...additionalFailures];
+        },
+    });
+}
+async function runCampaignCandidateAsync(init, actions) {
+    const metrics = createCampaignMetrics();
+    const executed = [];
+    const failures = [];
+    let context;
+    let failureKind;
+    let passed = true;
+    if (actions.length !== init.depth) {
+        return {
+            passed: false,
+            trace: {
+                actions: [],
+                failures: [],
+                metrics,
+                failureKind: "invalid-depth",
+            },
+        };
+    }
+    const checkInvariantsAsync = async (phase) => {
+        if (context === undefined || init.checkInvariantsAsync === undefined) {
+            return;
+        }
+        const phaseFailures = await init.checkInvariantsAsync(context, phase);
+        failures.push(...phaseFailures);
+        if (phaseFailures.length > 0) {
+            passed = false;
+        }
+    };
+    try {
+        context = await init.setupAsync(actions);
+        const beforeRun = { kind: "before-run" };
+        await init.reconcileAsync?.(context, beforeRun);
+        await checkInvariantsAsync(beforeRun);
+        for (const action of actions) {
+            if (!passed) {
+                break;
+            }
+            let outcome;
+            try {
+                outcome = await init.executeAsync(context, action);
+            }
+            catch {
+                outcome = {
+                    kind: "transport-error",
+                    reason: "Campaign action execution threw an error.",
+                };
+            }
+            executed.push({ action, outcome });
+            recordCampaignAction(metrics, {
+                actor: action.actor,
+                targetKey: action.targetKey,
+                outcome,
+            });
+            const afterAction = { kind: "after-action", action };
+            if (outcome.kind === "accepted") {
+                await init.reconcileAsync?.(context, afterAction);
+            }
+            await checkInvariantsAsync(afterAction);
+            if (outcome.kind !== "accepted"
+                && (outcome.kind !== "protocol-revert" || init.failOnRevert)) {
+                passed = false;
+            }
+        }
+        if (passed) {
+            await checkInvariantsAsync({ kind: "after-run" });
+        }
+    }
+    catch {
+        passed = false;
+        failureKind = "execution-error";
+    }
+    finally {
+        if (context !== undefined) {
+            try {
+                await init.cleanupAsync?.(context);
+            }
+            catch {
+                passed = false;
+                failureKind ??= "execution-error";
+            }
+            try {
+                await checkInvariantsAsync({ kind: "post-cleanup" });
+            }
+            catch {
+                passed = false;
+                failureKind ??= "execution-error";
+            }
+        }
+    }
+    return {
+        passed,
+        trace: {
+            actions: Object.freeze(executed.map((entry) => Object.freeze(entry))),
+            failures: Object.freeze(failures.map((failure) => Object.freeze({ ...failure }))),
+            metrics,
+            ...(failureKind === undefined ? {} : { failureKind }),
+        },
+    };
+}

package/dist/testing/campaign/campaign-scheduler.d.ts

@@ -0,0 +1,40 @@
+import * as fc from "fast-check";
+import { InvariantCampaign } from "./campaign-types.js";
+export interface CampaignSchedulingTarget {
+    readonly actors: readonly string[];
+    readonly key: string;
+    readonly requiresActiveContract?: boolean;
+    readonly weight: number;
+}
+export type ScheduledCampaignSlot = {
+    readonly kind: "probe";
+} | {
+    readonly actor: string;
+    readonly kind: "target";
+    readonly targetKey: string;
+};
+/**
+ * Generates exact-depth scheduling inputs with fast-check's seed and shrink
+ * support while delegating all eligibility decisions to the pure scheduler.
+ */
+export declare function createCampaignScheduleArbitrary(init: {
+    readonly depth: number;
+    readonly hasActiveContract: boolean;
+    readonly targets: readonly CampaignSchedulingTarget[];
+}): fc.Arbitrary<readonly ScheduledCampaignSlot[]>;
+/**
+ * Projects a public invariant campaign definition onto generated scheduling
+ * slots. Targets without explicit actors use every configured actor in stable
+ * name order, allowing lightweight read/probe targets to share the campaign
+ * actor matrix.
+ */
+export declare function createInvariantCampaignScheduleArbitrary(campaign: InvariantCampaign, options?: {
+    readonly hasActiveContract?: boolean;
+}): fc.Arbitrary<readonly ScheduledCampaignSlot[]>;
+export declare function scheduleCampaignSlots(init: {
+    readonly actorRolls: readonly number[];
+    readonly depth: number;
+    readonly hasActiveContract: boolean;
+    readonly targetRolls: readonly number[];
+    readonly targets: readonly CampaignSchedulingTarget[];
+}): readonly ScheduledCampaignSlot[];

package/dist/testing/campaign/campaign-scheduler.js

@@ -0,0 +1,75 @@
+import * as fc from "fast-check";
+/**
+ * Generates exact-depth scheduling inputs with fast-check's seed and shrink
+ * support while delegating all eligibility decisions to the pure scheduler.
+ */
+export function createCampaignScheduleArbitrary(init) {
+    if (!Number.isSafeInteger(init.depth) || init.depth < 1) {
+        throw new Error("Campaign schedule depth must be a positive safe integer.");
+    }
+    const roll = fc.integer({ min: 0, max: Number.MAX_SAFE_INTEGER });
+    return fc.tuple(fc.array(roll, { minLength: init.depth, maxLength: init.depth }), fc.array(roll, { minLength: init.depth, maxLength: init.depth })).map(([targetRolls, actorRolls]) => scheduleCampaignSlots({
+        ...init,
+        targetRolls,
+        actorRolls,
+    }));
+}
+/**
+ * Projects a public invariant campaign definition onto generated scheduling
+ * slots. Targets without explicit actors use every configured actor in stable
+ * name order, allowing lightweight read/probe targets to share the campaign
+ * actor matrix.
+ */
+export function createInvariantCampaignScheduleArbitrary(campaign, options = {}) {
+    const defaultActors = Object.keys(campaign.runtime.actors).sort();
+    return createCampaignScheduleArbitrary({
+        depth: campaign.config.depth,
+        hasActiveContract: options.hasActiveContract ?? true,
+        targets: campaign.targets.map((target) => ({
+            key: target.key,
+            weight: 1,
+            actors: target.actors ?? defaultActors,
+        })),
+    });
+}
+export function scheduleCampaignSlots(init) {
+    if (!Number.isSafeInteger(init.depth) || init.depth < 1) {
+        throw new Error("Campaign schedule depth must be a positive safe integer.");
+    }
+    const eligibleTargets = init.targets.filter((target) => target.weight > 0
+        && target.actors.length > 0
+        && (init.hasActiveContract || target.requiresActiveContract !== true));
+    const totalWeight = eligibleTargets.reduce((sum, target) => sum + target.weight, 0);
+    if (!Number.isSafeInteger(totalWeight)) {
+        throw new Error("Campaign target weights must sum to a safe integer.");
+    }
+    return Array.from({ length: init.depth }, (_, index) => {
+        if (totalWeight === 0) {
+            return { kind: "probe" };
+        }
+        const target = selectByWeight(eligibleTargets, rollAt(init.targetRolls, index), totalWeight);
+        const actor = target.actors[rollAt(init.actorRolls, index) % target.actors.length];
+        return {
+            kind: "target",
+            targetKey: target.key,
+            actor,
+        };
+    });
+}
+function rollAt(rolls, index) {
+    if (rolls.length === 0) {
+        return 0;
+    }
+    const roll = rolls[index % rolls.length];
+    return Number.isSafeInteger(roll) && roll >= 0 ? roll : 0;
+}
+function selectByWeight(targets, roll, totalWeight) {
+    let remaining = roll % totalWeight;
+    for (const target of targets) {
+        if (remaining < target.weight) {
+            return target;
+        }
+        remaining -= target.weight;
+    }
+    throw new Error("Campaign scheduler could not select an eligible target.");
+}

package/dist/testing/campaign/campaign-types.d.ts

@@ -0,0 +1,52 @@
+export interface CantonTestActor {
+    readonly party: string;
+    readonly participant: string;
+    readonly actAs?: readonly string[];
+    readonly readAs?: readonly string[];
+}
+export type CampaignIsolation = {
+    readonly kind: "cleanup";
+} | {
+    readonly kind: "external";
+} | {
+    readonly kind: "snapshot";
+};
+export interface CampaignRuntime {
+    readonly actors: Readonly<Record<string, CantonTestActor>>;
+    readonly isolation: CampaignIsolation;
+}
+export interface InvariantCampaignConfig {
+    readonly runs: number;
+    readonly depth: number;
+    readonly failOnRevert?: boolean;
+    readonly path?: string;
+    readonly seed?: number;
+    readonly timeoutMs?: number;
+}
+export interface ResolvedInvariantCampaignConfig {
+    readonly runs: number;
+    readonly depth: number;
+    readonly failOnRevert: boolean;
+    readonly path?: string;
+    readonly seed?: number;
+    readonly timeoutMs?: number;
+}
+export interface CampaignTarget {
+    readonly key: string;
+    readonly actors?: readonly string[];
+}
+export type CampaignInvariant<Model = unknown, Ghost = unknown> = ((context: {
+    readonly model: Model;
+    readonly ghost: Ghost;
+}) => void | Promise<void>) & {
+    readonly label?: string;
+};
+export declare function invariant<Model = unknown, Ghost = unknown>(label: string, check: CampaignInvariant<Model, Ghost>): CampaignInvariant<Model, Ghost>;
+export interface InvariantCampaign<Model = unknown, Ghost = unknown> {
+    readonly runtime: CampaignRuntime;
+    readonly config: ResolvedInvariantCampaignConfig;
+    readonly targets: readonly CampaignTarget[];
+    readonly handlers: readonly CampaignHandler[];
+    readonly invariants: readonly CampaignInvariant<Model, Ghost>[];
+}
+import { CampaignHandler } from "../handlers/handler.js";

package/dist/testing/campaign/campaign-types.js

@@ -0,0 +1,11 @@
+export function invariant(label, check) {
+    if (label.length === 0) {
+        throw new Error("Invariant campaign invariant names must not be empty.");
+    }
+    const named = (context) => check(context);
+    Object.defineProperty(named, "label", {
+        value: label,
+        enumerable: true,
+    });
+    return Object.freeze(named);
+}

package/dist/testing/daml/daml-action-arbitrary.d.ts

@@ -0,0 +1,13 @@
+import * as fc from "fast-check";
+import { DeclarativeChoiceAction } from "./daml-choice-action-arbitrary.js";
+import { DeclarativeCreateAction, DeclarativeCreateActionGenerationOptions } from "./daml-create-action-arbitrary.js";
+import { DamlTestingCatalog } from "./daml-testing-catalog.js";
+import { ResolvedDeclarativeTarget } from "../targets/target.js";
+export type DeclarativeAction = DeclarativeChoiceAction | DeclarativeCreateAction;
+export type DeclarativeActionGenerationOptions = DeclarativeCreateActionGenerationOptions;
+/**
+ * Combines resolved template-create and template-choice targets into one
+ * shrinkable campaign action arbitrary. Runtime adapters can discriminate the
+ * result by `payload` (create) or `argument` (choice) before submission.
+ */
+export declare function createDeclarativeActionArbitrary(catalog: DamlTestingCatalog, targets: readonly ResolvedDeclarativeTarget[], options?: DeclarativeActionGenerationOptions): fc.Arbitrary<DeclarativeAction>;