@manifest-network/manifest-agent-core 0.9.0

package/README.md

@@ -0,0 +1,39 @@
+# @manifest-network/manifest-agent-core
+
+TypeScript orchestration surface for Manifest agent flows. This package owns the deploy / manage-domain / troubleshoot / close-lease orchestration that host surfaces consume in lockstep — a bug fix in the core's recovery branch fixes every host surface simultaneously.
+
+> **Status.** All four orchestration functions have real implementations as of ENG-129 (PRs 1–4). The package remains `private: true` pending a publish decision; do not depend on it from external repos yet.
+
+See [ENG-127](https://linear.app/liftedinit/issue/ENG-127) for the broader initiative and [ENG-128](https://linear.app/liftedinit/issue/ENG-128) for the bootstrap PR.
+
+## Layering
+
+```
+manifest-mcp-mono       — protocol-level tools (RPC over MCP)
+manifest-agent-core     — orchestration, verification, recovery, plans, journal   (this package)
+host surface(s)         — chat / conversational / autonomous front-ends
+```
+
+The core sits above MCP; host surfaces sit above the core. Callbacks are where surfaces differ — a chat surface emits chat output and `AskUserQuestion`; a conversational surface updates its UI; an autonomous daemon auto-picks recovery branches per policy.
+
+## Public surface
+
+```ts
+import {
+  closeLease,
+  deployApp,
+  manageDomain,
+  troubleshootDeployment,
+} from '@manifest-network/manifest-agent-core';
+```
+
+Each function takes a typed args object plus a callbacks object with `onConfirm` / `onProgress` / `onComplete` / `onFailure` hooks. `deployApp` takes a `DeploySpec`; the other three take action-discriminated `*Args` types (e.g. `ManageDomainArgs` is `{ action: 'set' | 'clear' | 'lookup', ... }`). Only `deployApp` accepts `onPlan` and uses an enriched `onFailure` — `(failure: FailureEnvelope, options: RecoveryOption[]) => Promise<RecoveryChoice>` — to drive partial-success recovery: retry the set-domain step, salvage the lease without the custom domain, cancel a pending lease, or close an active one. See `RecoveryOptionId` in `src/types.ts` for the exact literal IDs (`retry_set_domain`, `salvage_without_domain`, `cancel_lease`, `close_lease`). The other three use the simpler `(failure: { reason: string }) => Promise<void>`. See `src/types.ts` for the frozen shapes.
+
+## Where each function lives
+
+| Function | Home |
+| --- | --- |
+| `deployApp` | `src/deploy-app.ts` |
+| `manageDomain` | `src/manage-domain.ts` |
+| `troubleshootDeployment` | `src/troubleshoot.ts` |
+| `closeLease` | `src/close-lease.ts` |

package/dist/close-lease.d.ts

@@ -0,0 +1,33 @@
+import { CloseLeaseArgs, CloseLeaseCallbacks, CloseLeaseOptions, CloseLeaseResult } from "./types.js";
+
+//#region src/close-lease.d.ts
+/**
+ * Close a lease and verify it reached a terminal on-chain state.
+ *
+ * @throws `ManifestMCPError(INVALID_CONFIG)` for args validation or when
+ *   `onConfirm` returns `'no'`.
+ * @throws `ManifestMCPError` (typically `TX_FAILED`) propagated as-is
+ *   from the `stopApp()` broadcast step. Broadcast errors do NOT invoke
+ *   `onFailure` — that callback is reserved for post-broadcast
+ *   verification failures. `stopApp` already raises a structured
+ *   `ManifestMCPError` from the core package; wrapping it again at this
+ *   layer would be redundant. Callers wanting to react to broadcast
+ *   errors should catch them at the call site.
+ * @throws `ManifestMCPError(TX_FAILED)` when post-broadcast verification
+ *   reaches one of two failure modes (both with `onFailure({ reason })`
+ *   invoked first):
+ *     - the lease is still non-terminal (`pending_drift` branch — state
+ *       decoded as PENDING / ACTIVE / similar non-terminal); or
+ *     - the chain returns `{ lease: null }` post-close, so the lease is
+ *       not visible on-chain (`unclassified` branch).
+ * @throws `ManifestMCPError(QUERY_FAILED)` when the post-broadcast verify
+ *   chain query (`billing.v1.lease`) raises a non-NotFound error
+ *   (RPC / transport / decoding failure). Wrapped inside the verifier
+ *   closure so the failure flows through `onFailure({ reason })` before
+ *   the throw. Structured `ManifestMCPError`s raised by the chain client
+ *   are re-thrown as-is (with `onFailure` invoked first).
+ */
+declare function closeLease(args: CloseLeaseArgs, callbacks: CloseLeaseCallbacks, opts: CloseLeaseOptions): Promise<CloseLeaseResult>;
+//#endregion
+export { closeLease };
+//# sourceMappingURL=close-lease.d.ts.map

package/dist/close-lease.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"close-lease.d.ts","names":[],"sources":["../src/close-lease.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+EsB,UAAA,CACpB,IAAA,EAAM,cAAA,EACN,SAAA,EAAW,mBAAA,EACX,IAAA,EAAM,iBAAA,GACL,OAAA,CAAQ,gBAAA"}

package/dist/close-lease.js

@@ -0,0 +1,138 @@
+import { decode, isTerminal } from "./internals/lease-state.js";
+import { verifyAndRecover } from "./internals/verify-recover.js";
+import { ManifestMCPError, ManifestMCPErrorCode, stopApp } from "@manifest-network/manifest-mcp-core";
+//#region src/close-lease.ts
+/**
+* Public entry point: orchestrate closing an existing lease via the
+* `close-lease` billing tx.
+*
+* Composition (mirrors `deploy-app.ts` / `manage-domain.ts`):
+*
+*   1. Validate args.
+*   2. Render a confirmation block + optionally consult `onConfirm`.
+*   3. Broadcast `stopApp` (which submits `MsgCloseLease`).
+*   4. Verify the post-broadcast on-chain state via `verifyAndRecover`
+*      driving a direct `billing.v1.lease({ leaseUuid })` query +
+*      `lease-state.decode` + `isTerminal`. Terminal states (CLOSED /
+*      REJECTED / EXPIRED / INSUFFICIENT_FUNDS) count as success;
+*      PENDING / ACTIVE map to the `pending_drift` branch; a chain
+*      response with no lease (`{ lease: null }`) maps to the catch-all
+*      `unclassified` branch.
+*   5. On verify-failure, invoke the simple-form `onFailure({ reason })`
+*      then throw `ManifestMCPError(TX_FAILED)`. On success, emit
+*      `onComplete` with the typed `CloseLeaseResult`.
+*/
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+* Close a lease and verify it reached a terminal on-chain state.
+*
+* @throws `ManifestMCPError(INVALID_CONFIG)` for args validation or when
+*   `onConfirm` returns `'no'`.
+* @throws `ManifestMCPError` (typically `TX_FAILED`) propagated as-is
+*   from the `stopApp()` broadcast step. Broadcast errors do NOT invoke
+*   `onFailure` — that callback is reserved for post-broadcast
+*   verification failures. `stopApp` already raises a structured
+*   `ManifestMCPError` from the core package; wrapping it again at this
+*   layer would be redundant. Callers wanting to react to broadcast
+*   errors should catch them at the call site.
+* @throws `ManifestMCPError(TX_FAILED)` when post-broadcast verification
+*   reaches one of two failure modes (both with `onFailure({ reason })`
+*   invoked first):
+*     - the lease is still non-terminal (`pending_drift` branch — state
+*       decoded as PENDING / ACTIVE / similar non-terminal); or
+*     - the chain returns `{ lease: null }` post-close, so the lease is
+*       not visible on-chain (`unclassified` branch).
+* @throws `ManifestMCPError(QUERY_FAILED)` when the post-broadcast verify
+*   chain query (`billing.v1.lease`) raises a non-NotFound error
+*   (RPC / transport / decoding failure). Wrapped inside the verifier
+*   closure so the failure flows through `onFailure({ reason })` before
+*   the throw. Structured `ManifestMCPError`s raised by the chain client
+*   are re-thrown as-is (with `onFailure` invoked first).
+*/
+async function closeLease(args, callbacks, opts) {
+	validateArgs(args);
+	const block = renderConfirmationBlock(args);
+	if (callbacks.onConfirm) {
+		if (await callbacks.onConfirm(block) !== "yes") throw new ManifestMCPError(ManifestMCPErrorCode.INVALID_CONFIG, "User declined to proceed with close-lease.");
+	}
+	callbacks.onProgress?.({ kind: "user_confirmed" });
+	await stopApp(opts.clientManager, args.leaseUuid);
+	const verifyResult = await verifyAndRecover({
+		verifier: async () => {
+			let result;
+			try {
+				result = await (await opts.clientManager.getQueryClient()).liftedinit.billing.v1.lease({ leaseUuid: args.leaseUuid });
+			} catch (err) {
+				const reason = `Failed to query lease ${args.leaseUuid} during close-verify: ${err instanceof Error ? err.message : String(err)}`;
+				if (callbacks.onFailure) await callbacks.onFailure({ reason });
+				if (err instanceof ManifestMCPError) throw err;
+				throw new ManifestMCPError(ManifestMCPErrorCode.QUERY_FAILED, reason);
+			}
+			const lease = result?.lease;
+			if (lease === null || lease === void 0) return {
+				outcome: "not_found",
+				diagnostic: { reason: `lease ${args.leaseUuid} not visible on chain after close` }
+			};
+			const rawState = lease.state;
+			const stateName = decode(typeof rawState === "number" || typeof rawState === "string" ? rawState : void 0);
+			if (stateName === void 0) return {
+				outcome: "pending",
+				diagnostic: { reason: `lease ${args.leaseUuid} state could not be decoded (raw=${String(rawState)})` }
+			};
+			return {
+				outcome: isTerminal(stateName) ? "terminal" : "pending",
+				diagnostic: { stateName }
+			};
+		},
+		successValues: ["terminal"],
+		branches: {
+			pending: {
+				branchId: "pending_drift",
+				journalActionTags: ["close-lease-verify-pending"],
+				buildFailureEnvelope: (d) => ({
+					outcome: "failed",
+					reason: d.reason ?? `close_lease tx accepted but state is still ${d.stateName ?? "unknown"}.`
+				}),
+				buildRecoveryOptions: () => []
+			},
+			not_found: {
+				branchId: "unclassified",
+				journalActionTags: ["close-lease-verify-not-found"],
+				buildFailureEnvelope: (d) => ({
+					outcome: "failed",
+					reason: d.reason ?? `Lease ${args.leaseUuid} not visible on chain after close.`
+				}),
+				buildRecoveryOptions: () => []
+			}
+		}
+	}, void 0);
+	if (verifyResult.result !== "success") {
+		const reason = verifyResult.failure?.reason ?? "close-lease verification failed.";
+		if (callbacks.onFailure) await callbacks.onFailure({ reason });
+		throw new ManifestMCPError(ManifestMCPErrorCode.TX_FAILED, reason);
+	}
+	if (!verifyResult.diagnostic.stateName) throw new ManifestMCPError(ManifestMCPErrorCode.TX_FAILED, `close-lease verifier invariant violated: success outcome reached without diagnostic.stateName for lease ${args.leaseUuid}`);
+	const finalState = verifyResult.diagnostic.stateName;
+	const result = {
+		leaseUuid: args.leaseUuid,
+		finalState
+	};
+	callbacks.onComplete?.(result);
+	return result;
+}
+function validateArgs(args) {
+	if (typeof args.leaseUuid !== "string" || !args.leaseUuid.match(UUID_RE)) throw new ManifestMCPError(ManifestMCPErrorCode.INVALID_CONFIG, `closeLease: leaseUuid must be a UUID; got "${args.leaseUuid}".`);
+}
+function renderConfirmationBlock(args) {
+	return { text: [
+		`Close lease ${args.leaseUuid}.`,
+		"  Image: (image not recorded)",
+		"  This is permanent — the lease cannot be reopened.",
+		"",
+		"Proceed?"
+	].join("\n") };
+}
+//#endregion
+export { closeLease };
+
+//# sourceMappingURL=close-lease.js.map

package/dist/close-lease.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"close-lease.js","names":["decodeLeaseState"],"sources":["../src/close-lease.ts"],"sourcesContent":["/**\n * Public entry point: orchestrate closing an existing lease via the\n * `close-lease` billing tx.\n *\n * Composition (mirrors `deploy-app.ts` / `manage-domain.ts`):\n *\n *   1. Validate args.\n *   2. Render a confirmation block + optionally consult `onConfirm`.\n *   3. Broadcast `stopApp` (which submits `MsgCloseLease`).\n *   4. Verify the post-broadcast on-chain state via `verifyAndRecover`\n *      driving a direct `billing.v1.lease({ leaseUuid })` query +\n *      `lease-state.decode` + `isTerminal`. Terminal states (CLOSED /\n *      REJECTED / EXPIRED / INSUFFICIENT_FUNDS) count as success;\n *      PENDING / ACTIVE map to the `pending_drift` branch; a chain\n *      response with no lease (`{ lease: null }`) maps to the catch-all\n *      `unclassified` branch.\n *   5. On verify-failure, invoke the simple-form `onFailure({ reason })`\n *      then throw `ManifestMCPError(TX_FAILED)`. On success, emit\n *      `onComplete` with the typed `CloseLeaseResult`.\n */\n\nimport {\n  ManifestMCPError,\n  ManifestMCPErrorCode,\n  stopApp,\n} from '@manifest-network/manifest-mcp-core';\nimport {\n  decode as decodeLeaseState,\n  isTerminal,\n} from './internals/lease-state.js';\nimport {\n  type VerificationSpec,\n  verifyAndRecover,\n} from './internals/verify-recover.js';\nimport type {\n  CloseLeaseArgs,\n  CloseLeaseCallbacks,\n  CloseLeaseOptions,\n  CloseLeaseResult,\n  DeploymentPlanBlock,\n  LeaseStateName,\n} from './types.js';\n\nconst UUID_RE =\n  /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;\n\ntype CloseOutcome = 'terminal' | 'pending' | 'not_found';\n\ninterface CloseDiag {\n  stateName?: LeaseStateName;\n  reason?: string;\n}\n\n/**\n * Close a lease and verify it reached a terminal on-chain state.\n *\n * @throws `ManifestMCPError(INVALID_CONFIG)` for args validation or when\n *   `onConfirm` returns `'no'`.\n * @throws `ManifestMCPError` (typically `TX_FAILED`) propagated as-is\n *   from the `stopApp()` broadcast step. Broadcast errors do NOT invoke\n *   `onFailure` — that callback is reserved for post-broadcast\n *   verification failures. `stopApp` already raises a structured\n *   `ManifestMCPError` from the core package; wrapping it again at this\n *   layer would be redundant. Callers wanting to react to broadcast\n *   errors should catch them at the call site.\n * @throws `ManifestMCPError(TX_FAILED)` when post-broadcast verification\n *   reaches one of two failure modes (both with `onFailure({ reason })`\n *   invoked first):\n *     - the lease is still non-terminal (`pending_drift` branch — state\n *       decoded as PENDING / ACTIVE / similar non-terminal); or\n *     - the chain returns `{ lease: null }` post-close, so the lease is\n *       not visible on-chain (`unclassified` branch).\n * @throws `ManifestMCPError(QUERY_FAILED)` when the post-broadcast verify\n *   chain query (`billing.v1.lease`) raises a non-NotFound error\n *   (RPC / transport / decoding failure). Wrapped inside the verifier\n *   closure so the failure flows through `onFailure({ reason })` before\n *   the throw. Structured `ManifestMCPError`s raised by the chain client\n *   are re-thrown as-is (with `onFailure` invoked first).\n */\nexport async function closeLease(\n  args: CloseLeaseArgs,\n  callbacks: CloseLeaseCallbacks,\n  opts: CloseLeaseOptions,\n): Promise<CloseLeaseResult> {\n  validateArgs(args);\n\n  const block = renderConfirmationBlock(args);\n  if (callbacks.onConfirm) {\n    const yesNo = await callbacks.onConfirm(block);\n    if (yesNo !== 'yes') {\n      throw new ManifestMCPError(\n        ManifestMCPErrorCode.INVALID_CONFIG,\n        'User declined to proceed with close-lease.',\n      );\n    }\n  }\n  callbacks.onProgress?.({ kind: 'user_confirmed' });\n\n  await stopApp(opts.clientManager, args.leaseUuid);\n\n  // Direct single-lease query (Copilot review PR #60, comment 3275999624):\n  // the previous `leasesByTenant` + page-1-only pagination would\n  // false-`not_found` for tenants with >100 leases. `billing.v1.lease`\n  // is the same query shape `troubleshoot.ts` already uses; it's\n  // tenant-agnostic and bounded to a single lease.\n  const spec: VerificationSpec<unknown, CloseOutcome, CloseDiag> = {\n    verifier: async () => {\n      // Wrap the chain call in try/catch (Copilot review PR #60,\n      // comment 3276419264): if `billing.v1.lease` rejects (RPC down,\n      // transport, structured `ManifestMCPError`), the error would\n      // otherwise propagate OUT of `verifyAndRecover` and bypass the\n      // post-verify `onFailure({ reason })` callback below. Mirror\n      // the disambiguation pattern from `lookupDomain` (commit aaa5cc5)\n      // and `troubleshootDeployment` (commit f1a4737): invoke\n      // `onFailure` first, then re-throw `ManifestMCPError` as-is or\n      // wrap plain errors as `QUERY_FAILED`.\n      let result: unknown;\n      try {\n        const queryClient = await opts.clientManager.getQueryClient();\n        result = await queryClient.liftedinit.billing.v1.lease({\n          leaseUuid: args.leaseUuid,\n        });\n      } catch (err) {\n        const reason = `Failed to query lease ${args.leaseUuid} during close-verify: ${\n          err instanceof Error ? err.message : String(err)\n        }`;\n        if (callbacks.onFailure) {\n          await callbacks.onFailure({ reason });\n        }\n        if (err instanceof ManifestMCPError) {\n          throw err;\n        }\n        throw new ManifestMCPError(ManifestMCPErrorCode.QUERY_FAILED, reason);\n      }\n      const lease = (result as { lease?: unknown })?.lease;\n      if (lease === null || lease === undefined) {\n        return {\n          outcome: 'not_found' as const,\n          diagnostic: {\n            reason: `lease ${args.leaseUuid} not visible on chain after close`,\n          },\n        };\n      }\n      const rawState = (lease as { state?: unknown }).state;\n      const stateName = decodeLeaseState(\n        typeof rawState === 'number' || typeof rawState === 'string'\n          ? rawState\n          : undefined,\n      );\n      if (stateName === undefined) {\n        return {\n          outcome: 'pending' as const,\n          diagnostic: {\n            reason: `lease ${args.leaseUuid} state could not be decoded (raw=${String(rawState)})`,\n          },\n        };\n      }\n      return {\n        outcome: (isTerminal(stateName) ? 'terminal' : 'pending') as\n          | 'terminal'\n          | 'pending',\n        diagnostic: { stateName },\n      };\n    },\n    successValues: ['terminal'],\n    branches: {\n      pending: {\n        branchId: 'pending_drift',\n        journalActionTags: ['close-lease-verify-pending'],\n        buildFailureEnvelope: (d) => ({\n          outcome: 'failed',\n          reason:\n            d.reason ??\n            `close_lease tx accepted but state is still ${d.stateName ?? 'unknown'}.`,\n        }),\n        buildRecoveryOptions: () => [],\n      },\n      not_found: {\n        branchId: 'unclassified',\n        journalActionTags: ['close-lease-verify-not-found'],\n        buildFailureEnvelope: (d) => ({\n          outcome: 'failed',\n          reason:\n            d.reason ??\n            `Lease ${args.leaseUuid} not visible on chain after close.`,\n        }),\n        buildRecoveryOptions: () => [],\n      },\n    },\n  };\n\n  const verifyResult = await verifyAndRecover(spec, undefined);\n\n  if (verifyResult.result !== 'success') {\n    const reason =\n      verifyResult.failure?.reason ?? 'close-lease verification failed.';\n    if (callbacks.onFailure) {\n      await callbacks.onFailure({ reason });\n    }\n    throw new ManifestMCPError(ManifestMCPErrorCode.TX_FAILED, reason);\n  }\n\n  // Invariant: when `verifyAndRecover` returns success, the matched\n  // outcome was `'terminal'`, and the verifier's `terminal` branch\n  // ALWAYS sets `diagnostic.stateName` (see the spec above). A missing\n  // `stateName` on the success path means the verifier invariant is\n  // broken — likely a future refactor regression. The previous\n  // implementation fell back to `'LEASE_STATE_CLOSED'` silently, which\n  // would lie to the caller (Copilot review PR #60, comment 3276719603).\n  // Fail loudly with a typed error instead. `TX_FAILED` is the closest\n  // available code in `ManifestMCPErrorCode` (no `INTERNAL_ERROR`\n  // variant); the message names the invariant explicitly.\n  if (!verifyResult.diagnostic.stateName) {\n    throw new ManifestMCPError(\n      ManifestMCPErrorCode.TX_FAILED,\n      `close-lease verifier invariant violated: success outcome reached without diagnostic.stateName for lease ${args.leaseUuid}`,\n    );\n  }\n  const finalState: LeaseStateName = verifyResult.diagnostic.stateName;\n  const result: CloseLeaseResult = {\n    leaseUuid: args.leaseUuid,\n    finalState,\n  };\n  callbacks.onComplete?.(result);\n  return result;\n}\n\n// --- Helpers --------------------------------------------------------\n\nfunction validateArgs(args: CloseLeaseArgs): void {\n  if (typeof args.leaseUuid !== 'string' || !args.leaseUuid.match(UUID_RE)) {\n    throw new ManifestMCPError(\n      ManifestMCPErrorCode.INVALID_CONFIG,\n      `closeLease: leaseUuid must be a UUID; got \"${args.leaseUuid}\".`,\n    );\n  }\n}\n\nfunction renderConfirmationBlock(args: CloseLeaseArgs): DeploymentPlanBlock {\n  // Image is not tracked in `CloseLeaseArgs` and `stopApp` doesn't return it;\n  // surface the gap explicitly so reviewers/users see the missing context\n  // rather than silently omitting an image field they'd expect.\n  const text = [\n    `Close lease ${args.leaseUuid}.`,\n    '  Image: (image not recorded)',\n    '  This is permanent — the lease cannot be reopened.',\n    '',\n    'Proceed?',\n  ].join('\\n');\n  return { text };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA2CA,MAAM,UACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCF,eAAsB,WACpB,MACA,WACA,MAC2B;AAC3B,cAAa,KAAK;CAElB,MAAM,QAAQ,wBAAwB,KAAK;AAC3C,KAAI,UAAU;MACE,MAAM,UAAU,UAAU,MAAM,KAChC,MACZ,OAAM,IAAI,iBACR,qBAAqB,gBACrB,6CACD;;AAGL,WAAU,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAElD,OAAM,QAAQ,KAAK,eAAe,KAAK,UAAU;CA6FjD,MAAM,eAAe,MAAM,iBAtFsC;EAC/D,UAAU,YAAY;GAUpB,IAAI;AACJ,OAAI;AAEF,aAAS,OADW,MAAM,KAAK,cAAc,gBAAgB,EAClC,WAAW,QAAQ,GAAG,MAAM,EACrD,WAAW,KAAK,WACjB,CAAC;YACK,KAAK;IACZ,MAAM,SAAS,yBAAyB,KAAK,UAAU,wBACrD,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI;AAElD,QAAI,UAAU,UACZ,OAAM,UAAU,UAAU,EAAE,QAAQ,CAAC;AAEvC,QAAI,eAAe,iBACjB,OAAM;AAER,UAAM,IAAI,iBAAiB,qBAAqB,cAAc,OAAO;;GAEvE,MAAM,QAAS,QAAgC;AAC/C,OAAI,UAAU,QAAQ,UAAU,KAAA,EAC9B,QAAO;IACL,SAAS;IACT,YAAY,EACV,QAAQ,SAAS,KAAK,UAAU,oCACjC;IACF;GAEH,MAAM,WAAY,MAA8B;GAChD,MAAM,YAAYA,OAChB,OAAO,aAAa,YAAY,OAAO,aAAa,WAChD,WACA,KAAA,EACL;AACD,OAAI,cAAc,KAAA,EAChB,QAAO;IACL,SAAS;IACT,YAAY,EACV,QAAQ,SAAS,KAAK,UAAU,mCAAmC,OAAO,SAAS,CAAC,IACrF;IACF;AAEH,UAAO;IACL,SAAU,WAAW,UAAU,GAAG,aAAa;IAG/C,YAAY,EAAE,WAAW;IAC1B;;EAEH,eAAe,CAAC,WAAW;EAC3B,UAAU;GACR,SAAS;IACP,UAAU;IACV,mBAAmB,CAAC,6BAA6B;IACjD,uBAAuB,OAAO;KAC5B,SAAS;KACT,QACE,EAAE,UACF,8CAA8C,EAAE,aAAa,UAAU;KAC1E;IACD,4BAA4B,EAAE;IAC/B;GACD,WAAW;IACT,UAAU;IACV,mBAAmB,CAAC,+BAA+B;IACnD,uBAAuB,OAAO;KAC5B,SAAS;KACT,QACE,EAAE,UACF,SAAS,KAAK,UAAU;KAC3B;IACD,4BAA4B,EAAE;IAC/B;GACF;EACF,EAEiD,KAAA,EAAU;AAE5D,KAAI,aAAa,WAAW,WAAW;EACrC,MAAM,SACJ,aAAa,SAAS,UAAU;AAClC,MAAI,UAAU,UACZ,OAAM,UAAU,UAAU,EAAE,QAAQ,CAAC;AAEvC,QAAM,IAAI,iBAAiB,qBAAqB,WAAW,OAAO;;AAapE,KAAI,CAAC,aAAa,WAAW,UAC3B,OAAM,IAAI,iBACR,qBAAqB,WACrB,2GAA2G,KAAK,YACjH;CAEH,MAAM,aAA6B,aAAa,WAAW;CAC3D,MAAM,SAA2B;EAC/B,WAAW,KAAK;EAChB;EACD;AACD,WAAU,aAAa,OAAO;AAC9B,QAAO;;AAKT,SAAS,aAAa,MAA4B;AAChD,KAAI,OAAO,KAAK,cAAc,YAAY,CAAC,KAAK,UAAU,MAAM,QAAQ,CACtE,OAAM,IAAI,iBACR,qBAAqB,gBACrB,8CAA8C,KAAK,UAAU,IAC9D;;AAIL,SAAS,wBAAwB,MAA2C;AAW1E,QAAO,EAAE,MAPI;EACX,eAAe,KAAK,UAAU;EAC9B;EACA;EACA;EACA;EACD,CAAC,KAAK,KAAK,EACG"}

package/dist/deploy-app.d.ts

@@ -0,0 +1,24 @@
+import { DeployAppCallbacks, DeployAppOptions, DeployResult, DeploySpec } from "./types.js";
+
+//#region src/deploy-app.d.ts
+/**
+ * Orchestrate a deployment. See module-level docstring for the architect-
+ * locked composition + E-hybrid runtime-context contract.
+ *
+ * @throws `ManifestMCPError(INVALID_CONFIG)` for spec / wallet validation.
+ * @throws `ManifestMCPError(INVALID_CONFIG)` when `onConfirm` returns
+ *   `'no'` or `onPlan` returns `'cancel'`.
+ *
+ * Errors from fred's broadcast or core's recovery primitives surface as
+ * typed `ManifestMCPError`s. Partial-success failures with applicable
+ * recovery options route through `onFailure(envelope, options)` — the
+ * callback's return value drives recovery dispatch via the inline
+ * closures in `dispatchRecovery`. Non-partial or inform-only failures
+ * (no recovery choices to present, per `handleBroadcastFailure`'s F3
+ * branch) throw directly as `ManifestMCPError(TX_FAILED)` without
+ * invoking `onFailure`.
+ */
+declare function deployApp(spec: DeploySpec, callbacks: DeployAppCallbacks, opts: DeployAppOptions): Promise<DeployResult>;
+//#endregion
+export { deployApp };
+//# sourceMappingURL=deploy-app.d.ts.map

package/dist/deploy-app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploy-app.d.ts","names":[],"sources":["../src/deploy-app.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;iBAoHsB,SAAA,CACpB,IAAA,EAAM,UAAA,EACN,SAAA,EAAW,kBAAA,EACX,IAAA,EAAM,gBAAA,GACL,OAAA,CAAQ,YAAA"}