@sprigr/apps-app-sdk 0.8.3 → 0.8.5

package/README.md

@@ -68,11 +68,12 @@ Three platform tiers, and they are not substitutes for each other. Full guide: [
 | T3 undo | handler returns `_undo`; manifest `undo.reverse_tool` | platform token | `requireApproval` (capture), `undoEnvelope`, `runUndoApply`, `@sprigr/apps-undo-journal` |
 
 - `requireApproval(handlers, specs, opts)` wraps the named tools so each returns an `_approval` card instead of writing, then on the granted pass captures a before-image through the **pinned** connection and offers `_undo`. It resolves the connection inside itself, before the label lookup, the hash and the capture: a gate that sits outside the app's own pin names the wrong store, hashes the wrong store and captures the wrong store's copy. Register the result after the originals: `Object.assign(registry, requireApproval(registry, SPECS, opts))`.
+- `dispatcherApproval(specs, opts)`: the same gate for a one-tool-many-actions dispatcher. Build it beside the action registry and call `gate.run(action, args, env, () => def.execute(state, parsed))` from the dispatcher; params are read from `opts.inputField` (default `input`), the action name is hashed in, and `pinEnv` may return a per-actor token state rather than the env.
 - `approvalHash(rawId, connection, ...parts)`, `set(values)`, `seq(values)`: a stable operation identity so a tap survives the model reordering a list or dropping an optional argument on the retry.
 - `undoEnvelope({...})` throws on a blank field. The platform drops the whole envelope on a blank and mints nothing, silently.
 - `refuseWithoutForce(name, handler, opts)` / `archiveOfferRefusal(...)`: a delete refuses once and offers the vendor's native archive unless `force: true`.
 - `buildConfirmationPolicy({ irreversible, always, rules })` declares a dispatcher's policy beside its action registry; `checkConfirmationPolicy({ policy, registry, ungated, requiredInput })` returns every silent failure (dead rule, `(unset)` placeholder, money threshold, unclassified write) for a one-line test.
-- `runUndoApply(args, { env, journal, specs, pin })` is the body of your `internal: true` reverse tool: load, re-pin to the journalled connection, restore, drop. `pin` may hand `restore` a different type from the env (a per-actor token state), may throw (`connection_unavailable`) or return null to refuse (`connection_mismatch`); a restore that throws is `restore_failed` and the copy is kept.
+- `runUndoApply(args, { env, journal, specs, pin })` is the body of your `internal: true` reverse tool: load, re-pin to the journalled connection, restore, drop. `pin` may hand `restore` a different type from the env (a per-actor token state), may throw (`connection_unavailable`) or return null to refuse (`connection_mismatch`); a restore that throws is `restore_failed` and the copy is kept; a successful restore may return `newId`, `notRestored`, `extra` (spread into the payload) and `note` (appended after the fidelity sentence).
 - `safeCapture(scope, name, id, read)` and `offerUndo({ journal, entity, id, before, connection, fidelity, resource, describe, warning })`: the capture-then-offer halves for a write that is not behind an approval card (a dispatcher `update_*` action). `requireApproval` uses the same two on its granted pass.
 - `sprigr-check-write-protection` (bin): every destructive-by-name tool or enumerated dispatcher action must carry a policy, or a reason in `apps/<app>/write-protection.json`; ratchets on `tools/write-protection-baseline.json`.
 

package/dist/index.d.ts

@@ -1047,7 +1047,12 @@ declare function refuseWithoutForce<E>(deleteAction: string, inner: ToolHandler<
 
 /**
  * Human approval for the writes a vendor cannot undo, plus the before-image
- * capture for the ones it can partly undo, in ONE wrapper.
+ * capture for the ones it can partly undo, in ONE wrapper. Two shapes over the
+ * same core:
+ *
+ *   requireApproval(handlers, specs, opts)   flat tools, one handler per tool
+ *   dispatcherApproval(specs, opts)          one tool, many actions; the
+ *                                            dispatcher calls gate.run(...)
  *
  * ## Why this exists when the manifest already declares `confirmation`
  *
@@ -1078,8 +1083,8 @@ declare function refuseWithoutForce<E>(deleteAction: string, inner: ToolHandler<
  * questions stay in the app, because only the app knows what cannot be walked
  * back.
  */
-/** Per-tool spec: how the card reads, and (optionally) how to journal a before-image. */
-interface ApprovalSpec<E = unknown> {
+/** Per-tool (or per-action) spec: how the card reads, and (optionally) how to journal a before-image. */
+interface ApprovalSpec<P = unknown> {
     /**
      * Arg names that may carry the target id, most specific first. ONE list, used
      * for both the card label and the grant hash, so the two cannot drift apart
@@ -1091,7 +1096,7 @@ interface ApprovalSpec<E = unknown> {
      * `connection` the resolved store / organisation / business, or '' when the
      * app has one. Do not set `hash` here; the wrapper derives it from the raw
      * id and the connection so it cannot move between the ask and the retry.
-     * Override with `hash` below only when the arguments understate the blast
+     * Extend with `hash` below only when the arguments understate the blast
      * radius.
      */
     describe: (target: string, args: ToolArgs, connection: string) => Omit<AppApprovalEnvelope, 'hash'>;
@@ -1101,14 +1106,14 @@ interface ApprovalSpec<E = unknown> {
      */
     hash?: (args: ToolArgs) => Array<string | number | undefined | null>;
     /** Present only for tools whose write can be (partly) reversed. */
-    undo?: UndoCaptureSpec<E>;
+    undo?: UndoCaptureSpec<P>;
 }
-interface UndoCaptureSpec<E = unknown> {
+interface UndoCaptureSpec<P = unknown> {
     /** Coarse type surfaced as `_undo.resource`. */
     resource: string;
     fidelity: UndoFidelity;
-    /** Read the object BEFORE the write, through the PINNED env. Null or throw on miss. */
-    capture: (pinnedEnv: E, id: string, args: ToolArgs) => Promise<unknown>;
+    /** Read the object BEFORE the write, through the PINNED env or state. Null or throw on miss. */
+    capture: (pinned: P, id: string, args: ToolArgs) => Promise<unknown>;
     /** How the change reads in `list_undoable_changes`; the connection is appended by the wrapper. */
     describe: (before: Record<string, unknown>, id: string) => string;
     /** Relayed verbatim; on `'recreated'` it must say the id changes. Never empty. */
@@ -1125,7 +1130,12 @@ interface CaptureJournal {
         ref: string;
     } | null>;
 }
-interface RequireApprovalOptions<E = unknown> {
+/**
+ * `E` is the env the tool receives; `P` is what the pinned connection looks
+ * like to `capture` and `describeTarget` (the same env re-pinned for Shopify,
+ * a fresh per-actor token state for Xero or Asana).
+ */
+interface ApprovalGateOptions<E, P = E> {
     /** Log prefix, e.g. `shopify-undo`. */
     scope: string;
     /**
@@ -1135,14 +1145,19 @@ interface RequireApprovalOptions<E = unknown> {
      * the arguments alone: on the retry the model usually omits it.
      */
     resolveConnection: (env: E, args: ToolArgs) => Promise<string>;
-    /** Re-pin the env to a resolved connection so lookups and captures hit it. */
-    pinEnv: (env: E, connection: string) => E;
     /**
-     * Human label for a raw id, looked up THROUGH the pinned env. Fall back to
-     * the id on any miss; never guess, a confidently wrong card is worse than a
-     * terse one. Omit to always show the raw id.
+     * Re-pin to a resolved connection so lookups and captures hit it. Omit when
+     * `P` is `E` and the env needs no pin (a single-connection app).
+     */
+    pinEnv?: (env: E, connection: string) => P | Promise<P>;
+    /**
+     * Human label for a raw id, looked up THROUGH the pinned connection. Fall
+     * back to the id on any miss; never guess, a confidently wrong card is worse
+     * than a terse one. Omit to always show the raw id. `name` is the tool, or
+     * for a dispatcher the action, so a lookup can route by resource type when
+     * the id alone does not say what it is (an Asana gid).
      */
-    describeTarget?: (pinnedEnv: E, id: string) => Promise<string>;
+    describeTarget?: (pinned: P, id: string, name: string) => Promise<string>;
     /**
      * Where before-images go. Required when any spec declares `undo`. The
      * journal's own capture returns null rather than throwing, and this wrapper
@@ -1155,8 +1170,29 @@ interface RequireApprovalOptions<E = unknown> {
      */
     stampConnection?: (result: unknown, connection: string) => unknown;
 }
+/** Flat-tool options: the pinned type is the env itself. */
+type RequireApprovalOptions<E> = ApprovalGateOptions<E, E>;
+interface DispatcherApprovalOptions<E, P = E> extends ApprovalGateOptions<E, P> {
+    /**
+     * Where the per-action params live on the dispatched args (`{ action,
+     * input: {...} }` -> 'input'). When the field is absent the top-level args
+     * are used, which is the flat-verb envelope. Default 'input'.
+     */
+    inputField?: string;
+}
+interface DispatcherApprovalGate<E> {
+    /** True when `action` carries an approval spec. */
+    has(action: string): boolean;
+    /**
+     * Run one dispatched action through the gate. With no spec, `write` just
+     * runs. With a spec, the ask pass returns the `_approval` card and never
+     * calls `write`; the granted pass captures, calls `write`, and offers
+     * `_undo` beside its result.
+     */
+    run(action: string, args: ToolArgs, env: E, write: () => Promise<unknown>): Promise<unknown>;
+}
 /**
- * Wrap the named tools so each asks a human first, then (if it declares
+ * Wrap the named flat tools so each asks a human first, then (if it declares
  * `undo`) journals a before-image on the granted pass and offers `_undo`.
  *
  * Returns only the wrapped entries. Register them AFTER the originals
@@ -1168,6 +1204,20 @@ interface RequireApprovalOptions<E = unknown> {
  * guard exists to prevent, and it would look identical to working.
  */
 declare function requireApproval<E>(handlers: Record<string, ToolHandler<E>>, specs: Record<string, ApprovalSpec<E>>, opts: RequireApprovalOptions<E>): Record<string, ToolHandler<E>>;
+/**
+ * The same gate for a dispatcher tool (one tool, many actions selected by an
+ * input field). Build it once beside the action registry and call `run` from
+ * the dispatcher after the action is resolved and its params parsed:
+ *
+ *   const gate = dispatcherApproval(SPECS, { scope, resolveConnection, pinEnv, journal });
+ *   ...
+ *   return gate.run(action, args, env, () => def.execute(state, parsed));
+ *
+ * The platform stamps `_approval_granted` on the TOP-LEVEL args; the per-action
+ * params are read from `opts.inputField` (default `input`), or from the
+ * top-level args when that field is absent (the flat-verb envelope).
+ */
+declare function dispatcherApproval<E, P = E>(specs: Record<string, ApprovalSpec<P>>, opts: DispatcherApprovalOptions<E, P>): DispatcherApprovalGate<E>;
 
 /**
  * The reversal entry point every adopting app declares as `undo.reverse_tool`.
@@ -1221,6 +1271,13 @@ interface RestoreResult {
     error?: string;
     notRestored?: string;
     extra?: Record<string, unknown>;
+    /**
+     * Free-form detail appended to the runner's note (the new gid, rows it
+     * could not refile, a sticker the vendor will not remove). The runner's own
+     * sentence on fidelity stays first so the model reads "replacement, not an
+     * undo" before the detail.
+     */
+    note?: string;
 }
 interface JournalRowLike<T = unknown> {
     entity: string;
@@ -1767,4 +1824,4 @@ interface ExecutionContextLike {
 }
 type HandlerFn<TArgs, TResult> = (args: TArgs, env: Record<string, unknown>, ctx?: ExecutionContextLike) => Promise<TResult>;
 
-export { APPROVAL_GRANTED_KEY, type Actor, type AppApprovalEnvelope, type AppFileListItem, type AppFileUrlArgs, type AppFileUrlResult, type AppFilesEnv, type AppUndoEnvelope, type ApprovalSpec, type ArchiveOfferOptions, type ArchiveOfferRefusal, type CaptureJournal, type ConfirmCondition, type ConfirmRule, type ConfirmationPolicy, type D1Like, type D1PreparedStatementLike, DEFAULT_EMIT_TIMEOUT_MS, DEFAULT_MAX_FILE_BYTES, DEFAULT_MONEY_FIELDS, DEFAULT_WRITE_PREFIXES, type EmitMarketplaceEventOptions, type EmitResult, type EmitTransport, type EventArgs, type ExecutionContextLike, type FetchFileResult, type FetchWithRetryOptions, type GetAppFileResult, type HandlerFn, type InboxOwner, type InstallBridge, InvalidUndoEnvelopeError, type JournalRowLike, type MarketplaceEventEmitOpts, type MarketplaceEventSourceIntegration, NotConnectedError, type OAuthBouncerSignals, type OAuthState, type OfferUndoArgs, type PlatformHostEnv, type PolicyCheckInput, type PolicySource, type PutAppFileArgs, type PutAppFileResult, type PutAppFileStreamArgs, type RequireApprovalOptions, type RestoreResult, type RestoreSpec, type ScheduleArgs, type SprigrDataAggregationCell, type SprigrDataAggregationResult, type SprigrDataAggregationSpec, type SprigrDataApi, type SprigrDataIndexOpts, type SprigrDataSearchOpts, type SprigrDataSearchResult, type SprigrFilesApi, type SprigrFilesApiWithEdit, type SprigrFilesCreateInput, type SprigrFilesCreateResult, type SprigrFilesEditInput, type SprigrFilesEditResult, type SprigrFilesJobResult, type ToolArgs, type ToolHandler, type ToolResult, type ToolWrapperOptions, UNIT_SEP, type UndoApplyOptions, type UndoApplyResult, type UndoCaptureSpec, type UndoFidelity, type WebhookArgs, type WfpBridgeEnv, type WfpEmitReply, actorKey, actorTool, appFileUrl, approvalHash, archiveOfferRefusal, base64ToBytes, buildConfirmationPolicy, buildMarketplaceWebhookUrl, bytesToBase64, canEmit, checkConfirmationPolicy, constantTimeEqual, createMarketplaceEmitter, createToolWrappers, decodeState, deleteAppFile, describeMissingBridge, emitMarketplaceEvent, encodeState, fetchFileAsBase64, fetchFileBytes, fetchWithRetry, fullWarning, getAppFile, hmacSha256Hex, installTokenPost, isNotConnectedError, isStagingHost, listAppFiles, offerUndo, overlaySprigr, ownerFromActorKey, parseActor, putAppFile, putAppFileStream, randomHex, recreatedWarning, refuseWithoutForce, requireApproval, resolveInstallBridge, resolveOAuthBouncerBase, resolveOAuthBouncerCallbackUrl, resolvePlatformWebhookBase, runUndoApply, safeCapture, seq, set, tool, undoEnvelope, withSprigrEmitFallback };
+export { APPROVAL_GRANTED_KEY, type Actor, type AppApprovalEnvelope, type AppFileListItem, type AppFileUrlArgs, type AppFileUrlResult, type AppFilesEnv, type AppUndoEnvelope, type ApprovalGateOptions, type ApprovalSpec, type ArchiveOfferOptions, type ArchiveOfferRefusal, type CaptureJournal, type ConfirmCondition, type ConfirmRule, type ConfirmationPolicy, type D1Like, type D1PreparedStatementLike, DEFAULT_EMIT_TIMEOUT_MS, DEFAULT_MAX_FILE_BYTES, DEFAULT_MONEY_FIELDS, DEFAULT_WRITE_PREFIXES, type DispatcherApprovalGate, type DispatcherApprovalOptions, type EmitMarketplaceEventOptions, type EmitResult, type EmitTransport, type EventArgs, type ExecutionContextLike, type FetchFileResult, type FetchWithRetryOptions, type GetAppFileResult, type HandlerFn, type InboxOwner, type InstallBridge, InvalidUndoEnvelopeError, type JournalRowLike, type MarketplaceEventEmitOpts, type MarketplaceEventSourceIntegration, NotConnectedError, type OAuthBouncerSignals, type OAuthState, type OfferUndoArgs, type PlatformHostEnv, type PolicyCheckInput, type PolicySource, type PutAppFileArgs, type PutAppFileResult, type PutAppFileStreamArgs, type RequireApprovalOptions, type RestoreResult, type RestoreSpec, type ScheduleArgs, type SprigrDataAggregationCell, type SprigrDataAggregationResult, type SprigrDataAggregationSpec, type SprigrDataApi, type SprigrDataIndexOpts, type SprigrDataSearchOpts, type SprigrDataSearchResult, type SprigrFilesApi, type SprigrFilesApiWithEdit, type SprigrFilesCreateInput, type SprigrFilesCreateResult, type SprigrFilesEditInput, type SprigrFilesEditResult, type SprigrFilesJobResult, type ToolArgs, type ToolHandler, type ToolResult, type ToolWrapperOptions, UNIT_SEP, type UndoApplyOptions, type UndoApplyResult, type UndoCaptureSpec, type UndoFidelity, type WebhookArgs, type WfpBridgeEnv, type WfpEmitReply, actorKey, actorTool, appFileUrl, approvalHash, archiveOfferRefusal, base64ToBytes, buildConfirmationPolicy, buildMarketplaceWebhookUrl, bytesToBase64, canEmit, checkConfirmationPolicy, constantTimeEqual, createMarketplaceEmitter, createToolWrappers, decodeState, deleteAppFile, describeMissingBridge, dispatcherApproval, emitMarketplaceEvent, encodeState, fetchFileAsBase64, fetchFileBytes, fetchWithRetry, fullWarning, getAppFile, hmacSha256Hex, installTokenPost, isNotConnectedError, isStagingHost, listAppFiles, offerUndo, overlaySprigr, ownerFromActorKey, parseActor, putAppFile, putAppFileStream, randomHex, recreatedWarning, refuseWithoutForce, requireApproval, resolveInstallBridge, resolveOAuthBouncerBase, resolveOAuthBouncerCallbackUrl, resolvePlatformWebhookBase, runUndoApply, safeCapture, seq, set, tool, undoEnvelope, withSprigrEmitFallback };

package/dist/index.js

@@ -617,57 +617,41 @@ function rawIdOf(args, keys) {
 function isOk(result) {
   return !!result && typeof result === "object" && result.ok !== false;
 }
-function requireApproval(handlers, specs, opts) {
-  const gated = {};
-  for (const [name, spec] of Object.entries(specs)) {
-    const inner = handlers[name];
-    if (!inner) {
-      throw new Error(
-        `requireApproval: "${name}" has an approval spec but is not in the handler registry. It was probably renamed or removed; update the specs in the same change, or a destructive tool ships ungated.`
-      );
-    }
-    if (spec.undo && !opts.journal) {
-      throw new Error(`requireApproval: "${name}" declares undo but no journal was supplied.`);
-    }
-    gated[name] = async (args, env, ctx) => {
-      const a = args ?? {};
-      if (a[APPROVAL_GRANTED_KEY] === true) {
-        const { [APPROVAL_GRANTED_KEY]: _granted, ...rest } = a;
-        return granted(name, spec, rest, env, ctx, inner, opts);
-      }
-      const connection = await opts.resolveConnection(env, a);
-      const rawId = rawIdOf(a, spec.keys);
-      const pinned = connection ? opts.pinEnv(env, connection) : env;
-      const target = rawId && opts.describeTarget ? await safeLabel(opts.describeTarget, pinned, rawId) : rawId || "(unknown id)";
-      const extra = spec.hash ? spec.hash(a) : [];
-      return {
-        ok: false,
-        _approval: {
-          ...spec.describe(target, a, connection),
-          hash: approvalHash(rawId, connection, ...extra)
-        }
-      };
-    };
-  }
-  return gated;
-}
-async function safeLabel(fn, env, id) {
+async function safeLabel(fn, pinned, id, name) {
   try {
-    const label = await fn(env, id);
+    const label = await fn(pinned, id, name);
     return label && label.trim() ? label : id;
   } catch {
     return id;
   }
 }
-async function granted(name, spec, args, env, ctx, inner, opts) {
-  const connection = await opts.resolveConnection(env, args);
+async function pin(opts, env, connection) {
+  if (!connection || !opts.pinEnv) return env;
+  return opts.pinEnv(env, connection);
+}
+async function askPass(name, spec, params, env, opts, hashPrefix) {
+  const connection = await opts.resolveConnection(env, params);
+  const rawId = rawIdOf(params, spec.keys);
+  const pinned = await pin(opts, env, connection);
+  const target = rawId && opts.describeTarget ? await safeLabel(opts.describeTarget, pinned, rawId, name) : rawId || "(unknown id)";
+  const extra = spec.hash ? spec.hash(params) : [];
+  return {
+    ok: false,
+    _approval: {
+      ...spec.describe(target, params, connection),
+      hash: approvalHash(...hashPrefix, rawId, connection, ...extra)
+    }
+  };
+}
+async function grantedPass(name, spec, params, env, opts, write) {
+  const connection = await opts.resolveConnection(env, params);
   const stamp = (r) => connection && opts.stampConnection ? opts.stampConnection(r, connection) : r;
   const undo = spec.undo;
-  const id = rawIdOf(args, spec.keys);
-  if (!undo || !id) return stamp(await inner(args, env, ctx));
-  const pinned = connection ? opts.pinEnv(env, connection) : env;
-  const before = await safeCapture(opts.scope, name, id, () => undo.capture(pinned, id, args));
-  const result = await inner(args, env, ctx);
+  const id = rawIdOf(params, spec.keys);
+  if (!undo || !id) return stamp(await write());
+  const pinned = await pin(opts, env, connection);
+  const before = await safeCapture(opts.scope, name, id, () => undo.capture(pinned, id, params));
+  const result = await write();
   if (!isOk(result) || !before) return stamp(result);
   const envelope = await offerUndo({
     journal: opts.journal(env),
@@ -683,6 +667,50 @@ async function granted(name, spec, args, env, ctx, inner, opts) {
   if (!envelope) return stamp(result);
   return { ...stamp(result), _undo: envelope };
 }
+function assertJournal(name, spec, opts, who) {
+  if (spec.undo && !opts.journal) {
+    throw new Error(`${who}: "${name}" declares undo but no journal was supplied.`);
+  }
+}
+function requireApproval(handlers, specs, opts) {
+  const gated = {};
+  for (const [name, spec] of Object.entries(specs)) {
+    const inner = handlers[name];
+    if (!inner) {
+      throw new Error(
+        `requireApproval: "${name}" has an approval spec but is not in the handler registry. It was probably renamed or removed; update the specs in the same change, or a destructive tool ships ungated.`
+      );
+    }
+    assertJournal(name, spec, opts, "requireApproval");
+    gated[name] = async (args, env, ctx) => {
+      const a = args ?? {};
+      if (a[APPROVAL_GRANTED_KEY] === true) {
+        const { [APPROVAL_GRANTED_KEY]: _granted, ...rest } = a;
+        return grantedPass(name, spec, rest, env, opts, () => inner(rest, env, ctx));
+      }
+      return askPass(name, spec, a, env, opts, []);
+    };
+  }
+  return gated;
+}
+function dispatcherApproval(specs, opts) {
+  for (const [name, spec] of Object.entries(specs)) assertJournal(name, spec, opts, "dispatcherApproval");
+  const field = opts.inputField ?? "input";
+  return {
+    has: (action) => Object.prototype.hasOwnProperty.call(specs, action),
+    async run(action, args, env, write) {
+      const spec = specs[action];
+      if (!spec) return write();
+      const a = args ?? {};
+      const nested = a[field];
+      const params = nested && typeof nested === "object" && !Array.isArray(nested) ? nested : a;
+      if (a[APPROVAL_GRANTED_KEY] === true) {
+        return grantedPass(action, spec, params, env, opts, write);
+      }
+      return askPass(action, spec, params, env, opts, [action]);
+    }
+  };
+}
 
 // src/write-protection/undo-apply.ts
 async function runUndoApply(args, opts) {
@@ -705,7 +733,7 @@ async function runUndoApply(args, opts) {
     };
   }
   const before = row.before;
-  if (!before || typeof before !== "object") {
+  if (!before || typeof before !== "object" || Array.isArray(before)) {
     return { ok: false, error: "before_image_unreadable", note: "The saved copy could not be read back. Nothing was changed." };
   }
   let pinned;
@@ -741,6 +769,7 @@ async function runUndoApply(args, opts) {
   await opts.journal.dropBefore(ref);
   const recreated = spec.fidelity === "recreated";
   const notRestored = result.notRestored ?? spec.notRestored;
+  const suffix = result.note && result.note.trim() ? ` ${result.note.trim()}` : "";
   return {
     ok: true,
     ...result.extra ?? {},
@@ -750,7 +779,7 @@ async function runUndoApply(args, opts) {
     new_id: result.newId ?? null,
     fidelity: spec.fidelity,
     ...notRestored ? { not_restored: notRestored } : {},
-    note: recreated ? `Created a NEW ${spec.resource}${result.newId ? ` (${result.newId})` : ""} from the saved copy. The original ${row.original_id} is still gone and its id will never be reissued.${notRestored ? ` Not restored: ${notRestored}.` : ""} Report this as a replacement, not as an undo.` : `Restored ${spec.resource} ${row.original_id} to its saved values.${notRestored ? ` Not restored: ${notRestored}.` : ""} Anything changed since the capture was overwritten.`
+    note: recreated ? `Created a NEW ${spec.resource}${result.newId ? ` (${result.newId})` : ""} from the saved copy. The original ${row.original_id} is still gone and its id will never be reissued.${notRestored ? ` Not restored: ${notRestored}.` : ""} Report this as a replacement, not as an undo.${suffix}` : `Restored ${spec.resource} ${row.original_id} to its saved values.${notRestored ? ` Not restored: ${notRestored}.` : ""} Anything changed since the capture was overwritten.${suffix}`
   };
 }
 
@@ -937,6 +966,7 @@ export {
   decodeState,
   deleteAppFile,
   describeMissingBridge,
+  dispatcherApproval,
   emitMarketplaceEvent,
   encodeState,
   fetchFileAsBase64,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sprigr/apps-app-sdk",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",