ton-mesh-harness 0.13.0

package/dist/sdk/schemas.d.ts

@@ -0,0 +1,885 @@
+/**
+ * Single zod source of truth for ton-mesh-harness-mcp inputs / outputs / events.
+ *
+ * Generated JSON Schemas drive both:
+ *   - the MCP server tools/list response (`@modelcontextprotocol/sdk`)
+ *   - the SDK's TypeScript types (`z.infer<typeof DeployOptionsSchema>`)
+ *
+ * Spec: docs/v0.8/mcp-core-requirements.md §F2 / §F3 / §F5 / §NF6
+ * Verdict context: docs/archive/v0.8/at-mcp-probe.md (P-1 probe, dual-path WalletSpec)
+ *
+ * NO `console.*` ANYWHERE IN THIS FILE OR src/sdk/* — lint-enforced (planned [S4]).
+ */
+import { z } from 'zod';
+export declare const WalletSpecSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"tonconnect">;
+    /** Substring match against TonConnect manifest names. Default: "Tonkeeper". */
+    connector: z.ZodDefault<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    kind: "tonconnect";
+    connector: string;
+}, {
+    kind: "tonconnect";
+    connector?: string | undefined;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"agentic">;
+    /**
+     * Override path to the agentic-wallet config file.
+     * Default: `$TON_CONFIG_PATH` if set, else `~/.config/ton/config.json`.
+     * The kit reads this file directly with its own loader (the original
+     * P-1 memo's "via @ton/walletkit's loader" claim was wrong — the kit
+     * defines the schema; @ton/walletkit's `Signer` is then used to sign).
+     */
+    config_path: z.ZodOptional<z.ZodString>;
+    /**
+     * Selects from agentic wallet list when multiple are configured.
+     * Default: the active wallet, which is the convention `@ton/mcp`
+     * writes via `set_active_wallet`. Verify exact field at week-5
+     * implementation start by inspecting an actual config.json.
+     */
+    wallet_label: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    kind: "agentic";
+    config_path?: string | undefined;
+    wallet_label?: string | undefined;
+}, {
+    kind: "agentic";
+    config_path?: string | undefined;
+    wallet_label?: string | undefined;
+}>]>;
+export type WalletSpec = z.infer<typeof WalletSpecSchema>;
+/**
+ * Backwards-compat helper: legacy callers (CLI today) pass a bare string
+ * meaning "TonConnect connector substring". Lift it into a `WalletSpec`.
+ *
+ * Used at the SDK boundary in [S2] / runDeploy() so the MCP JSON schema
+ * stays clean (no `string | WalletSpec` union exposed via the contract).
+ */
+export declare function parseWalletInput(input: string | WalletSpec | undefined): WalletSpec;
+export declare const DeployOptionsSchema: z.ZodObject<{
+    /** Absolute or relative path to the build directory. */
+    source_dir: z.ZodString;
+    /** Optional `.ton` domain to write storage / site DNS records for. */
+    domain: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    /** Bag description; defaults to source_dir basename if null. */
+    description: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    /**
+     * Wallet selection (Path 1 = TonConnect human-signed / Path 2 = agentic autonomous).
+     * MCP callers MUST pass the structured object; legacy CLI callers pass a
+     * bare string and are lifted via `parseWalletInput()` in the SDK boundary.
+     */
+    wallet: z.ZodDefault<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"tonconnect">;
+        /** Substring match against TonConnect manifest names. Default: "Tonkeeper". */
+        connector: z.ZodDefault<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        kind: "tonconnect";
+        connector: string;
+    }, {
+        kind: "tonconnect";
+        connector?: string | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"agentic">;
+        /**
+         * Override path to the agentic-wallet config file.
+         * Default: `$TON_CONFIG_PATH` if set, else `~/.config/ton/config.json`.
+         * The kit reads this file directly with its own loader (the original
+         * P-1 memo's "via @ton/walletkit's loader" claim was wrong — the kit
+         * defines the schema; @ton/walletkit's `Signer` is then used to sign).
+         */
+        config_path: z.ZodOptional<z.ZodString>;
+        /**
+         * Selects from agentic wallet list when multiple are configured.
+         * Default: the active wallet, which is the convention `@ton/mcp`
+         * writes via `set_active_wallet`. Verify exact field at week-5
+         * implementation start by inspecting an actual config.json.
+         */
+        wallet_label: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        kind: "agentic";
+        config_path?: string | undefined;
+        wallet_label?: string | undefined;
+    }, {
+        kind: "agentic";
+        config_path?: string | undefined;
+        wallet_label?: string | undefined;
+    }>]>>;
+    /**
+     * Use TON testnet instead of mainnet. Supported on the tonutils backend
+     * since v0.9: the daemon is started with the testnet `--network-config`
+     * and the DNS write uses testnet endpoints. Requires testnet TON in the
+     * signing wallet and a testnet `.ton` domain. Bag propagation depends on
+     * testnet ADNL/storage liveness (self-host via the deployer's own daemon).
+     */
+    testnet: z.ZodDefault<z.ZodBoolean>;
+    /** Path to ADNL Tunnel client config (nodes-pool.json). */
+    tunnel_config: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    /**
+     * Cloud-seeder announce knobs (#69). For running the kit AS a
+     * publicly-reachable seeder on a VM: `announce_ip` is the public IPv4 to
+     * advertise to the DHT (tonutils config `ExternalIP`); `announce_port` pins
+     * the UDP `ListenAddr` port so a firewall rule can be pre-opened. Both
+     * override the `MESH_ANNOUNCE_IP` / `MESH_ANNOUNCE_PORT` env vars.
+     * IPv4 only — the daemon binds 0.0.0.0 (IPv4); an IPv6 announce would
+     * advertise an address it can't serve.
+     */
+    announce_ip: z.ZodDefault<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+    announce_port: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    /**
+     * If true, the daemon survives the call; the MCP server tracks the spawned
+     * daemon and kills it on its own shutdown. If false, the daemon is killed
+     * before the call returns (one-shot semantics).
+     */
+    keep_alive: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Daemon ownership (#37):
+     *   - `embedded` (default): daemon killed before the call returns.
+     *   - `detached`: daemon survives; the CALLER owns its lifecycle (the
+     *     legacy `keep_alive: true` behaviour — a bare `keep_alive: true`
+     *     with the default mode is normalized to `detached`). Rejected by
+     *     the MCP server (it can't own a long-lived daemon).
+     *   - `service`: hand the daemon to the OS service manager (launchd /
+     *     systemd --user) seeding a persistent db under
+     *     ~/.ton-mesh/seeds/<bag_id>/. The CLI/MCP return cleanly; manage
+     *     via `ton-mesh-harness service list|stop`. Not on Windows yet.
+     */
+    daemon_mode: z.ZodDefault<z.ZodEnum<["embedded", "detached", "service"]>>;
+    /**
+     * Emit a provenance manifest into `<source_dir>/.well-known/ton-deploy.json`
+     * before bag creation (so the bag includes it). On the agentic path it is
+     * signed with the operator/standard key; on TonConnect it is unsigned
+     * (the wallet can't sign arbitrary bytes). Only emitted when `domain` is
+     * set. Best-effort: any failure is logged and skipped, never fatal.
+     * Pass false to opt out (CLI `--no-provenance`).
+     */
+    provenance: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    source_dir: string;
+    domain: string | null;
+    description: string | null;
+    wallet: {
+        kind: "tonconnect";
+        connector: string;
+    } | {
+        kind: "agentic";
+        config_path?: string | undefined;
+        wallet_label?: string | undefined;
+    };
+    testnet: boolean;
+    tunnel_config: string | null;
+    announce_ip: string | null;
+    announce_port: number | null;
+    keep_alive: boolean;
+    daemon_mode: "embedded" | "detached" | "service";
+    provenance: boolean;
+}, {
+    source_dir: string;
+    domain?: string | null | undefined;
+    description?: string | null | undefined;
+    wallet?: {
+        kind: "tonconnect";
+        connector?: string | undefined;
+    } | {
+        kind: "agentic";
+        config_path?: string | undefined;
+        wallet_label?: string | undefined;
+    } | undefined;
+    testnet?: boolean | undefined;
+    tunnel_config?: string | null | undefined;
+    announce_ip?: string | null | undefined;
+    announce_port?: number | null | undefined;
+    keep_alive?: boolean | undefined;
+    daemon_mode?: "embedded" | "detached" | "service" | undefined;
+    provenance?: boolean | undefined;
+}>;
+export type DeployOptions = z.infer<typeof DeployOptionsSchema>;
+export declare const NextActionSchema: z.ZodObject<{
+    description: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    description: string;
+}, {
+    description: string;
+}>;
+export declare const DeployResultSchema: z.ZodObject<{
+    bag_id: z.ZodString;
+    bag_size_bytes: z.ZodNumber;
+    /**
+     * Real on-chain tx hash of the `change_dns_record` write. Null when
+     * `domain` was null on input (no DNS write), AND — best-effort — when
+     * Toncenter's tx index lagged the TONAPI DNS poll past the grace window
+     * (#117): a null hash on an otherwise-successful deploy still means the
+     * write landed (verify via TONAPI `resolve` storage==bag_id). The
+     * submitted-tx pointer is surfaced in `next_actions` in that case.
+     */
+    dns_tx_hash: z.ZodNullable<z.ZodString>;
+    /**
+     * The tonutils-storage daemon's local HTTP API base (e.g.
+     * `http://127.0.0.1:7100`). Renamed from `dashboard_url` in [S3] review
+     * — the daemon does not serve a dashboard HTML page; it exposes a JSON
+     * API. The kit's actual dashboard is a separate static file the CLI
+     * may open in a browser. `null` when `seed_status: "stopped"` (embedded
+     * mode kills the daemon before `done`), since the URL would point at a
+     * dead endpoint — mirrors `daemon_pid`. (#134)
+     */
+    daemon_api_url: z.ZodNullable<z.ZodString>;
+    /** Non-null only for `daemon_mode: "detached"` (the caller owns the pid). */
+    daemon_pid: z.ZodNullable<z.ZodNumber>;
+    seed_status: z.ZodEnum<["seeding", "stopped"]>;
+    /**
+     * OS service label when `daemon_mode: "service"` handed the daemon to
+     * launchd / systemd (e.g. `ton-mesh.<bag_id>`); null otherwise.
+     * Manage via `ton-mesh-harness service list | stop`.
+     */
+    daemon_service: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    next_actions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        description: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        description: string;
+    }, {
+        description: string;
+    }>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    bag_id: string;
+    bag_size_bytes: number;
+    dns_tx_hash: string | null;
+    daemon_api_url: string | null;
+    daemon_pid: number | null;
+    seed_status: "seeding" | "stopped";
+    daemon_service: string | null;
+    next_actions: {
+        description: string;
+    }[];
+}, {
+    bag_id: string;
+    bag_size_bytes: number;
+    dns_tx_hash: string | null;
+    daemon_api_url: string | null;
+    daemon_pid: number | null;
+    seed_status: "seeding" | "stopped";
+    daemon_service?: string | null | undefined;
+    next_actions?: {
+        description: string;
+    }[] | undefined;
+}>;
+export type DeployResult = z.infer<typeof DeployResultSchema>;
+export declare const CheckEnvOptionsSchema: z.ZodObject<{
+    source_dir: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, "strict", z.ZodTypeAny, {
+    source_dir: string | null;
+}, {
+    source_dir?: string | null | undefined;
+}>;
+export type CheckEnvOptions = z.infer<typeof CheckEnvOptionsSchema>;
+export declare const CheckEnvResultSchema: z.ZodEffects<z.ZodObject<{
+    ready: z.ZodBoolean;
+    node_version: z.ZodString;
+    disk_free_mb: z.ZodNumber;
+    udp_port_17555_free: z.ZodBoolean;
+    /**
+     * `"tonconnect"` if the kit's TonConnect connector code is reachable
+     * (no session check). `"agentic"` if `~/.config/ton/config.json`
+     * (or `$TON_CONFIG_PATH`) exists AND has at least one wallet entry the
+     * SDK's loader can read. Possible values: `[]`, `["tonconnect"]`,
+     * `["agentic"]`, `["tonconnect","agentic"]`. Each value appears at most once.
+     */
+    wallet_signers_available: z.ZodEffects<z.ZodArray<z.ZodEnum<["tonconnect", "agentic"]>, "many">, ("tonconnect" | "agentic")[], ("tonconnect" | "agentic")[]>;
+    daemon_backend_installed: z.ZodObject<{
+        tonutils: z.ZodBoolean;
+        ton_core: z.ZodBoolean;
+    }, "strict", z.ZodTypeAny, {
+        tonutils: boolean;
+        ton_core: boolean;
+    }, {
+        tonutils: boolean;
+        ton_core: boolean;
+    }>;
+    network_reachable: z.ZodBoolean;
+    /** Null when `source_dir` was null on input. */
+    source_dir_valid: z.ZodNullable<z.ZodBoolean>;
+    blocking: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        fix_hint: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        code: string;
+        message: string;
+        fix_hint: string;
+    }, {
+        code: string;
+        message: string;
+        fix_hint: string;
+    }>, "many">;
+    warnings: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        code: string;
+        message: string;
+    }, {
+        code: string;
+        message: string;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    ready: boolean;
+    node_version: string;
+    disk_free_mb: number;
+    udp_port_17555_free: boolean;
+    wallet_signers_available: ("tonconnect" | "agentic")[];
+    daemon_backend_installed: {
+        tonutils: boolean;
+        ton_core: boolean;
+    };
+    network_reachable: boolean;
+    source_dir_valid: boolean | null;
+    blocking: {
+        code: string;
+        message: string;
+        fix_hint: string;
+    }[];
+    warnings: {
+        code: string;
+        message: string;
+    }[];
+}, {
+    ready: boolean;
+    node_version: string;
+    disk_free_mb: number;
+    udp_port_17555_free: boolean;
+    wallet_signers_available: ("tonconnect" | "agentic")[];
+    daemon_backend_installed: {
+        tonutils: boolean;
+        ton_core: boolean;
+    };
+    network_reachable: boolean;
+    source_dir_valid: boolean | null;
+    blocking: {
+        code: string;
+        message: string;
+        fix_hint: string;
+    }[];
+    warnings: {
+        code: string;
+        message: string;
+    }[];
+}>, {
+    ready: boolean;
+    node_version: string;
+    disk_free_mb: number;
+    udp_port_17555_free: boolean;
+    wallet_signers_available: ("tonconnect" | "agentic")[];
+    daemon_backend_installed: {
+        tonutils: boolean;
+        ton_core: boolean;
+    };
+    network_reachable: boolean;
+    source_dir_valid: boolean | null;
+    blocking: {
+        code: string;
+        message: string;
+        fix_hint: string;
+    }[];
+    warnings: {
+        code: string;
+        message: string;
+    }[];
+}, {
+    ready: boolean;
+    node_version: string;
+    disk_free_mb: number;
+    udp_port_17555_free: boolean;
+    wallet_signers_available: ("tonconnect" | "agentic")[];
+    daemon_backend_installed: {
+        tonutils: boolean;
+        ton_core: boolean;
+    };
+    network_reachable: boolean;
+    source_dir_valid: boolean | null;
+    blocking: {
+        code: string;
+        message: string;
+        fix_hint: string;
+    }[];
+    warnings: {
+        code: string;
+        message: string;
+    }[];
+}>;
+export type CheckEnvResult = z.infer<typeof CheckEnvResultSchema>;
+export declare const StatusOptionsSchema: z.ZodObject<{
+    bag_id: z.ZodString;
+    /** Optional `.ton` domain to also check (resolves NFT + reads storage record). */
+    domain: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    testnet: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    domain: string | null;
+    testnet: boolean;
+    bag_id: string;
+}, {
+    bag_id: string;
+    domain?: string | null | undefined;
+    testnet?: boolean | undefined;
+}>;
+export type StatusOptions = z.infer<typeof StatusOptionsSchema>;
+export declare const StatusResultSchema: z.ZodObject<{
+    bag_id: z.ZodString;
+    /** TONAPI reports the bag is visible / not "not_found". */
+    bag_accessible: z.ZodBoolean;
+    /** Bag size in bytes if TONAPI returned it; null when accessible=false. */
+    bag_size_bytes: z.ZodNullable<z.ZodNumber>;
+    /** File count if TONAPI returned it; null when accessible=false. */
+    bag_file_count: z.ZodNullable<z.ZodNumber>;
+    /**
+     * When `bag_accessible: false`, why. `not_found` = TONAPI returned
+     * status=not_found (genuine "not propagated"). `network_error` =
+     * TONAPI was unreachable or returned 5xx for both attempts. Lets
+     * callers distinguish "the bag isn't on the network yet" from
+     * "TONAPI itself is down / endpoint drifted." `null` when accessible.
+     */
+    bag_unavailable_reason: z.ZodNullable<z.ZodEnum<["not_found", "network_error"]>>;
+    /** Present iff `domain` was passed. */
+    domain: z.ZodNullable<z.ZodObject<{
+        name: z.ZodString;
+        nft_address: z.ZodNullable<z.ZodString>;
+        /** Bag id currently pointed to by the `storage` DNS record (lowercase hex). */
+        resolved_bag_id: z.ZodNullable<z.ZodString>;
+        /** `resolved_bag_id === bag_id` (lowercased compare). */
+        matches: z.ZodBoolean;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        nft_address: string | null;
+        resolved_bag_id: string | null;
+        matches: boolean;
+    }, {
+        name: string;
+        nft_address: string | null;
+        resolved_bag_id: string | null;
+        matches: boolean;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    domain: {
+        name: string;
+        nft_address: string | null;
+        resolved_bag_id: string | null;
+        matches: boolean;
+    } | null;
+    bag_id: string;
+    bag_size_bytes: number | null;
+    bag_accessible: boolean;
+    bag_file_count: number | null;
+    bag_unavailable_reason: "not_found" | "network_error" | null;
+}, {
+    domain: {
+        name: string;
+        nft_address: string | null;
+        resolved_bag_id: string | null;
+        matches: boolean;
+    } | null;
+    bag_id: string;
+    bag_size_bytes: number | null;
+    bag_accessible: boolean;
+    bag_file_count: number | null;
+    bag_unavailable_reason: "not_found" | "network_error" | null;
+}>;
+export type StatusResult = z.infer<typeof StatusResultSchema>;
+export declare const SiteRecordOptionsSchema: z.ZodObject<{
+    /** `.ton` domain whose NFT will receive the site record. */
+    domain: z.ZodString;
+    /**
+     * 64-hex ADNL identity (256-bit) of the rldp-http-proxy. Accepts an
+     * optional `0x` prefix; canonicalized to lowercase, no prefix.
+     */
+    site_adnl: z.ZodEffects<z.ZodString, string, string>;
+    testnet: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    domain: string;
+    testnet: boolean;
+    site_adnl: string;
+}, {
+    domain: string;
+    site_adnl: string;
+    testnet?: boolean | undefined;
+}>;
+export type SiteRecordOptions = z.infer<typeof SiteRecordOptionsSchema>;
+export declare const SiteRecordResultSchema: z.ZodObject<{
+    /** Normalized `<name>.ton`. */
+    domain: z.ZodString;
+    /** The domain NFT item address the transaction targets. */
+    nft_address: z.ZodString;
+    /** Always `site` — this tool never touches the storage record. */
+    record: z.ZodLiteral<"site">;
+    /** Canonical (lowercase, no prefix) ADNL hex written into the record. */
+    site_adnl: z.ZodString;
+    /** Gas attached to the message, in nanoTON (string — bigint isn't JSON-safe). */
+    amount_nano: z.ZodString;
+    /** The `change_dns_record` message body, BOC-serialized + base64url. */
+    body_boc_base64url: z.ZodString;
+    /** Tonkeeper transfer deeplink that signs the site record in one tap. */
+    tonkeeper_deeplink: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    domain: string;
+    nft_address: string;
+    site_adnl: string;
+    record: "site";
+    amount_nano: string;
+    body_boc_base64url: string;
+    tonkeeper_deeplink: string;
+}, {
+    domain: string;
+    nft_address: string;
+    site_adnl: string;
+    record: "site";
+    amount_nano: string;
+    body_boc_base64url: string;
+    tonkeeper_deeplink: string;
+}>;
+export type SiteRecordResult = z.infer<typeof SiteRecordResultSchema>;
+declare const PhaseSchema: z.ZodEnum<["env_check", "bag_creating", "daemon_starting", "bag_uploaded", "awaiting_signature", "dns_signing", "dns_confirmed", "verifying", "done"]>;
+export type DeployPhase = z.infer<typeof PhaseSchema>;
+/**
+ * Discriminated union on `phase`. Specialised data shapes for
+ * `awaiting_signature` (signing mode handoff) and `done` (DeployResult);
+ * all intermediate phases carry a free-form `data` record (file-level
+ * granularity, daemon ports, etc.).
+ *
+ * Using a discriminated union (rather than `z.union`) is load-bearing:
+ * a `z.union` with a free-form fallback variant would silently accept
+ * malformed `awaiting_signature` events.
+ */
+export declare const DeployEventSchema: z.ZodDiscriminatedUnion<"phase", [z.ZodObject<{
+    data: z.ZodDiscriminatedUnion<"signing_mode", [z.ZodObject<{
+        signing_mode: z.ZodLiteral<"tonconnect">;
+        signing_url: z.ZodString;
+        expires_at_iso: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        signing_mode: "tonconnect";
+        signing_url: string;
+        expires_at_iso: string;
+    }, {
+        signing_mode: "tonconnect";
+        signing_url: string;
+        expires_at_iso: string;
+    }>, z.ZodObject<{
+        signing_mode: z.ZodLiteral<"agentic">;
+        signing_url: z.ZodNull;
+        /**
+         * Wallet label that will sign autonomously, for the agent's logs.
+         * Optional — if the active wallet has no explicit label, this is null.
+         */
+        wallet_label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, "strict", z.ZodTypeAny, {
+        wallet_label: string | null;
+        signing_mode: "agentic";
+        signing_url: null;
+    }, {
+        signing_mode: "agentic";
+        signing_url: null;
+        wallet_label?: string | null | undefined;
+    }>]>;
+    message: z.ZodString;
+    percent: z.ZodOptional<z.ZodNumber>;
+    phase: z.ZodLiteral<"awaiting_signature">;
+}, "strict", z.ZodTypeAny, {
+    message: string;
+    phase: "awaiting_signature";
+    data: {
+        signing_mode: "tonconnect";
+        signing_url: string;
+        expires_at_iso: string;
+    } | {
+        wallet_label: string | null;
+        signing_mode: "agentic";
+        signing_url: null;
+    };
+    percent?: number | undefined;
+}, {
+    message: string;
+    phase: "awaiting_signature";
+    data: {
+        signing_mode: "tonconnect";
+        signing_url: string;
+        expires_at_iso: string;
+    } | {
+        signing_mode: "agentic";
+        signing_url: null;
+        wallet_label?: string | null | undefined;
+    };
+    percent?: number | undefined;
+}>, z.ZodObject<{
+    data: z.ZodObject<{
+        bag_id: z.ZodString;
+        bag_size_bytes: z.ZodNumber;
+        /**
+         * Real on-chain tx hash of the `change_dns_record` write. Null when
+         * `domain` was null on input (no DNS write), AND — best-effort — when
+         * Toncenter's tx index lagged the TONAPI DNS poll past the grace window
+         * (#117): a null hash on an otherwise-successful deploy still means the
+         * write landed (verify via TONAPI `resolve` storage==bag_id). The
+         * submitted-tx pointer is surfaced in `next_actions` in that case.
+         */
+        dns_tx_hash: z.ZodNullable<z.ZodString>;
+        /**
+         * The tonutils-storage daemon's local HTTP API base (e.g.
+         * `http://127.0.0.1:7100`). Renamed from `dashboard_url` in [S3] review
+         * — the daemon does not serve a dashboard HTML page; it exposes a JSON
+         * API. The kit's actual dashboard is a separate static file the CLI
+         * may open in a browser. `null` when `seed_status: "stopped"` (embedded
+         * mode kills the daemon before `done`), since the URL would point at a
+         * dead endpoint — mirrors `daemon_pid`. (#134)
+         */
+        daemon_api_url: z.ZodNullable<z.ZodString>;
+        /** Non-null only for `daemon_mode: "detached"` (the caller owns the pid). */
+        daemon_pid: z.ZodNullable<z.ZodNumber>;
+        seed_status: z.ZodEnum<["seeding", "stopped"]>;
+        /**
+         * OS service label when `daemon_mode: "service"` handed the daemon to
+         * launchd / systemd (e.g. `ton-mesh.<bag_id>`); null otherwise.
+         * Manage via `ton-mesh-harness service list | stop`.
+         */
+        daemon_service: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        next_actions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            description: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            description: string;
+        }, {
+            description: string;
+        }>, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        bag_id: string;
+        bag_size_bytes: number;
+        dns_tx_hash: string | null;
+        daemon_api_url: string | null;
+        daemon_pid: number | null;
+        seed_status: "seeding" | "stopped";
+        daemon_service: string | null;
+        next_actions: {
+            description: string;
+        }[];
+    }, {
+        bag_id: string;
+        bag_size_bytes: number;
+        dns_tx_hash: string | null;
+        daemon_api_url: string | null;
+        daemon_pid: number | null;
+        seed_status: "seeding" | "stopped";
+        daemon_service?: string | null | undefined;
+        next_actions?: {
+            description: string;
+        }[] | undefined;
+    }>;
+    message: z.ZodString;
+    percent: z.ZodOptional<z.ZodNumber>;
+    phase: z.ZodLiteral<"done">;
+}, "strict", z.ZodTypeAny, {
+    message: string;
+    phase: "done";
+    data: {
+        bag_id: string;
+        bag_size_bytes: number;
+        dns_tx_hash: string | null;
+        daemon_api_url: string | null;
+        daemon_pid: number | null;
+        seed_status: "seeding" | "stopped";
+        daemon_service: string | null;
+        next_actions: {
+            description: string;
+        }[];
+    };
+    percent?: number | undefined;
+}, {
+    message: string;
+    phase: "done";
+    data: {
+        bag_id: string;
+        bag_size_bytes: number;
+        dns_tx_hash: string | null;
+        daemon_api_url: string | null;
+        daemon_pid: number | null;
+        seed_status: "seeding" | "stopped";
+        daemon_service?: string | null | undefined;
+        next_actions?: {
+            description: string;
+        }[] | undefined;
+    };
+    percent?: number | undefined;
+}>, z.ZodObject<{
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    message: z.ZodString;
+    percent: z.ZodOptional<z.ZodNumber>;
+    phase: z.ZodLiteral<"env_check">;
+}, "strict", z.ZodTypeAny, {
+    message: string;
+    phase: "env_check";
+    data?: Record<string, unknown> | undefined;
+    percent?: number | undefined;
+}, {
+    message: string;
+    phase: "env_check";
+    data?: Record<string, unknown> | undefined;
+    percent?: number | undefined;
+}>, z.ZodObject<{
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    message: z.ZodString;
+    percent: z.ZodOptional<z.ZodNumber>;
+    phase: z.ZodLiteral<"bag_creating">;
+}, "strict", z.ZodTypeAny, {
+    message: string;
+    phase: "bag_creating";
+    data?: Record<string, unknown> | undefined;
+    percent?: number | undefined;
+}, {
+    message: string;
+    phase: "bag_creating";
+    data?: Record<string, unknown> | undefined;
+    percent?: number | undefined;
+}>, z.ZodObject<{
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    message: z.ZodString;
+    percent: z.ZodOptional<z.ZodNumber>;
+    phase: z.ZodLiteral<"daemon_starting">;
+}, "strict", z.ZodTypeAny, {
+    message: string;
+    phase: "daemon_starting";
+    data?: Record<string, unknown> | undefined;
+    percent?: number | undefined;
+}, {
+    message: string;
+    phase: "daemon_starting";
+    data?: Record<string, unknown> | undefined;
+    percent?: number | undefined;
+}>, z.ZodObject<{
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    message: z.ZodString;
+    percent: z.ZodOptional<z.ZodNumber>;
+    phase: z.ZodLiteral<"bag_uploaded">;
+}, "strict", z.ZodTypeAny, {
+    message: string;
+    phase: "bag_uploaded";
+    data?: Record<string, unknown> | undefined;
+    percent?: number | undefined;
+}, {
+    message: string;
+    phase: "bag_uploaded";
+    data?: Record<string, unknown> | undefined;
+    percent?: number | undefined;
+}>, z.ZodObject<{
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    message: z.ZodString;
+    percent: z.ZodOptional<z.ZodNumber>;
+    phase: z.ZodLiteral<"dns_signing">;
+}, "strict", z.ZodTypeAny, {
+    message: string;
+    phase: "dns_signing";
+    data?: Record<string, unknown> | undefined;
+    percent?: number | undefined;
+}, {
+    message: string;
+    phase: "dns_signing";
+    data?: Record<string, unknown> | undefined;
+    percent?: number | undefined;
+}>, z.ZodObject<{
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    message: z.ZodString;
+    percent: z.ZodOptional<z.ZodNumber>;
+    phase: z.ZodLiteral<"dns_confirmed">;
+}, "strict", z.ZodTypeAny, {
+    message: string;
+    phase: "dns_confirmed";
+    data?: Record<string, unknown> | undefined;
+    percent?: number | undefined;
+}, {
+    message: string;
+    phase: "dns_confirmed";
+    data?: Record<string, unknown> | undefined;
+    percent?: number | undefined;
+}>, z.ZodObject<{
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    message: z.ZodString;
+    percent: z.ZodOptional<z.ZodNumber>;
+    phase: z.ZodLiteral<"verifying">;
+}, "strict", z.ZodTypeAny, {
+    message: string;
+    phase: "verifying";
+    data?: Record<string, unknown> | undefined;
+    percent?: number | undefined;
+}, {
+    message: string;
+    phase: "verifying";
+    data?: Record<string, unknown> | undefined;
+    percent?: number | undefined;
+}>]>;
+export type DeployEvent = z.infer<typeof DeployEventSchema>;
+/**
+ * All stable error codes per F5. Adding new codes is non-breaking; renaming
+ * or removing is breaking and requires a kit minor bump + tool description note.
+ */
+export declare const ERR_CODES: readonly ["ERR_INVALID_INPUT", "ERR_NO_DOMAIN", "ERR_NO_WALLET", "ERR_PORT_BUSY", "ERR_DAEMON_SPAWN", "ERR_DAEMON_API_TIMEOUT", "ERR_BAG_UPLOAD", "ERR_DNS_SIGN_REJECTED", "ERR_DNS_TX_TIMEOUT", "ERR_VERIFY_FAILED", "ERR_CANCELLED", "ERR_BUSY", "ERR_INTERNAL"];
+export declare const ErrCodeSchema: z.ZodEnum<["ERR_INVALID_INPUT", "ERR_NO_DOMAIN", "ERR_NO_WALLET", "ERR_PORT_BUSY", "ERR_DAEMON_SPAWN", "ERR_DAEMON_API_TIMEOUT", "ERR_BAG_UPLOAD", "ERR_DNS_SIGN_REJECTED", "ERR_DNS_TX_TIMEOUT", "ERR_VERIFY_FAILED", "ERR_CANCELLED", "ERR_BUSY", "ERR_INTERNAL"]>;
+export type ErrCode = z.infer<typeof ErrCodeSchema>;
+/**
+ * Code-aware discriminated union. ERR_CANCELLED carries strict F4 data;
+ * other codes carry a free-form data record (or none).
+ */
+export declare const ErrorPayloadSchema: z.ZodDiscriminatedUnion<"code", [z.ZodObject<{
+    code: z.ZodLiteral<"ERR_CANCELLED">;
+    message: z.ZodString;
+    severity: z.ZodEnum<["fatal", "recoverable"]>;
+    fix_hint: z.ZodOptional<z.ZodString>;
+    data: z.ZodObject<{
+        phase_at_cancel: z.ZodEnum<["env_check", "bag_creating", "daemon_starting", "bag_uploaded", "awaiting_signature", "dns_signing", "dns_confirmed", "verifying", "done"]>;
+        may_have_published: z.ZodBoolean;
+        bag_id: z.ZodNullable<z.ZodString>;
+        tx_hash: z.ZodNullable<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        bag_id: string | null;
+        phase_at_cancel: "env_check" | "bag_creating" | "daemon_starting" | "bag_uploaded" | "awaiting_signature" | "dns_signing" | "dns_confirmed" | "verifying" | "done";
+        may_have_published: boolean;
+        tx_hash: string | null;
+    }, {
+        bag_id: string | null;
+        phase_at_cancel: "env_check" | "bag_creating" | "daemon_starting" | "bag_uploaded" | "awaiting_signature" | "dns_signing" | "dns_confirmed" | "verifying" | "done";
+        may_have_published: boolean;
+        tx_hash: string | null;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    code: "ERR_CANCELLED";
+    message: string;
+    data: {
+        bag_id: string | null;
+        phase_at_cancel: "env_check" | "bag_creating" | "daemon_starting" | "bag_uploaded" | "awaiting_signature" | "dns_signing" | "dns_confirmed" | "verifying" | "done";
+        may_have_published: boolean;
+        tx_hash: string | null;
+    };
+    severity: "fatal" | "recoverable";
+    fix_hint?: string | undefined;
+}, {
+    code: "ERR_CANCELLED";
+    message: string;
+    data: {
+        bag_id: string | null;
+        phase_at_cancel: "env_check" | "bag_creating" | "daemon_starting" | "bag_uploaded" | "awaiting_signature" | "dns_signing" | "dns_confirmed" | "verifying" | "done";
+        may_have_published: boolean;
+        tx_hash: string | null;
+    };
+    severity: "fatal" | "recoverable";
+    fix_hint?: string | undefined;
+}>, z.ZodObject<{
+    code: z.ZodEnum<["ERR_INVALID_INPUT" | "ERR_NO_DOMAIN" | "ERR_NO_WALLET" | "ERR_PORT_BUSY" | "ERR_DAEMON_SPAWN" | "ERR_DAEMON_API_TIMEOUT" | "ERR_BAG_UPLOAD" | "ERR_DNS_SIGN_REJECTED" | "ERR_DNS_TX_TIMEOUT" | "ERR_VERIFY_FAILED" | "ERR_BUSY" | "ERR_INTERNAL", ...("ERR_INVALID_INPUT" | "ERR_NO_DOMAIN" | "ERR_NO_WALLET" | "ERR_PORT_BUSY" | "ERR_DAEMON_SPAWN" | "ERR_DAEMON_API_TIMEOUT" | "ERR_BAG_UPLOAD" | "ERR_DNS_SIGN_REJECTED" | "ERR_DNS_TX_TIMEOUT" | "ERR_VERIFY_FAILED" | "ERR_BUSY" | "ERR_INTERNAL")[]]>;
+    message: z.ZodString;
+    severity: z.ZodEnum<["fatal", "recoverable"]>;
+    fix_hint: z.ZodOptional<z.ZodString>;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strict", z.ZodTypeAny, {
+    code: "ERR_INVALID_INPUT" | "ERR_NO_DOMAIN" | "ERR_NO_WALLET" | "ERR_PORT_BUSY" | "ERR_DAEMON_SPAWN" | "ERR_DAEMON_API_TIMEOUT" | "ERR_BAG_UPLOAD" | "ERR_DNS_SIGN_REJECTED" | "ERR_DNS_TX_TIMEOUT" | "ERR_VERIFY_FAILED" | "ERR_BUSY" | "ERR_INTERNAL";
+    message: string;
+    severity: "fatal" | "recoverable";
+    fix_hint?: string | undefined;
+    data?: Record<string, unknown> | undefined;
+}, {
+    code: "ERR_INVALID_INPUT" | "ERR_NO_DOMAIN" | "ERR_NO_WALLET" | "ERR_PORT_BUSY" | "ERR_DAEMON_SPAWN" | "ERR_DAEMON_API_TIMEOUT" | "ERR_BAG_UPLOAD" | "ERR_DNS_SIGN_REJECTED" | "ERR_DNS_TX_TIMEOUT" | "ERR_VERIFY_FAILED" | "ERR_BUSY" | "ERR_INTERNAL";
+    message: string;
+    severity: "fatal" | "recoverable";
+    fix_hint?: string | undefined;
+    data?: Record<string, unknown> | undefined;
+}>]>;
+export type ErrorPayload = z.infer<typeof ErrorPayloadSchema>;
+export {};