@monimesl/dot-cli 1.0.0-beta.1 → 1.0.0-beta.11

package/dist/templates/showcase/pages/dash/cache/controller.ts

@@ -1,3 +1,5 @@
+import { errorMessage } from '@monimesl/dot-runtime';
+
 import state from './state';
 
 const RECENT = 'recent/';
@@ -12,38 +14,65 @@ export default definePage({
       await this.actions.refresh();
     },
   },
+  // Values are JSON: text, numbers, true or false, lists and objects. Each can be up to 1 MB,
+  // and the cache up to 64 MB. A full cache rejects with 'failed'.
   actions: {
     async refresh() {
-      const keys = await this.dash.storage.cache.keys();
-      const recent: string[] = [];
-      for (const key of keys.filter((each) => each.startsWith(RECENT))) {
-        recent.push((await this.dash.storage.cache.get<string>(key)) ?? '');
+      try {
+        const keys = await this.dash.storage.cache.keys();
+        const recent: string[] = [];
+        for (const key of keys.filter((each) => each.startsWith(RECENT))) {
+          // get gives null for a key that's missing or expired.
+          recent.push((await this.dash.storage.cache.get<string>(key)) ?? '');
+        }
+        const hasGenre = await this.dash.storage.cache.exists(GENRE);
+        this.setState({
+          recent,
+          genre: hasGenre ? ((await this.dash.storage.cache.get<string>(GENRE)) ?? '') : '',
+          keys: keys.join(', '),
+        });
+      } catch (error) {
+        this.setState({ note: errorMessage(error) });
       }
-      const hasGenre = await this.dash.storage.cache.exists(GENRE);
-      this.setState({
-        recent,
-        genre: hasGenre ? ((await this.dash.storage.cache.get<string>(GENRE)) ?? '') : '',
-        keys: keys.join(', '),
-      });
     },
     // Each view lasts 30 seconds, then the cache forgets it.
     async view(_state, event: DataEvent<{ id: string; name: string }>) {
-      await this.dash.storage.cache.set(`${RECENT}${event.data.id}`, event.data.name, {
-        ttl: RECENT_MILLISECONDS,
-      });
+      try {
+        await this.dash.storage.cache.set(`${RECENT}${event.data.id}`, event.data.name, {
+          ttl: RECENT_MILLISECONDS,
+        });
+        this.setState({ note: '' });
+      } catch (error) {
+        this.setState({ note: errorMessage(error) });
+      }
       await this.actions.refresh();
     },
     // With no ttl, the genre lasts until it's removed.
     async setGenre(_state, event: ValueEvent) {
-      await this.dash.storage.cache.set(GENRE, event.detail.value);
+      try {
+        await this.dash.storage.cache.set(GENRE, event.detail.value);
+        this.setState({ note: '' });
+      } catch (error) {
+        this.setState({ note: errorMessage(error) });
+      }
       await this.actions.refresh();
     },
     async forgetGenre() {
-      await this.dash.storage.cache.remove(GENRE);
+      try {
+        await this.dash.storage.cache.remove(GENRE);
+        this.setState({ note: '' });
+      } catch (error) {
+        this.setState({ note: errorMessage(error) });
+      }
       await this.actions.refresh();
     },
     async clear() {
-      await this.dash.storage.cache.clear();
+      try {
+        await this.dash.storage.cache.clear();
+        this.setState({ note: '' });
+      } catch (error) {
+        this.setState({ note: errorMessage(error) });
+      }
       await this.actions.refresh();
     },
   },

package/dist/templates/showcase/pages/dash/cache/state.ts

@@ -14,4 +14,5 @@ export default {
   recent: [] as string[],
   genre: '',
   keys: '',
+  note: '',
 };

package/dist/templates/showcase/pages/dash/cache/view.dml

@@ -45,4 +45,8 @@
       </View>
     </View>
   </View>
+
+  <If condition="{{ note }}">
+    <Notice tone="danger">{{ note }}</Notice>
+  </If>
 </View>

package/dist/templates/showcase/pages/dash/calls/controller.ts

@@ -3,7 +3,7 @@ import { errorMessage, isDashError } from '@monimesl/dot-runtime';
 
 import state from './state';
 
-// The long wait, kept so the Cancel button can stop it.
+// The long wait, kept so the Cancel button can stop it. cancel() makes it reject with 'cancelled'.
 let wait: DashRequest<void> | null = null;
 
 export default definePage({
@@ -27,7 +27,8 @@ export default definePage({
       try {
         switch (event.data.call) {
           case 'timeout':
-            // Gives up after 1 second on a wait of 5.
+            // Every call takes { timeout } last, except payments.request, where Dash decides.
+            // This gives up after 1 second on a wait of 5.
             await this.dash.system.delay(5000, { timeout: 1000 });
             break;
           case 'cancelled':

package/dist/templates/showcase/pages/dash/contacts/controller.ts

@@ -6,6 +6,7 @@ export default definePage({
   initialState: state,
   configs: { navigationBar: { title: 'Contacts' } },
   actions: {
+    // Resolves with { name, phone }, the number as the contact has it, such as "076 123456".
     async choose() {
       try {
         const contact = await unlessCancelled(this.dash.contacts.pickPhone());

package/dist/templates/showcase/pages/dash/crypto/controller.ts

@@ -12,6 +12,7 @@ export default definePage({
     encode: (state) => ({ encoded: dash.utils.base64.encode(state.text) }),
   },
   actions: {
+    // Text goes in as UTF-8. Binary data goes in as { base64: '…' }.
     async hash(state) {
       try {
         const sha256 = await this.dash.crypto.sha256(state.text);
@@ -25,6 +26,7 @@ export default definePage({
         this.setState({ note: errorMessage(error) });
       }
     },
+    // randomBytes takes a count from 1 to 1024.
     async makeRandom() {
       try {
         const random = await this.dash.crypto.randomBytes(16);

package/dist/templates/showcase/pages/dash/crypto/view.dml

@@ -1,6 +1,6 @@
 <View>
   <Text variant="title">dash.crypto</Text>
-  <Text>Hashes, signatures and random values, worked out on the phone. Each gives hex, or base64 with { as: 'base64' }.</Text>
+  <Text>Hashes, signatures and random values, worked out on the phone. They come as hex, or as base64 with { as: 'base64' }. randomUUID gives a UUID.</Text>
 
   <View variant="card" gap="medium">
     <Input label="Text" value="{{ text }}" onChange="setText" />

package/dist/templates/showcase/pages/dash/files/controller.ts

@@ -1,3 +1,5 @@
+import { errorMessage } from '@monimesl/dot-runtime';
+
 import type { Archive, Song } from './state';
 import state from './state';
 
@@ -14,57 +16,90 @@ export default definePage({
   mutations: {
     setDraft: (_state, event: ValueEvent) => ({ draft: event.detail.value }),
   },
+  // Paths are inside the dot's folder, and '' is the folder itself. A call on a path with nothing
+  // there rejects with 'missing', while stat gives null.
   actions: {
     async refresh() {
-      const entries = await this.dash.storage.file.list('', { recursive: true });
-      const songs: Song[] = [];
-      for (const entry of entries) {
-        if (entry.kind === 'file' && entry.path.startsWith('setlist/')) {
-          songs.push({ path: entry.path, text: await this.dash.storage.file.read(entry.path) });
+      try {
+        const entries = await this.dash.storage.file.list('', { recursive: true });
+        const songs: Song[] = [];
+        for (const entry of entries) {
+          if (entry.kind === 'file' && entry.path.startsWith('setlist/')) {
+            songs.push({ path: entry.path, text: await this.dash.storage.file.read(entry.path) });
+          }
         }
+        const archives: Archive[] = entries
+          .filter((entry) => entry.kind === 'folder' && /^archive\/[^/]+$/.test(entry.path))
+          .map((entry) => ({
+            path: entry.path,
+            time: new Date(Number(entry.name)).toLocaleTimeString('en-GB'),
+          }))
+          .reverse();
+        const documents = entries.filter(
+          (entry) => entry.kind === 'file' && entry.path.startsWith('documents/'),
+        );
+        // In bytes: what the dot's files take, and the most they may take.
+        const { used, quota } = await this.dash.storage.file.usage();
+        const kept = await this.dash.storage.file.stat(PICTURE);
+        this.setState({
+          songs,
+          archives,
+          documents,
+          usage: `${used} bytes used of ${quota / 1024 / 1024} MB`,
+          picture: kept ? (await this.dash.storage.file.open(PICTURE)).url : '',
+        });
+      } catch (error) {
+        this.setState({ note: errorMessage(error) });
       }
-      const archives: Archive[] = entries
-        .filter((entry) => entry.kind === 'folder' && /^archive\/[^/]+$/.test(entry.path))
-        .map((entry) => ({
-          path: entry.path,
-          time: new Date(Number(entry.name)).toLocaleTimeString('en-GB'),
-        }))
-        .reverse();
-      const documents = entries.filter(
-        (entry) => entry.kind === 'file' && entry.path.startsWith('documents/'),
-      );
-      const { used, quota } = await this.dash.storage.file.usage();
-      const kept = await this.dash.storage.file.stat(PICTURE);
-      this.setState({
-        songs,
-        archives,
-        documents,
-        usage: `${used} bytes used of ${quota / 1024 / 1024} MB`,
-        picture: kept ? (await this.dash.storage.file.open(PICTURE)).url : '',
-      });
     },
     async save(state) {
-      await this.dash.storage.file.write(`setlist/${Date.now()}.txt`, state.draft);
-      this.setState({ draft: '' });
+      try {
+        await this.dash.storage.file.write(`setlist/${Date.now()}.txt`, state.draft);
+        this.setState({ draft: '', note: '' });
+      } catch (error) {
+        this.setState({ note: errorMessage(error) });
+      }
       await this.actions.refresh();
     },
     // Moves the whole setlist folder into the archive, under the time it was archived.
     async archive() {
-      await this.dash.storage.file.createFolder('archive');
-      await this.dash.storage.file.move('setlist', `archive/${Date.now()}`);
+      try {
+        await this.dash.storage.file.createFolder('archive');
+        await this.dash.storage.file.move('setlist', `archive/${Date.now()}`);
+        this.setState({ note: '' });
+      } catch (error) {
+        this.setState({ note: errorMessage(error) });
+      }
       await this.actions.refresh();
     },
-    // Copies an archived setlist back, in place of the current one.
+    // Copies an archived setlist back, in place of the current one. Without overwrite, a path
+    // that's taken rejects with 'failed'.
     async copyBack(_state, event: DataEvent<{ path: string }>) {
-      await this.dash.storage.file.copy(event.data.path, 'setlist', { overwrite: true });
+      try {
+        await this.dash.storage.file.copy(event.data.path, 'setlist', { overwrite: true });
+        this.setState({ note: '' });
+      } catch (error) {
+        this.setState({ note: errorMessage(error) });
+      }
       await this.actions.refresh();
     },
+    // A folder with files in it needs recursive.
     async clearSetlist() {
-      await this.dash.storage.file.remove('setlist', { recursive: true });
+      try {
+        await this.dash.storage.file.remove('setlist', { recursive: true });
+        this.setState({ note: '' });
+      } catch (error) {
+        this.setState({ note: errorMessage(error) });
+      }
       await this.actions.refresh();
     },
     async forgetPicture() {
-      await this.dash.storage.file.remove(PICTURE);
+      try {
+        await this.dash.storage.file.remove(PICTURE);
+        this.setState({ note: '' });
+      } catch (error) {
+        this.setState({ note: errorMessage(error) });
+      }
       await this.actions.refresh();
     },
   },

package/dist/templates/showcase/pages/dash/files/state.ts

@@ -20,4 +20,5 @@ export default {
   picture: '',
   // Files saved into the dot's documents folder, such as a ticket from the dash.media page.
   documents: [] as FileEntry[],
+  note: '',
 };

package/dist/templates/showcase/pages/dash/files/view.dml

@@ -1,6 +1,6 @@
 <View>
   <Text variant="title">dash.storage.file</Text>
-  <Text>Each dot has its own folder on the phone. Other dots can't see it, and its files stay after the dot closes.</Text>
+  <Text>Each dot has its own folder on the phone. Other dots can't see it, and its files stay after the dot closes. Like the cache and secrets, it isn't backed up, so keep what matters on the dot's server too.</Text>
 
   <View gap="small">
     <Text variant="subtitle">write, read and list</Text>
@@ -75,4 +75,8 @@
     <Text variant="subtitle">usage</Text>
     <Text>{{ usage }}</Text>
   </View>
+
+  <If condition="{{ note }}">
+    <Notice tone="danger">{{ note }}</Notice>
+  </If>
 </View>

package/dist/templates/showcase/pages/dash/media/controller.ts

@@ -6,8 +6,12 @@ import state from './state';
 export default definePage({
   initialState: state,
   configs: { navigationBar: { title: 'Photos, files and scanning' } },
-  // unlessCancelled gives undefined when the person closes the picker or scanner.
+  // Each call here needs a permission in dot.json. Dash asks the person the first time. If dot.json
+  // doesn't list it, or the person says no, the call rejects with 'denied'. unlessCancelled gives
+  // undefined when the person closes the picker or scanner.
   actions: {
+    // Resolves with a DotFile: a JPEG of at most 2048 pixels on its longest side, without its
+    // location. A phone without a camera rejects with 'unsupported'.
     async pickPhoto(_state, event: DataEvent<{ source: PhotoSource }>) {
       try {
         const photo = await unlessCancelled(
@@ -22,6 +26,7 @@ export default definePage({
         this.setState({ note: errorMessage(error) });
       }
     },
+    // A file larger than 25 MB rejects with 'invalid'.
     async pickTicket() {
       try {
         const ticket = await unlessCancelled(
@@ -51,6 +56,7 @@ export default definePage({
         this.setState({ note: errorMessage(error) });
       }
     },
+    // Resolves with { text, format }. Only QR codes for now.
     async scanTicket() {
       try {
         const scanned = await unlessCancelled(this.dash.media.scanCode());

package/dist/templates/showcase/pages/dash/media/state.ts

@@ -1,6 +1,8 @@
 import type { DotFile } from '@monimesl/dot-runtime';
 
 export default {
+  // A DotFile has a name, a size in bytes, a contentType and a url to show it with. It's temporary,
+  // so it goes when the dot closes.
   photo: null as DotFile | null,
   photoDetails: '',
   ticket: null as DotFile | null,

package/dist/templates/showcase/pages/dash/network/controller.ts

@@ -87,6 +87,8 @@ export default definePage({
         this.setState({ connection: errorMessage(error) });
       }
     },
+    // Like fetch, it resolves with any answer, even a 404, so check ok. It rejects only when no
+    // answer comes, and with 'denied' for a host that network.hosts in dot.json doesn't list.
     async searchAsText(state) {
       try {
         const response = await this.dash.network.http.request({
@@ -113,6 +115,7 @@ export default definePage({
       this.setState({ limit: state.limit + PAGE });
       await this.actions.load();
     },
+    // With as: 'json', an answer that isn't JSON rejects with 'failed'.
     async load(state) {
       this.setState({ searching: true, note: '' });
       try {
@@ -153,7 +156,8 @@ export default definePage({
         return;
       }
       try {
-        // The catalog's artwork comes in any size its address names.
+        // Resolves with ok and a temporary file for a 2xx answer of up to 256 MB. The catalog's
+        // artwork comes in any size its address names.
         const response = await this.dash.network.http.download({
           url: release.artwork.replace('100x100bb', '300x300bb'),
           name: 'artwork.jpg',

package/dist/templates/showcase/pages/dash/network/view.dml

@@ -97,7 +97,7 @@
 
   <View gap="small">
     <Text variant="subtitle">Hosts dot.json doesn't list</Text>
-    <Text variant="caption" tone="muted">Dash turns the request down.</Text>
+    <Text variant="caption" tone="muted">Dash turns the request down, with the code denied.</Text>
     <View variant="card" gap="small">
       <Button variant="secondary" onClick="tryUnlistedHost">Reach example.com</Button>
       <If condition="{{ note }}">

package/dist/templates/showcase/pages/dash/payments/cases.ts

@@ -1,4 +1,10 @@
-import type { OrderLineItem, PaymentMethod, PaymentOptions } from '@monimesl/dot-runtime';
+import type {
+  LinkProvider,
+  MomoProvider,
+  OrderLineItem,
+  PaymentMethod,
+  PaymentOptions,
+} from '@monimesl/dot-runtime';
 
 // What the tester sets above the cases.
 export interface CaseInput {
@@ -17,6 +23,8 @@ export interface PaymentCase {
   reusesReference?: boolean;
   // Calls cancel() this long after asking.
   cancelAfterMilliseconds?: number;
+  // Asks a second time while the sheet is open, as a double tap would.
+  asksTwice?: boolean;
 }
 
 export interface CaseGroup {
@@ -26,8 +34,8 @@ export interface CaseGroup {
   cases: PaymentCase[];
 }
 
-// SLE 0.50 a ticket, in minor units as Monime counts money, so trying a case with real money costs
-// little: the two tickets the page starts with come to SLE 1.00.
+// SLE 0.50 a ticket, in minor units as Monime counts money. In Dash the money is real, so the
+// cases cost little: the two tickets the page starts with come to SLE 1.00.
 const TICKET_PRICE = 50;
 const SAMPLE_PHONE_NUMBER = '+23276123456';
 const SAMPLE_ACCOUNT_ID = 'fac-k6VgVTfSmLruHpiQgMg4DUeySZx';
@@ -115,13 +123,13 @@ export const GROUPS: CaseGroup[] = [
         id: 'orange',
         title: 'Orange Money only',
         expect: 'Mobile money with only Orange Money (m17).',
-        options: paying([{ type: 'momo', providers: { include: ['m17'] } }]),
+        options: paying([{ type: 'momo', providers: ['m17'] }]),
       },
       {
         id: 'africell',
         title: 'Africell Money only',
         expect: 'Mobile money with only Africell Money (m18).',
-        options: paying([{ type: 'momo', providers: { include: ['m18'] } }]),
+        options: paying([{ type: 'momo', providers: ['m18'] }]),
       },
       {
         id: 'one-number',
@@ -134,30 +142,30 @@ export const GROUPS: CaseGroup[] = [
           ),
       },
       {
-        id: 'not-a-bank',
-        title: 'Account at any provider but one bank',
-        expect: 'Linked accounts, leaving out slb004.',
-        options: paying([{ type: 'link', providers: { exclude: ['slb004'] } }]),
+        id: 'any-provider',
+        title: 'An empty list of providers',
+        expect: 'Linked accounts at any bank, as an empty list means all of them.',
+        options: paying([{ type: 'link', providers: [] }]),
       },
       {
-        id: 'banks',
-        title: 'Bank accounts only',
-        expect: 'Linked accounts at slb001, slb004 and slb007 only, so no mobile money wallets.',
-        options: paying([{ type: 'link', providers: { include: ['slb001', 'slb004', 'slb007'] } }]),
+        id: 'two-banks',
+        title: 'Accounts at two banks',
+        expect: 'Linked accounts at slb001 and slb009 only.',
+        options: paying([{ type: 'link', providers: ['slb001', 'slb009'] }]),
       },
       {
         id: 'orange-or-account',
         title: 'Orange Money from one number, or an account',
         expect:
-          'Mobile money limited to Orange Money and the number above, then linked accounts but slb004.',
+          'Mobile money limited to Orange Money and the number above, then linked accounts at slb001 only.',
         options: (input, reference) =>
           paying([
             {
               type: 'momo',
-              providers: { include: ['m17'] },
+              providers: ['m17'],
               phoneNumber: input.phoneNumber || SAMPLE_PHONE_NUMBER,
             },
-            { type: 'link', providers: { exclude: ['slb004'] } },
+            { type: 'link', providers: ['slb001'] },
           ])(input, reference),
       },
     ],
@@ -261,6 +269,14 @@ export const GROUPS: CaseGroup[] = [
         options: (input, reference) => jazzNight(reference, [tickets(input)]),
         cancelAfterMilliseconds: 20_000,
       },
+      {
+        id: 'two-at-once',
+        title: 'Two requests at once',
+        expect:
+          'One sheet opens, and it carries on. The second request rejects as denied, shown behind the sheet.',
+        options: (input, reference) => jazzNight(reference, [tickets(input)]),
+        asksTwice: true,
+      },
     ],
   },
   {
@@ -299,7 +315,7 @@ export const GROUPS: CaseGroup[] = [
     id: 'invalid',
     title: 'Refused before Dash',
     subtitle:
-      'Every host checks these the same way, so each rejects as invalid with the same message.',
+      'Every host checks these the same way. Each rejects as invalid, with a message that starts as shown.',
     cases: [
       {
         id: 'no-items',
@@ -399,16 +415,18 @@ export const GROUPS: CaseGroup[] = [
         options: paying([{ type: 'card' }, { type: 'card' }]),
       },
       {
-        id: 'both-filters',
-        title: 'Include and exclude together',
-        expect: "invalid: Give include or exclude for link's providers, not both",
-        options: paying([{ type: 'link', providers: { include: ['m17'], exclude: ['m18'] } }]),
+        id: 'providers-not-a-list',
+        title: 'Providers that are not a list',
+        expect: 'invalid: link\'s providers must be a list of provider IDs, such as ["slb001"]',
+        // The types catch this. The cast gets past them, to show what Dash tells a dot in plain JavaScript.
+        options: paying([{ type: 'link', providers: 'slb001' as unknown as LinkProvider[] }]),
       },
       {
         id: 'unknown-provider',
         title: "A provider Monime doesn't know",
         expect: 'invalid: "m99" isn\'t a provider Monime knows for momo',
-        options: paying([{ type: 'momo', providers: { include: ['m99'] } }]),
+        // The types catch this too.
+        options: paying([{ type: 'momo', providers: ['m99' as unknown as MomoProvider] }]),
       },
       {
         id: 'local-number',

package/dist/templates/showcase/pages/dash/payments/controller.ts

@@ -24,6 +24,7 @@ export default definePage({
     setFinancialAccountId: (_state, event: ValueEvent) => ({
       financialAccountId: event.detail.value.trim(),
     }),
+    clearError: () => ({ error: '' }),
   },
   actions: {
     // data-case names the case to run, from cases.ts.
@@ -51,7 +52,16 @@ export default definePage({
         phoneNumber: state.phoneNumber,
         financialAccountId: state.financialAccountId,
       };
+      // Once the person picks a method, it resolves with how the payment ended: completed,
+      // pending, expired or cancelled. Before that, it rejects with 'cancelled' if the sheet
+      // closes, and with 'invalid' or 'denied' if Monime won't take the order.
       const request = this.dash.payments.request(paymentCase.options(input, reference));
+      if (paymentCase.asksTwice) {
+        // Only one sheet opens at a time, so this rejects as denied and the first carries on.
+        this.dash.payments
+          .request(paymentCase.options(input, `${reference}-again`))
+          .catch((error: unknown) => this.setState({ error: errorOutcome(error) }));
+      }
       const cancelAfter = paymentCase.cancelAfterMilliseconds;
       if (cancelAfter !== undefined) {
         // Runs beside the payment. Cancelling one that already ended does nothing.
@@ -67,6 +77,7 @@ export default definePage({
         this.setState(shownResult(result));
       } catch (error) {
         outcome = errorOutcome(error);
+        this.setState({ error: outcome });
       }
       // Another run may have started meanwhile, so this one names itself again.
       this.setState((current) => ({
@@ -74,9 +85,13 @@ export default definePage({
         runs: added(current.runs, paymentCase.title, outcome),
       }));
     },
+    // get resolves with the payment for a reference, or undefined if there is none.
     async checkPayment(state) {
       const title = 'Check the last payment';
       const found = await lookedUp(this.dash.payments.get(state.reference));
+      if (found.failed) {
+        this.setState({ error: found.outcome });
+      }
       this.setState((current) => ({
         ...found.shown,
         last: { title, expect: '', outcome: found.outcome },
@@ -86,6 +101,9 @@ export default definePage({
     async lookUpUnknown() {
       const title = 'Look up an order that never was';
       const found = await lookedUp(this.dash.payments.get('order-that-never-was'));
+      if (found.failed) {
+        this.setState({ error: found.outcome });
+      }
       this.setState((current) => ({
         last: {
           title,
@@ -102,11 +120,15 @@ async function lookedUp(lookup: Promise<PaymentResult | undefined>) {
   try {
     const result = await lookup;
     if (result === undefined) {
-      return { outcome: 'undefined: there is no payment for this reference', shown: {} };
+      return {
+        outcome: 'undefined: there is no payment for this reference',
+        shown: {},
+        failed: false,
+      };
     }
-    return { outcome: resultOutcome(result), shown: shownResult(result) };
+    return { outcome: resultOutcome(result), shown: shownResult(result), failed: false };
   } catch (error) {
-    return { outcome: errorOutcome(error), shown: {} };
+    return { outcome: errorOutcome(error), shown: {}, failed: true };
   }
 }
 
@@ -114,6 +136,8 @@ function resultOutcome(result: PaymentResult): string {
   return `${result.status} by ${result.method}, ${moneyText(result.amount)}`;
 }
 
+// isDashError(error) is true for an error from a Dash call, so it has a code. Give it codes, such
+// as isDashError(error, 'invalid'), to check for those only.
 function errorOutcome(error: unknown): string {
   if (isDashError(error)) {
     return `${error.code}: ${error.message}`;

package/dist/templates/showcase/pages/dash/payments/state.ts

@@ -30,4 +30,6 @@ export default {
   requestId: '',
   orderNumber: '',
   runs: [] as Run[],
+  // The last error, shown as a toast so it's seen without scrolling to the runs.
+  error: '',
 };

package/dist/templates/showcase/pages/dash/payments/view.dml

@@ -1,6 +1,6 @@
 <View>
   <Text variant="title">dash.payments</Text>
-  <Text>Takes a payment for an order through Dash's own payment sheet. The person picks a linked account, a card or mobile money, and the money goes to the Space that owns the dot. It needs the payments permission in dot.json. Each case below says what should happen. In Dash the money is real, so the orders cost a few cents.</Text>
+  <Text>Takes a payment for an order through Dash's own payment sheet. The person picks a linked account, a card or mobile money, and the money goes to the Space that owns the dot. It needs the payments permission in dot.json, which Dash doesn't ask the person for. Each case below says what should happen. In Dash the money is real, so the orders cost a few cents.</Text>
 
   <View gap="small">
     <Text variant="subtitle">The order</Text>
@@ -68,4 +68,6 @@
       </List>
     </View>
   </If>
+
+  <Toast message="{{ error }}" tone="danger" duration="{{ 6000 }}" onHide="clearError" />
 </View>