@distrohelena/canton-typescript-sdk 0.1.28 → 0.1.30

package/dist/cjs/services/state/state-service-client.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateServiceClient = void 0;
+class StateServiceClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+        void this.transport;
+    }
+    /** Reads a page of active contracts. gRPC supports template and interface filters; JSON supports template queries only. */
+    getActiveContractsPageAsync(request, options) {
+        return this.transport.getActiveContractsPageAsync(request, options);
+    }
+    /** Reads active contracts as a stream. JSON-backed; gRPC currently rejects it. */
+    getActiveContractsAsync(request, observer, options) {
+        return this.transport.getActiveContractsAsync(request, observer, options);
+    }
+    /** Reads connected synchronizers. Supported on gRPC; JSON rejects it. */
+    getConnectedSynchronizersAsync(request, options) {
+        return this.transport.getConnectedSynchronizersAsync(request, options);
+    }
+    /** Reads the participant ledger end. Supported on gRPC; JSON rejects it. */
+    getLedgerEndAsync(request, options) {
+        return this.transport.getLedgerEndAsync(request, options);
+    }
+    /** Reads the latest participant pruning offsets. Supported on gRPC; JSON rejects it. */
+    getLatestPrunedOffsetsAsync(request, options) {
+        return this.transport.getLatestPrunedOffsetsAsync(request, options);
+    }
+}
+exports.StateServiceClient = StateServiceClient;

package/dist/cjs/services/synchronizer-connectivity/synchronizer-connectivity-service-client.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SynchronizerConnectivityServiceClient = void 0;
+class SynchronizerConnectivityServiceClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+        void this.transport;
+    }
+    /** Lists connected synchronizers. Supported on gRPC; JSON rejects it. */
+    listConnectedSynchronizersAsync(request, options) {
+        return this.transport.listConnectedSynchronizersAsync(request, options);
+    }
+    /** Reads synchronizer ids for a synchronizer alias. Supported on gRPC; JSON rejects it. */
+    getSynchronizerIdAsync(request, options) {
+        return this.transport.getSynchronizerIdAsync(request, options);
+    }
+    /** Lists registered synchronizers and their connection status. Supported on gRPC; JSON rejects it. */
+    listRegisteredSynchronizersAsync(request, options) {
+        return this.transport.listRegisteredSynchronizersAsync(request, options);
+    }
+}
+exports.SynchronizerConnectivityServiceClient = SynchronizerConnectivityServiceClient;

package/dist/cjs/services/topology-aggregation/topology-aggregation-service-client.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopologyAggregationServiceClient = void 0;
+class TopologyAggregationServiceClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+        void this.transport;
+    }
+    /** Lists aggregated party hosting information. Supported on gRPC; JSON rejects it. */
+    listPartiesAsync(request, options) {
+        return this.transport.topologyListPartiesAsync(request, options);
+    }
+    /** Lists aggregated key owner information. Supported on gRPC; JSON rejects it. */
+    listKeyOwnersAsync(request, options) {
+        return this.transport.listKeyOwnersAsync(request, options);
+    }
+}
+exports.TopologyAggregationServiceClient = TopologyAggregationServiceClient;

package/dist/cjs/services/topology-manager-read/topology-manager-read-service-client.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopologyManagerReadServiceClient = void 0;
+class TopologyManagerReadServiceClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+        void this.transport;
+    }
+    /** Reads namespace delegations. Supported on gRPC; JSON rejects it. */
+    listNamespaceDelegationAsync(request, options) {
+        return this.transport.listNamespaceDelegationAsync(request, options);
+    }
+    /** Reads decentralized namespace definitions. Supported on gRPC; JSON rejects it. */
+    listDecentralizedNamespaceDefinitionAsync(request, options) {
+        return this.transport.listDecentralizedNamespaceDefinitionAsync(request, options);
+    }
+    /** Reads owner-to-key mappings. Supported on gRPC; JSON rejects it. */
+    listOwnerToKeyMappingAsync(request, options) {
+        return this.transport.listOwnerToKeyMappingAsync(request, options);
+    }
+    /** Reads party-to-key mappings. Supported on gRPC; JSON rejects it. */
+    listPartyToKeyMappingAsync(request, options) {
+        return this.transport.listPartyToKeyMappingAsync(request, options);
+    }
+    /** Reads synchronizer trust certificates. Supported on gRPC; JSON rejects it. */
+    listSynchronizerTrustCertificateAsync(request, options) {
+        return this.transport.listSynchronizerTrustCertificateAsync(request, options);
+    }
+    /** Reads participant synchronizer permissions. Supported on gRPC; JSON rejects it. */
+    listParticipantSynchronizerPermissionAsync(request, options) {
+        return this.transport.listParticipantSynchronizerPermissionAsync(request, options);
+    }
+    /** Reads party hosting limits. Supported on gRPC; JSON rejects it. */
+    listPartyHostingLimitsAsync(request, options) {
+        return this.transport.listPartyHostingLimitsAsync(request, options);
+    }
+    /** Reads topology vetted packages. Supported on gRPC; JSON rejects it. */
+    listVettedPackagesAsync(request, options) {
+        return this.transport.topologyListVettedPackagesAsync(request, options);
+    }
+    /** Reads party-to-participant mappings. Supported on gRPC; JSON rejects it. */
+    listPartyToParticipantAsync(request, options) {
+        return this.transport.listPartyToParticipantAsync(request, options);
+    }
+    /** Reads synchronizer parameter state. Supported on gRPC; JSON rejects it. */
+    listSynchronizerParametersStateAsync(request, options) {
+        return this.transport.listSynchronizerParametersStateAsync(request, options);
+    }
+    /** Reads sequencing parameter state. Supported on gRPC; JSON rejects it. */
+    listSequencingParametersStateAsync(request, options) {
+        return this.transport.listSequencingParametersStateAsync(request, options);
+    }
+    /** Reads mediator synchronizer state. Supported on gRPC; JSON rejects it. */
+    listMediatorSynchronizerStateAsync(request, options) {
+        return this.transport.listMediatorSynchronizerStateAsync(request, options);
+    }
+    /** Reads sequencer synchronizer state. Supported on gRPC; JSON rejects it. */
+    listSequencerSynchronizerStateAsync(request, options) {
+        return this.transport.listSequencerSynchronizerStateAsync(request, options);
+    }
+    /** Reads LSU announcements. Supported on gRPC; JSON rejects it. */
+    listLsuAnnouncementAsync(request, options) {
+        return this.transport.listLsuAnnouncementAsync(request, options);
+    }
+    /** Reads LSU sequencer connection successors. Supported on gRPC; JSON rejects it. */
+    listLsuSequencerConnectionSuccessorAsync(request, options) {
+        return this.transport.listLsuSequencerConnectionSuccessorAsync(request, options);
+    }
+    /** Lists available topology stores. Supported on gRPC; JSON rejects it. */
+    listAvailableStoresAsync(request, options) {
+        return this.transport.listAvailableStoresAsync(request, options);
+    }
+    /** Reads raw topology transactions. Deprecated upstream. Supported on gRPC; JSON rejects it. */
+    listAllAsync(request, options) {
+        return this.transport.listAllAsync(request, options);
+    }
+    /** Reads raw topology transactions using the preferred V2 API. Supported on gRPC; JSON rejects it. */
+    listAllV2Async(request, options) {
+        return this.transport.listAllV2Async(request, options);
+    }
+}
+exports.TopologyManagerReadServiceClient = TopologyManagerReadServiceClient;

package/dist/cjs/services/topology-manager-write/topology-manager-write-service-client.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopologyManagerWriteServiceClient = void 0;
+const topology_signed_transaction_assembler_js_1 = require("./topology-signed-transaction-assembler.js");
+class TopologyManagerWriteServiceClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+        void this.transport;
+    }
+    /** Authorizes topology transactions. Supported on gRPC; JSON rejects it. */
+    authorizeAsync(request, options) {
+        return this.transport.authorizeTopologyTransactionsAsync(request, options);
+    }
+    /** Adds topology transactions to a topology store. Supported on gRPC; JSON rejects it. */
+    addTransactionsAsync(request, options) {
+        return this.transport.addTopologyTransactionsAsync(request, options);
+    }
+    /** Imports a serialized topology snapshot. Supported on gRPC; JSON rejects it. */
+    importTopologySnapshotAsync(request, options) {
+        return this.transport.importTopologySnapshotAsync(request, options);
+    }
+    /** Imports a serialized topology snapshot using the V2 RPC. Supported on gRPC; JSON rejects it. */
+    importTopologySnapshotV2Async(request, options) {
+        return this.transport.importTopologySnapshotV2Async(request, options);
+    }
+    /** Adds local signatures to topology transactions. Supported on gRPC; JSON rejects it. */
+    signTransactionsAsync(request, options) {
+        return this.transport.signTopologyTransactionsAsync(request, options);
+    }
+    /** Generates topology transactions from raw proposals. Supported on gRPC; JSON rejects it. */
+    generateTransactionsAsync(request, options) {
+        return this.transport.generateTopologyTransactionsAsync(request, options);
+    }
+    /** Creates a temporary topology store. Supported on gRPC; JSON rejects it. */
+    createTemporaryTopologyStoreAsync(request, options) {
+        return this.transport.createTemporaryTopologyStoreAsync(request, options);
+    }
+    /** Drops a temporary topology store. Supported on gRPC; JSON rejects it. */
+    dropTemporaryTopologyStoreAsync(request, options) {
+        return this.transport.dropTemporaryTopologyStoreAsync(request, options);
+    }
+    /** Assembles SDK-owned signed topology transactions from detached signatures. SDK-local; transport independent. */
+    assembleSignedTransactions(request) {
+        return (0, topology_signed_transaction_assembler_js_1.assembleSignedTopologyTransactions)(request);
+    }
+}
+exports.TopologyManagerWriteServiceClient = TopologyManagerWriteServiceClient;

package/dist/cjs/services/topology-manager-write/topology-signed-transaction-assembler.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assembleSignedTopologyTransactions = assembleSignedTopologyTransactions;
+const validation_error_js_1 = require("../../core/errors/validation-error.js");
+const signed_topology_transaction_js_1 = require("../../core/types/topology/signed-topology-transaction.js");
+const topology_signature_format_js_1 = require("../../core/types/topology/topology-signature-format.js");
+const topology_transaction_signature_js_1 = require("../../core/types/topology/topology-transaction-signature.js");
+function assembleSignedTopologyTransactions(request) {
+    const preparedTransactionsByHash = new Map(request.preparedTransactions.map((preparedTransaction) => [
+        toHex(preparedTransaction.transactionHash),
+        preparedTransaction,
+    ]));
+    const signaturesByHash = new Map();
+    const seenSignerPairs = new Set();
+    for (const signature of request.signatures) {
+        validateExternalSignature(signature);
+        const signatureFormat = signature.signatureFormat;
+        const hashKey = toHex(signature.transactionHash);
+        const preparedTransaction = preparedTransactionsByHash.get(hashKey);
+        if (preparedTransaction === undefined) {
+            throw new validation_error_js_1.ValidationError(`No prepared transaction matches detached signature hash ${hashKey}.`);
+        }
+        const signerKey = `${hashKey}:${signature.signedByFingerprint}`;
+        if (seenSignerPairs.has(signerKey)) {
+            throw new validation_error_js_1.ValidationError(`Duplicate detached signature for signer ${signature.signedByFingerprint} on transaction ${hashKey}.`);
+        }
+        seenSignerPairs.add(signerKey);
+        const mappedSignature = new topology_transaction_signature_js_1.TopologyTransactionSignature({
+            format: mapExternalSignatureFormatToRawFormat(signatureFormat),
+            signature: signature.signature,
+            signedByFingerprint: signature.signedByFingerprint,
+            signingAlgorithmSpec: signature.signingAlgorithmSpec
+                ?? mapExternalSignatureFormatToAlgorithmSpec(signatureFormat),
+            signatureDelegation: signature.signatureDelegation,
+        });
+        const existing = signaturesByHash.get(hashKey) ?? [];
+        existing.push(mappedSignature);
+        signaturesByHash.set(hashKey, existing);
+    }
+    return request.preparedTransactions.map((preparedTransaction) => new signed_topology_transaction_js_1.SignedTopologyTransaction({
+        transaction: preparedTransaction.serializedTransaction,
+        signatures: signaturesByHash.get(toHex(preparedTransaction.transactionHash)) ?? [],
+        proposal: preparedTransaction.proposal,
+        multiTransactionSignatures: [],
+    }));
+}
+function validateExternalSignature(signature) {
+    if (signature.transactionHash.length === 0) {
+        throw new validation_error_js_1.ValidationError("Detached topology signatures require a transactionHash.");
+    }
+    else if (signature.signature.length === 0) {
+        throw new validation_error_js_1.ValidationError("Detached topology signatures require signature bytes.");
+    }
+    else if (signature.signedByFingerprint.length === 0) {
+        throw new validation_error_js_1.ValidationError("Detached topology signatures require signedByFingerprint.");
+    }
+    else if (signature.signatureFormat === undefined) {
+        throw new validation_error_js_1.ValidationError("Detached topology signatures require signatureFormat.");
+    }
+}
+function mapExternalSignatureFormatToRawFormat(signatureFormat) {
+    switch (signatureFormat) {
+        case topology_signature_format_js_1.TopologySignatureFormat.ed25519:
+            return "concat";
+        case topology_signature_format_js_1.TopologySignatureFormat.ecDsaSha256:
+            return "der";
+        default:
+            return "unspecified";
+    }
+}
+function mapExternalSignatureFormatToAlgorithmSpec(signatureFormat) {
+    switch (signatureFormat) {
+        case topology_signature_format_js_1.TopologySignatureFormat.ed25519:
+            return "ed25519";
+        case topology_signature_format_js_1.TopologySignatureFormat.ecDsaSha256:
+            return "ecDsaSha256";
+        default:
+            return "unspecified";
+    }
+}
+function toHex(bytes) {
+    return [...bytes]
+        .map((value) => value.toString(16).padStart(2, "0"))
+        .join("");
+}

package/dist/cjs/services/traffic-control/traffic-control-service-client.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrafficControlServiceClient = void 0;
+class TrafficControlServiceClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+        void this.transport;
+    }
+    /** Reads participant traffic control state. Supported on gRPC; JSON rejects it. */
+    trafficControlStateAsync(request, options) {
+        return this.transport.trafficControlStateAsync(request, options);
+    }
+}
+exports.TrafficControlServiceClient = TrafficControlServiceClient;

package/dist/cjs/services/update/update-service-client.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateServiceClient = void 0;
+class UpdateServiceClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+        void this.transport;
+    }
+    /** Reads ledger updates. gRPC-backed; JSON currently rejects it. */
+    getUpdatesAsync(request, options) {
+        return this.getUpdatesLazy(request, options);
+    }
+    /** Reads one update by offset. Supported on gRPC; JSON rejects it. */
+    getUpdateByOffsetAsync(request, options) {
+        return this.transport.getUpdateByOffsetAsync(request, options);
+    }
+    /** Reads one update by update id. Supported on gRPC; JSON rejects it. */
+    getUpdateByIdAsync(request, options) {
+        return this.transport.getUpdateByIdAsync(request, options);
+    }
+    /** Reads one update by transaction hash. Supported on gRPC; JSON rejects it. */
+    getUpdateByHashAsync(request, options) {
+        return this.transport.getUpdateByHashAsync(request, options);
+    }
+    /** Reads a page of updates. Supported on gRPC; JSON rejects it. */
+    getUpdatesPageAsync(request, options) {
+        return this.transport.getUpdatesPageAsync(request, options);
+    }
+    async *getUpdatesLazy(request, options) {
+        yield* this.transport.getUpdatesAsync(request, options);
+    }
+}
+exports.UpdateServiceClient = UpdateServiceClient;

package/dist/cjs/services/user-management/user-management-service-client.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserManagementServiceClient = void 0;
+class UserManagementServiceClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+        void this.transport;
+    }
+    /** Grants user rights. Supported on JSON and gRPC. */
+    grantUserRightsAsync(request, options) {
+        return this.transport.grantUserRightsAsync(request, options);
+    }
+    /** Reads a participant user. Supported on gRPC; JSON rejects it. */
+    getUserAsync(request, options) {
+        return this.transport.getUserAsync(request, options);
+    }
+    /** Lists participant users. Supported on gRPC; JSON rejects it. */
+    listUsersAsync(request, options) {
+        return this.transport.listUsersAsync(request, options);
+    }
+    /** Lists rights for a participant user. Supported on gRPC; JSON rejects it. */
+    listUserRightsAsync(request, options) {
+        return this.transport.listUserRightsAsync(request, options);
+    }
+}
+exports.UserManagementServiceClient = UserManagementServiceClient;

package/dist/cjs/services/version/version-service-client.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionServiceClient = void 0;
+class VersionServiceClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+        void this.transport;
+    }
+    /** Reads the ledger API version. Supported on JSON and gRPC. */
+    getLedgerApiVersionAsync(request, options) {
+        return this.transport.getLedgerApiVersionAsync(request, options);
+    }
+}
+exports.VersionServiceClient = VersionServiceClient;

package/dist/cjs/testing/campaign/campaign-artifact.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCampaignFingerprint = createCampaignFingerprint;
+exports.serializeCampaignReplayArtifact = serializeCampaignReplayArtifact;
+exports.selectCampaignCounterexampleTrace = selectCampaignCounterexampleTrace;
+exports.writeCampaignReplayArtifactAsync = writeCampaignReplayArtifactAsync;
+exports.loadCampaignReplayArtifactAsync = loadCampaignReplayArtifactAsync;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+function createCampaignFingerprint(value) {
+    return (0, node_crypto_1.createHash)("sha256")
+        .update(canonicalCampaignJson(value))
+        .digest("hex");
+}
+function serializeCampaignReplayArtifact(artifact) {
+    return `${JSON.stringify({
+        schemaVersion: artifact.schemaVersion,
+        fingerprint: artifact.fingerprint,
+        actions: artifact.actions.map((action) => ({
+            ...(typeof action.targetKey === "string"
+                ? { targetKey: action.targetKey }
+                : {}),
+            ...(typeof action.actor === "string" ? { actor: action.actor } : {}),
+            ...(typeof action.outcome === "string"
+                ? { outcome: action.outcome }
+                : {}),
+        })),
+        metrics: artifact.metrics,
+        numRuns: artifact.numRuns,
+        numShrinks: artifact.numShrinks,
+        ...(artifact.seed === undefined ? {} : { seed: artifact.seed }),
+        ...(artifact.counterexamplePath === undefined
+            ? {}
+            : { counterexamplePath: artifact.counterexamplePath }),
+    })}\n`;
+}
+function selectCampaignCounterexampleTrace(details, traces) {
+    if (!details.failed || details.counterexampleKey === undefined) {
+        throw new Error("Invariant campaign did not produce a counterexample.");
+    }
+    const trace = traces.get(details.counterexampleKey);
+    if (trace === undefined) {
+        throw new Error("Final invariant campaign counterexample has no trace.");
+    }
+    return trace;
+}
+async function writeCampaignReplayArtifactAsync(filename, artifact) {
+    const destination = (0, node_path_1.resolve)(filename);
+    await ensureSecureDirectoryAsync((0, node_path_1.dirname)(destination));
+    const handle = await (0, promises_1.open)(destination, "wx", 0o600);
+    try {
+        await handle.writeFile(serializeCampaignReplayArtifact(artifact), "utf8");
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function loadCampaignReplayArtifactAsync(filename, fingerprint) {
+    const artifact = JSON.parse(await (0, promises_1.readFile)((0, node_path_1.resolve)(filename), "utf8"));
+    if (!isCampaignReplayArtifact(artifact)) {
+        throw new Error("Invariant campaign replay artifact has an invalid schema.");
+    }
+    else if (artifact.fingerprint !== fingerprint) {
+        throw new Error("Invariant campaign replay artifact fingerprint does not match.");
+    }
+    return artifact;
+}
+function canonicalCampaignJson(value) {
+    return JSON.stringify(sortJsonValue(value));
+}
+function sortJsonValue(value) {
+    if (Array.isArray(value)) {
+        return value.map(sortJsonValue);
+    }
+    else if (value !== null && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, nested]) => [key, sortJsonValue(nested)]));
+    }
+    return value;
+}
+function isCampaignReplayArtifact(value) {
+    return value !== null
+        && typeof value === "object"
+        && value.schemaVersion === 1
+        && typeof value.fingerprint === "string"
+        && Array.isArray(value.actions)
+        && value.actions.every(isReplayAction)
+        && isCampaignMetrics(value.metrics)
+        && isPositiveSafeInteger(value.numRuns)
+        && isNonNegativeSafeInteger(value.numShrinks);
+}
+function isReplayAction(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const action = value;
+    const allowedKeys = new Set(["actor", "outcome", "targetKey"]);
+    return Object.entries(action).every(([key, field]) => allowedKeys.has(key) && typeof field === "string");
+}
+function isPositiveSafeInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function isNonNegativeSafeInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isCampaignMetrics(value) {
+    if (value === null || typeof value !== "object") {
+        return false;
+    }
+    const candidate = value;
+    return isMetricGroup(candidate.byActor) && isMetricGroup(candidate.byTarget);
+}
+function isMetricGroup(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    return Object.values(value).every((outcomes) => outcomes !== null
+        && typeof outcomes === "object"
+        && !Array.isArray(outcomes)
+        && Object.values(outcomes).every((count) => typeof count === "number" && Number.isSafeInteger(count) && count >= 0));
+}
+async function ensureSecureDirectoryAsync(directory) {
+    const absoluteDirectory = (0, node_path_1.resolve)(directory);
+    const root = (0, node_path_1.parse)(absoluteDirectory).root;
+    const segments = (0, node_path_1.relative)(root, absoluteDirectory).split(node_path_1.sep).filter(Boolean);
+    let current = root;
+    for (const segment of segments) {
+        current = (0, node_path_1.resolve)(current, segment);
+        try {
+            const entry = await (0, promises_1.lstat)(current);
+            if (entry.isSymbolicLink()) {
+                throw new Error(`Invariant campaign artifact parent is a symlink: ${current}`);
+            }
+            else if (!entry.isDirectory()) {
+                throw new Error(`Invariant campaign artifact parent is not a directory: ${current}`);
+            }
+        }
+        catch (error) {
+            if (!isNotFoundError(error)) {
+                throw error;
+            }
+            await (0, promises_1.mkdir)(current, { mode: 0o700 });
+        }
+    }
+    await (0, promises_1.chmod)(absoluteDirectory, 0o700);
+}
+function isNotFoundError(error) {
+    return typeof error === "object"
+        && error !== null
+        && error.code === "ENOENT";
+}

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

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineInvariantCampaign = defineInvariantCampaign;
+const testing_configuration_error_js_1 = require("../errors/testing-configuration-error.js");
+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 testing_configuration_error_js_1.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 testing_configuration_error_js_1.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 testing_configuration_error_js_1.TestingConfigurationError(`Invariant campaign handler '${handler.name}' is duplicated.`);
+        }
+        names.add(handler.name);
+        if (runtime.isolation.kind === "cleanup" && handler.cleanup === "none") {
+            throw new testing_configuration_error_js_1.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 testing_configuration_error_js_1.TestingConfigurationError("Invariant campaign runs must be a positive safe integer.");
+    }
+    else if (!Number.isSafeInteger(config.depth) || config.depth < 1) {
+        throw new testing_configuration_error_js_1.TestingConfigurationError("Invariant campaign depth must be a positive safe integer.");
+    }
+    else if (config.seed !== undefined && !Number.isSafeInteger(config.seed)) {
+        throw new testing_configuration_error_js_1.TestingConfigurationError("Invariant campaign seed must be a safe integer.");
+    }
+    else if (config.timeoutMs !== undefined
+        && (!Number.isSafeInteger(config.timeoutMs) || config.timeoutMs < 1)) {
+        throw new testing_configuration_error_js_1.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 testing_configuration_error_js_1.TestingConfigurationError("Invariant campaign target keys must not be empty.");
+    }
+    else if (target.actors !== undefined && target.actors.length === 0) {
+        throw new testing_configuration_error_js_1.TestingConfigurationError(`Invariant campaign target '${target.key}' requires at least one actor.`);
+    }
+    for (const actor of target.actors ?? []) {
+        if (runtime.actors[actor] === undefined) {
+            throw new testing_configuration_error_js_1.TestingConfigurationError(`Invariant campaign target '${target.key}' references unknown actor '${actor}'.`);
+        }
+    }
+}

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCampaignMetrics = createCampaignMetrics;
+exports.recordCampaignAction = recordCampaignAction;
+function createCampaignMetrics() {
+    return {
+        byActor: {},
+        byTarget: {},
+    };
+}
+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))),
+    ]));
+}