@atcn/sdk 1.3.0

package/dist/client.d.ts

@@ -0,0 +1,395 @@
+import type { ClearingDecision, EventPayload, PublicKeyRecord, Signed } from "@atcn/schema";
+export declare class AtcnApiError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly reason: string | undefined;
+    readonly retryable: boolean;
+    readonly correlationId: string | undefined;
+    readonly details: unknown;
+    constructor(status: number, code: string, message: string, reason: string | undefined, retryable: boolean, correlationId: string | undefined, details: unknown);
+}
+/** Must equal this package's version in package.json (checked by a test). */
+export declare const SDK_VERSION = "1.3.0";
+/** Names the SDK and its version on every request, so the API operator can count SDK versions in use. Nothing else is sent. */
+export declare const SDK_HEADER = "atcn-sdk";
+export interface ClientOptions {
+    baseUrl: string;
+    apiKey: string;
+    /** Retries for retryable failures (same Idempotency-Key, so retries never duplicate effects). */
+    retries?: number;
+    fetch?: typeof fetch;
+    /** Extra headers sent on every request, for example `{ "atcn-workflow": "demo" }` from the bundled examples. */
+    headers?: Record<string, string>;
+}
+export interface RequestOptions {
+    idempotencyKey?: string;
+    query?: Record<string, string | number | undefined>;
+    headers?: Record<string, string>;
+    rawBody?: Uint8Array;
+    textBody?: {
+        contentType: string;
+        text: string;
+    };
+}
+type SignedEvent = Signed<EventPayload>;
+type Json = Record<string, unknown>;
+/** Thin HTTP client for the ATCN API. Every mutating call carries an Idempotency-Key. */
+export declare class AtcnClient {
+    private readonly options;
+    private readonly fetchImpl;
+    constructor(options: ClientOptions);
+    request<T = Json>(method: string, path: string, body?: unknown, opts?: RequestOptions): Promise<T>;
+    /**
+     * Creates or offers an obligation. With `subledger`, the obligation also becomes a delegation of one of the
+     * caller's subledger tasks; the link is not part of the signed event and is never shared with the counterparty.
+     */
+    createObligation(signed: SignedEvent, subledger?: {
+        task_id: string;
+        parent_delegation_id?: string | null;
+    }): Promise<{
+        obligation: Json;
+        event: Json;
+        subledger?: {
+            task_id: string;
+            delegation_id: string;
+        };
+    }>;
+    acceptObligation(obligationId: string, signed: SignedEvent): Promise<{
+        obligation: Json;
+        event: Json;
+    }>;
+    appendEvent(obligationId: string, signed: SignedEvent): Promise<{
+        obligation: Json;
+        event: Json;
+    }>;
+    getObligation(obligationId: string): Promise<Json>;
+    listObligations(query?: {
+        state?: string;
+        root_id?: string;
+        limit?: number;
+    }): Promise<{
+        items: Json[];
+    }>;
+    listEvents(obligationId: string): Promise<{
+        items: Json[];
+    }>;
+    getChain(obligationId: string): Promise<Json>;
+    getAllocation(obligationId: string): Promise<Json>;
+    uploadBlob(bytes: Uint8Array, mediaType?: string): Promise<{
+        digest: string;
+        uri: string;
+        size_bytes: number;
+    }>;
+    submitEvidence(obligationId: string, signed: SignedEvent): Promise<{
+        evidence: Json;
+        event: Json;
+        reevaluation: {
+            decision: ClearingDecision;
+            reused: boolean;
+        } | null;
+    }>;
+    listEvidence(obligationId: string): Promise<{
+        items: Json[];
+    }>;
+    evidenceLink(evidenceId: string): Promise<{
+        url: string;
+        expires_at: string;
+    }>;
+    evaluate(obligationId: string, policy: {
+        policy_id: string;
+        policy_version: string;
+    }, idempotencyKey?: string): Promise<{
+        decision: ClearingDecision;
+        reused: boolean;
+    }>;
+    listDecisions(obligationId: string): Promise<{
+        items: ClearingDecision[];
+    }>;
+    finalize(decisionId: string, idempotencyKey?: string): Promise<Json>;
+    openDispute(decisionId: string, signed: SignedEvent): Promise<Json>;
+    reviewDispute(disputeId: string, signed: SignedEvent): Promise<Json>;
+    listDisputes(query?: {
+        status?: string;
+        obligation_id?: string;
+    }): Promise<{
+        items: Json[];
+    }>;
+    journal(query?: Record<string, string | number | undefined>): Promise<{
+        items: Json[];
+    }>;
+    statement(query?: Record<string, string | number | undefined>): Promise<Json>;
+    createSettlementInstruction(input: {
+        obligation_id: string;
+        beneficiary_ref: string;
+        amount_minor: number;
+        currency: string;
+        adapter: "manual" | "sandbox" | "stripe";
+    }, idempotencyKey?: string): Promise<Json>;
+    reportSettlementEvent(input: Json, idempotencyKey?: string): Promise<Json>;
+    reconciliationExceptions(status?: string): Promise<{
+        items: Json[];
+    }>;
+    exportClosurePackage(obligationId: string): Promise<{
+        payload: {
+            package_version: "1.0";
+            generated_at: string;
+            root_obligation_id: string;
+            requested_obligation_id: string;
+            obligations: {
+                obligation_id: string;
+                parent_obligation_id: string | null;
+                redacted: boolean;
+                effective_terms: {
+                    schema_version: "1.0";
+                    obligation_id: string;
+                    terms_version: number;
+                    parent_obligation_id: string | null;
+                    principal_id: string;
+                    payer_id: string;
+                    issuer_agent_id: string;
+                    counterparty_agent_id: string | null;
+                    payee_selection: {
+                        type: "open_offer";
+                        allowed_platform_ids: string[];
+                    } | null;
+                    scope: {
+                        task_type: string;
+                        description: string;
+                        artifact_ref?: string | undefined;
+                    };
+                    currency: string;
+                    max_amount_minor: number;
+                    deliverables: {
+                        deliverable_id: string;
+                        description: string;
+                        amount_minor: number;
+                        required_checks: string[];
+                    }[];
+                    acceptance_policy: {
+                        policy_id: string;
+                        policy_version: string;
+                        policy_digest: string;
+                    };
+                    deadline: string;
+                    offer_expires_at: string;
+                    allow_subdelegation: boolean;
+                    subdelegation_limits: {
+                        max_depth: number;
+                        max_total_minor: number;
+                        allowed_policy_ids: string[];
+                    } | null;
+                    dispute_reviewer_id: string | null;
+                    verifier_agent_ids: string[];
+                    issued_at: string;
+                } | null;
+                effective_terms_digest: string | null;
+                state: string;
+            }[];
+            events: {
+                payload: {
+                    schema_version: "1.0";
+                    event_id: string;
+                    event_type: string;
+                    obligation_id: string;
+                    actor_id: string;
+                    actor_platform_id: string;
+                    event_time: string;
+                    causation_ids: string[];
+                    data: Record<string, unknown>;
+                };
+                signature: {
+                    key_id: string;
+                    key_version: number;
+                    algorithm: "Ed25519";
+                    value: string;
+                };
+                payload_hash: string;
+                received_at: string;
+                sequence: number;
+            }[];
+            public_keys: {
+                key_id: string;
+                key_version: number;
+                actor_id: string;
+                algorithm: "Ed25519";
+                public_key: string;
+                valid_from: string;
+                revoked_at: string | null;
+            }[];
+            policies: {
+                schema_version: "1.0";
+                policy_id: string;
+                policy_version: string;
+                task_type: string;
+                description: string;
+                evidence_admissibility: {
+                    allowed_producers: ("issuer" | "counterparty" | "verifier")[];
+                    require_digest_match: boolean;
+                };
+                required_evidence: string[];
+                checks: {
+                    check_id: string;
+                    verifier: string;
+                    verifier_version: string;
+                    evidence_type: string;
+                    config: Record<string, unknown>;
+                }[];
+                thresholds: {
+                    partial_acceptance: boolean;
+                    failed_portion_outcome: "disputed" | "rejected";
+                };
+                verifier_unavailable_outcome: "insufficient_evidence" | "disputed";
+                probabilistic_routing: "evidence_only" | "human_review";
+                timeouts: {
+                    evaluation_window_seconds: number;
+                };
+                dispute: {
+                    window_seconds: number;
+                    review_window_seconds: number;
+                    default_outcome: "uphold";
+                };
+                allocation: {
+                    platform_fee_bps: number;
+                };
+                rounding: "largest_remainder";
+            }[];
+            evidence: {
+                evidence_id: string;
+                evidence_type: string;
+                producer_id: string;
+                created_at: string;
+                content_digest: string;
+                uri: string;
+                retrieval_method: "https" | "atcn-blob" | "out_of_band";
+                media_type: string;
+                access_policy: {
+                    visible_to: ("issuer" | "counterparty" | "verifier" | "reviewer")[];
+                };
+                verifiers: string[];
+                deliverable_ids: string[];
+            }[];
+            verifier_results: {
+                result_id: string;
+                obligation_id: string;
+                check_id: string;
+                deliverable_id: string;
+                verifier_name: string;
+                verifier_version: string;
+                config_digest: string;
+                kind: "deterministic" | "probabilistic";
+                evidence_ids: string[];
+                evidence_digests: string[];
+                status: "pass" | "fail" | "invalid_evidence" | "missing_evidence" | "unavailable";
+                details: Record<string, unknown>;
+                model: {
+                    name: string;
+                    version: string;
+                    confidence_bps: number;
+                } | null;
+                executed_at: string;
+            }[];
+            decisions: {
+                obligation_id: string;
+                terms_version: number;
+                terms_digest: string;
+                policy: {
+                    policy_id: string;
+                    policy_version: string;
+                    policy_digest: string;
+                };
+                outcome: "insufficient_evidence" | "disputed" | "accepted" | "rejected" | "cancelled" | "expired" | "partially_accepted";
+                currency: string;
+                accepted_amount_minor: number;
+                rejected_amount_minor: number;
+                disputed_amount_minor: number;
+                pending_amount_minor: number;
+                deliverable_outcomes: {
+                    deliverable_id: string;
+                    amount_minor: number;
+                    outcome: "insufficient_evidence" | "disputed" | "accepted" | "rejected";
+                    reasons: {
+                        code: "invalid_evidence" | "missing_evidence" | "failed_criteria" | "verifier_unavailable" | "probabilistic_review_required" | "partial_not_permitted" | "passed" | "dispute_amended" | "dispute_upheld";
+                        check_id?: string | undefined;
+                        evidence_type?: string | undefined;
+                        detail?: string | undefined;
+                    }[];
+                }[];
+                input_event_ids: string[];
+                evidence_digests: string[];
+                verifier_output_digests: string[];
+                decision_maker: {
+                    type: "automated" | "human";
+                    id: string;
+                };
+                decision_id: string;
+                decision_digest: string;
+                decided_at: string;
+                supersedes_decision_id: string | null;
+                input_cutoff_sequence: number;
+            }[];
+            posting_batches: {
+                batch_id: string;
+                obligation_id: string;
+                entry_type: "refund" | "reversal" | "contingent" | "dispute_freeze" | "settlement" | "reserve" | "clearing" | "dispute_release" | "return";
+                decision_id: string | null;
+                settlement_event_id: string | null;
+                reverses_batch_id: string | null;
+                policy_version: string | null;
+                source_event_ids: string[];
+                rounding: {
+                    method: string;
+                    detail: string;
+                } | null;
+                lines: {
+                    account_type: "refund" | "payable" | "obligation_expense" | "contingent_expense" | "contingent_payable" | "receivable" | "platform_fee" | "dispute_frozen" | "reserve_reported" | "settlement_reported" | "unallocated_residual";
+                    party_id: string;
+                    allocation_role: "refund" | "contingent" | "dispute_freeze" | "settlement" | "reserve" | "platform_fee" | "unallocated_residual" | "payer_expense" | "payee_share" | "parent_margin" | "child_cost";
+                    currency: string;
+                    debit_minor: number;
+                    credit_minor: number;
+                }[];
+                posted_at: string;
+            }[];
+            settlement_instructions: {
+                instruction_id: string;
+                obligation_id: string;
+                decision_id: string;
+                beneficiary_party_id: string;
+                beneficiary_ref: string;
+                currency: string;
+                amount_minor: number;
+                adapter: "manual" | "sandbox" | "stripe";
+                idempotency_key: string;
+                expires_at: string;
+                status: "unknown" | "failed" | "refunded" | "settled" | "returned" | "submitted" | "processing";
+                created_at: string;
+            }[];
+            settlement_events: {
+                settlement_event_id: string;
+                instruction_id: string | null;
+                provider: "manual" | "sandbox" | "stripe";
+                provider_event_id: string;
+                provider_reference: string;
+                provider_status: string;
+                normalized_status: "unknown" | "failed" | "refunded" | "settled" | "returned" | "submitted" | "processing";
+                currency: string;
+                amount_minor: number;
+                raw_json: string;
+                reported_at: string;
+            }[];
+        };
+        signature: {
+            key_id: string;
+            key_version: number;
+            algorithm: "Ed25519";
+            value: string;
+        };
+    }>;
+    serviceKeys(): Promise<{
+        items: PublicKeyRecord[];
+    }>;
+    keysForActor(actorId: string): Promise<{
+        items: PublicKeyRecord[];
+    }>;
+}
+export {};

package/dist/client.js

@@ -0,0 +1,167 @@
+export class AtcnApiError extends Error {
+    status;
+    code;
+    reason;
+    retryable;
+    correlationId;
+    details;
+    constructor(status, code, message, reason, retryable, correlationId, details) {
+        super(`${code}${reason ? ` (${reason})` : ""}: ${message}`);
+        this.status = status;
+        this.code = code;
+        this.reason = reason;
+        this.retryable = retryable;
+        this.correlationId = correlationId;
+        this.details = details;
+    }
+}
+/** Must equal this package's version in package.json (checked by a test). */
+export const SDK_VERSION = "1.3.0";
+/** Names the SDK and its version on every request, so the API operator can count SDK versions in use. Nothing else is sent. */
+export const SDK_HEADER = "atcn-sdk";
+/** Thin HTTP client for the ATCN API. Every mutating call carries an Idempotency-Key. */
+export class AtcnClient {
+    options;
+    fetchImpl;
+    constructor(options) {
+        this.options = options;
+        this.fetchImpl = options.fetch ?? fetch;
+    }
+    async request(method, path, body, opts = {}) {
+        const url = new URL(path, this.options.baseUrl);
+        for (const [k, v] of Object.entries(opts.query ?? {}))
+            if (v !== undefined)
+                url.searchParams.set(k, String(v));
+        const headers = {
+            [SDK_HEADER]: `typescript/${SDK_VERSION}`,
+            authorization: `Bearer ${this.options.apiKey}`,
+            ...this.options.headers,
+            ...opts.headers,
+        };
+        if (method !== "GET")
+            headers["idempotency-key"] = opts.idempotencyKey ?? crypto.randomUUID();
+        let payload;
+        if (opts.rawBody) {
+            headers["content-type"] = "application/octet-stream";
+            payload = opts.rawBody;
+        }
+        else if (opts.textBody) {
+            headers["content-type"] = opts.textBody.contentType;
+            payload = opts.textBody.text;
+        }
+        else if (body !== undefined) {
+            headers["content-type"] = "application/json";
+            payload = JSON.stringify(body);
+        }
+        const attempts = (this.options.retries ?? 2) + 1;
+        for (let attempt = 1;; attempt++) {
+            let response;
+            try {
+                response = await this.fetchImpl(url, { method, headers, body: payload });
+            }
+            catch (error) {
+                if (attempt < attempts)
+                    continue;
+                throw error;
+            }
+            const text = await response.text();
+            const parsed = text && response.headers.get("content-type")?.includes("json") ? JSON.parse(text) : text;
+            if (response.ok)
+                return parsed;
+            const err = parsed ?? {};
+            const apiError = new AtcnApiError(response.status, err.error?.code ?? "http_error", err.error?.message ?? String(parsed), err.error?.reason, err.error?.retryable ?? false, err.correlation_id, err.error?.details);
+            if (apiError.retryable && attempt < attempts) {
+                await new Promise((resolve) => setTimeout(resolve, 100 * 2 ** attempt));
+                continue;
+            }
+            throw apiError;
+        }
+    }
+    // ---- Obligations ----
+    /**
+     * Creates or offers an obligation. With `subledger`, the obligation also becomes a delegation of one of the
+     * caller's subledger tasks; the link is not part of the signed event and is never shared with the counterparty.
+     */
+    createObligation(signed, subledger) {
+        return this.request("POST", "/v1/obligations", subledger ? { ...signed, subledger } : signed, { idempotencyKey: `event:${signed.payload.event_id}` });
+    }
+    acceptObligation(obligationId, signed) {
+        return this.request("POST", `/v1/obligations/${obligationId}/accept`, signed, { idempotencyKey: `event:${signed.payload.event_id}` });
+    }
+    appendEvent(obligationId, signed) {
+        return this.request("POST", `/v1/obligations/${obligationId}/events`, signed, { idempotencyKey: `event:${signed.payload.event_id}` });
+    }
+    getObligation(obligationId) {
+        return this.request("GET", `/v1/obligations/${obligationId}`);
+    }
+    listObligations(query = {}) {
+        return this.request("GET", "/v1/obligations", undefined, { query });
+    }
+    listEvents(obligationId) {
+        return this.request("GET", `/v1/obligations/${obligationId}/events`);
+    }
+    getChain(obligationId) {
+        return this.request("GET", `/v1/obligations/${obligationId}/chain`);
+    }
+    getAllocation(obligationId) {
+        return this.request("GET", `/v1/obligations/${obligationId}/allocation`);
+    }
+    // ---- Evidence ----
+    uploadBlob(bytes, mediaType = "application/octet-stream") {
+        return this.request("POST", "/v1/blobs", undefined, { rawBody: bytes, headers: { "x-media-type": mediaType } });
+    }
+    submitEvidence(obligationId, signed) {
+        return this.request("POST", `/v1/obligations/${obligationId}/evidence`, signed, { idempotencyKey: `event:${signed.payload.event_id}` });
+    }
+    listEvidence(obligationId) {
+        return this.request("GET", `/v1/obligations/${obligationId}/evidence`);
+    }
+    evidenceLink(evidenceId) {
+        return this.request("GET", `/v1/evidence/${evidenceId}/link`);
+    }
+    // ---- Clearing and disputes ----
+    evaluate(obligationId, policy, idempotencyKey) {
+        return this.request("POST", `/v1/obligations/${obligationId}/evaluate`, policy, { idempotencyKey });
+    }
+    listDecisions(obligationId) {
+        return this.request("GET", `/v1/obligations/${obligationId}/decisions`);
+    }
+    finalize(decisionId, idempotencyKey) {
+        return this.request("POST", `/v1/decisions/${decisionId}/finalize`, undefined, { idempotencyKey });
+    }
+    openDispute(decisionId, signed) {
+        return this.request("POST", `/v1/decisions/${decisionId}/disputes`, signed, { idempotencyKey: `event:${signed.payload.event_id}` });
+    }
+    reviewDispute(disputeId, signed) {
+        return this.request("POST", `/v1/disputes/${disputeId}/review`, signed, { idempotencyKey: `event:${signed.payload.event_id}` });
+    }
+    listDisputes(query = {}) {
+        return this.request("GET", "/v1/disputes", undefined, { query });
+    }
+    // ---- Journal, settlement, reconciliation, exports ----
+    journal(query = {}) {
+        return this.request("GET", "/v1/journal", undefined, { query });
+    }
+    statement(query = {}) {
+        return this.request("GET", "/v1/journal/statement", undefined, { query });
+    }
+    createSettlementInstruction(input, idempotencyKey) {
+        return this.request("POST", "/v1/settlements/instructions", input, { idempotencyKey });
+    }
+    reportSettlementEvent(input, idempotencyKey) {
+        return this.request("POST", "/v1/settlements/events", input, { idempotencyKey });
+    }
+    reconciliationExceptions(status) {
+        return this.request("GET", "/v1/reconciliation/exceptions", undefined, { query: { status } });
+    }
+    exportClosurePackage(obligationId) {
+        return this.request("GET", `/v1/exports/${obligationId}`);
+    }
+    // ---- Keys ----
+    serviceKeys() {
+        return this.request("GET", "/v1/service/keys");
+    }
+    keysForActor(actorId) {
+        return this.request("GET", "/v1/keys", undefined, { query: { actor_id: actorId } });
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { EventSigner, type SignerIdentity } from "./signer.js";
+export { buildTerms, termsData, acceptanceData, buildEvidenceEnvelope, type TermsInput, type EnvelopeInput } from "./builders.js";
+export { AtcnClient, AtcnApiError, SDK_HEADER, SDK_VERSION, type ClientOptions, type RequestOptions } from "./client.js";
+export { verifyClosurePackage, REFERENCE_POLICIES, CODE_CHANGE_POLICY_V1, CODE_CHANGE_POLICY_V1_1, CODE_CHANGE_SUBTASK_POLICY_V1 } from "@atcn/core";
+export { SubledgerClient, ReceiptLinkClient, CaptureQueue, ext, stableKey, type CaptureOperation, type CaptureQueueOptions, type FlushResult } from "./subledger.js";
+export { verifySubledgerDocument, buildResponseStatement, signStatement, verifyStatementSignature } from "@atcn/subledger";
+export { verifyWebhook, signWebhook, WEBHOOK_SIGNATURE_HEADER, generateKeyPair, digestOf, sha256Digest, canonicalize } from "@atcn/schema";

package/dist/index.js

@@ -0,0 +1,7 @@
+export { EventSigner } from "./signer.js";
+export { buildTerms, termsData, acceptanceData, buildEvidenceEnvelope } from "./builders.js";
+export { AtcnClient, AtcnApiError, SDK_HEADER, SDK_VERSION } from "./client.js";
+export { verifyClosurePackage, REFERENCE_POLICIES, CODE_CHANGE_POLICY_V1, CODE_CHANGE_POLICY_V1_1, CODE_CHANGE_SUBTASK_POLICY_V1 } from "@atcn/core";
+export { SubledgerClient, ReceiptLinkClient, CaptureQueue, ext, stableKey } from "./subledger.js";
+export { verifySubledgerDocument, buildResponseStatement, signStatement, verifyStatementSignature } from "@atcn/subledger";
+export { verifyWebhook, signWebhook, WEBHOOK_SIGNATURE_HEADER, generateKeyPair, digestOf, sha256Digest, canonicalize } from "@atcn/schema";

package/dist/init.d.ts

@@ -0,0 +1,14 @@
+import { type ConsentIo, type Env } from "@atcn/usage";
+export interface CliOptions {
+    env?: Env;
+    io?: ConsentIo;
+    interactive?: boolean;
+    fetch?: typeof fetch;
+    log?: (line: string) => void;
+    error?: (line: string) => void;
+}
+/**
+ * `atcn init` records whether this machine shares anonymous usage metrics, by flag or by asking. On a yes it
+ * reports `integration_initialized`. Returns the process exit code: 0 saved, 2 usage error or no answer.
+ */
+export declare function runCli(argv: string[], options?: CliOptions): Promise<number>;

package/dist/init.js

@@ -0,0 +1,45 @@
+import { parseArgs } from "node:util";
+import { askToShareUsage, saveUsageChoice, sendUsageReport, settingsPath, usageStatus } from "@atcn/usage";
+import { SDK_VERSION } from "./client.js";
+const USAGE = "usage: atcn init [--share-usage yes|no]";
+/**
+ * `atcn init` records whether this machine shares anonymous usage metrics, by flag or by asking. On a yes it
+ * reports `integration_initialized`. Returns the process exit code: 0 saved, 2 usage error or no answer.
+ */
+export async function runCli(argv, options = {}) {
+    const env = options.env ?? process.env;
+    const log = options.log ?? console.log;
+    const error = options.error ?? console.error;
+    let parsed;
+    try {
+        parsed = parseArgs({ args: argv, options: { "share-usage": { type: "string" } }, allowPositionals: true });
+    }
+    catch {
+        error(USAGE);
+        return 2;
+    }
+    const flag = parsed.values["share-usage"];
+    if (parsed.positionals.length !== 1 || parsed.positionals[0] !== "init" || (flag !== undefined && flag !== "yes" && flag !== "no")) {
+        error(USAGE);
+        return 2;
+    }
+    let shared;
+    if (flag !== undefined)
+        shared = saveUsageChoice(flag === "yes", env).share_usage;
+    else if (options.interactive ?? process.stdin.isTTY === true)
+        shared = await askToShareUsage(options.io, env);
+    else {
+        error("Not an interactive terminal: pass --share-usage yes or --share-usage no.");
+        return 2;
+    }
+    if (shared === null) {
+        error("No answer given; nothing saved.");
+        return 2;
+    }
+    if (shared) {
+        await sendUsageReport({ event: "integration_initialized", sdk_version: `typescript/${SDK_VERSION}`, workflow: "custom", delegations: null, charges: null }, { env, fetch: options.fetch });
+    }
+    log(`Saved your choice to ${settingsPath(env)}.`);
+    log(`Usage metrics: ${usageStatus(env).reason}.`);
+    return 0;
+}

package/dist/signer.d.ts

@@ -0,0 +1,16 @@
+import { type EventPayload, type EventType, type Signed } from "@atcn/schema";
+export interface SignerIdentity {
+    actorId: string;
+    platformId: string;
+    keyId: string;
+    keyVersion?: number;
+    privateKey: string;
+}
+/** Signs ATCN events for one actor. Keys stay with the caller; ATCN only ever sees public keys. */
+export declare class EventSigner {
+    readonly identity: SignerIdentity;
+    constructor(identity: SignerIdentity);
+    get actorId(): string;
+    get platformId(): string;
+    sign(eventType: EventType, obligationId: string, data?: Record<string, unknown>, causationIds?: string[]): Signed<EventPayload>;
+}