yichus 0.3.1 → 0.3.3

package/dist/studio-page/what-happens.js

@@ -41,7 +41,7 @@
 // (poteto) TLA+ diagrams.
 
 import { mark, tg, MIN_LABEL, COLORS as C } from './system-map.js';
-import { walk, leavesOf, pathEffects, allEffects, stationLabel, outcomeLabel, isWriteOp } from './what-happens-record.js';
+import { walk, leavesOf, pathEffects, allEffects, stationLabel, stationDetail, fromWord, outcomeLabel, isWriteOp } from './what-happens-record.js';
 import { SANS, MONO, textWidth, clipText, boxAttr, fitAttr, labelAttr, labelled } from './label-fit.js';
 
 const RED = C.guard, GREEN = '#1f7a45', GREEN_SOFT = '#e4f4ea', RED_SOFT = '#fbe9e7';
@@ -223,9 +223,9 @@ export function renderWhatHappens(record, opts = {}) {
   y = frameTop + (phone ? 18 : 22);
   // the entry rack: the described entries, then one line for the others
   y = rack(record, entry, P, y, out, !!opts.ghosts || opts.open === 'ghosts');
-  // whether a base was compared, always in this place: a fix is then read
-  // off the frame, also when nothing is green
-  y = compared(record, P, y + (phone ? 13 : 15), out);
+  // what a compared base says, in this place: a fix is then read off the
+  // frame, also when nothing is green; with no base, nothing is drawn here
+  if (record.diff) y = compared(record, P, y + (phone ? 13 : 15), out);
   y += phone ? 10 : 14;
   // the entry's own line
   const o = parseOpen(opts.open);
@@ -243,6 +243,13 @@ export function renderWhatHappens(record, opts = {}) {
   }).map(effectKey));
   const x0 = P.pad + (phone ? 6 : 12);
   y = entryHead(entry, root || stepNode, record, P, x0, y, out, opts.open);
+  // entries that take the same steps, on other tables and checks
+  if (entry.sameShape && !root && !stepNode) {
+    const names = entry.sameShape.entries.map(id => id.replace(/^route:/, ''));
+    lines(`same steps as ${names.join(', ')} · on their own tables and checks`, P.fsS, P.W - P.pad - x0 - 12, false, 2)
+      .forEach(l => { out.push(tg([`sameShape:${entry.entry}`], T(x0 + 12, y + P.row * 0.2, l, { size: P.fsS, fill: C.muted, mono: false }))); y += P.row * 0.8; });
+    y += P.row * 0.3;
+  }
   const subject = root ? root.next : stepNode || entry.tree;
   // work beside the wrapper, folded; a wrapper's work after the handler is
   // folded on each path that runs it, just before its outcome
@@ -263,6 +270,35 @@ export function renderWhatHappens(record, opts = {}) {
     y = tree(subject, 0, x0, y, P, out, entry, true);
   }
   y = witnessList(record, entry, subject, P, x0, y + (phone ? 10 : 14), out);
+  // what each table it touches holds, by its checked row type, and then the tables only
+  // the entries with the same steps touch (which this tree stands for), each said to be theirs
+  const touched = new Map();
+  const touch = (es, by) => { for (const e of es || []) for (const tb of e.tables || []) if (!touched.has(tb)) touched.set(tb, by); };
+  for (const e of [entry, ...(entry.sameShape?.entries || []).map(id => record.entries.find(x => x.entry === id)).filter(Boolean)]) {
+    const by = e === entry ? null : e.entry.replace(/^route:/, '');
+    touch(e.effects, by);
+    walk(e === entry ? subject : e.tree, x => { if (!x.kind) touch(x.effects, by); });
+  }
+  for (const [tb, by] of [...touched].filter(([tb]) => record.rows && record.rows[tb])) {
+    for (const l of lines(`${by ? `in ${by}, ` : ''}${tb} holds ${record.rows[tb]}`, P.fsS, P.W - P.pad - x0 - 6, true, 3)) { y += P.row * 0.8; out.push(tg([`rows:${tb}`], T(x0, y, l, { size: P.fsS, fill: C.muted }))); }
+    y += P.row * 0.2;
+  }
+  // the checks it names are the author's labels: what each decides is in its code
+  const library = id => /^(Bosatsu|Yichus)\//.test(id);
+  const namedIds = [];
+  walk(subject, t => { if (t.kind === 'node' && t.from?.kind === 'call' && !library(t.from.callee) && !namedIds.includes(t.from.callee)) namedIds.push(t.from.callee); });
+  const named = [...new Set(namedIds.map(bare))];
+  if (named.length) {
+    const note = `${named.join(', ')}: names the author chose; this shows where each runs, what it is given and what happens when it fails, not what it decides`;
+    for (const l of lines(note, P.fsS, P.W - P.pad - x0 - 6, false, 3)) { y += P.row * 0.8; out.push(tg(['names'], T(x0, y, l, { size: P.fsS, fill: C.muted, mono: false }))); }
+    y += P.row * 0.3;
+  }
+  // what the author wrote above each named check: their words, in italic, not checked
+  for (const id of namedIds.filter(id => record.docs && record.docs[id])) {
+    const said = `${bare(id)}, in its author's comment (unchecked): ${record.docs[id].replace(/\s+/g, ' ')}`;
+    for (const l of lines(said, P.fsS, P.W - P.pad - x0 - 6, false, 3)) { y += P.row * 0.8; out.push(tg([`docs:${id}`], T(x0, y, l, { size: P.fsS, fill: C.muted, mono: false, italic: true }))); }
+    y += P.row * 0.2;
+  }
   const H = Math.ceil(y + (phone ? 10 : 16));
   const frame = labelled('frame', `<rect x="2.5" y="${frameTop}" width="${W - 5}" height="${H - frameTop - 3}" rx="10" fill="none" stroke="${C.frame}" stroke-width="1"/>` +
     `<text x="14" y="${frameTop + 4}" font-family="${SANS}" font-size="${phone ? 9 : 10}" font-weight="600" fill="${C.muted}" stroke="${C.page}" stroke-width="6" paint-order="stroke">Yichus output</text>`);
@@ -277,6 +313,12 @@ function rack(record, selected, P, y, out, expanded) {
   const x0 = pad + (phone ? 6 : 12);
   let x = x0, yy = y;
   const ghosts = record.entries.filter(e => !e.described);
+  // no entry described: one line that opens to list them all
+  if (ghosts.length === record.entries.length && !expanded) {
+    const n = ghosts.length, text = `${n} ${n === 1 ? 'entry' : 'entries'}`;
+    out.push(tg([`ghosts:${n}`], `<g data-ghosts="folded"${opener('ghosts', `Show the ${n} entries no scenario describes`)}>${title(`${n} entries no scenario describes`)}${ghostHead(x, yy)}${T(x + 11, yy, text, { size: fs, fill: C.muted, mono: false })}</g>`));
+    return yy + 4;
+  }
   out.push(T(x, yy, ghosts.length ? `entries · ${record.entries.length - ghosts.length} of ${record.entries.length} described by a scenario` : `entries · every one described`,
     { size: fs, fill: C.muted, mono: false }));
   yy += lh;
@@ -315,10 +357,6 @@ function rack(record, selected, P, y, out, expanded) {
 }
 function compared(record, P, y, out) {
   const x = P.pad + (P.phone ? 6 : 12), d = record.diff;
-  if (!d) {
-    out.push(tg(['compared:none'], `<g${labelAttr('compared')}>${title('no earlier version of the program was compared, so nothing here says what was fixed')}${T(x, y, 'no base compared', { size: P.fsS, fill: C.faint, mono: false })}</g>`));
-    return y + 4;
-  }
   const parts = [[`compared with ${d.base}`, C.muted, null], [`${d.fixed.length} fixed`, d.fixed.length ? GREEN : C.muted, 600], [`${d.stillRed.length} still failing`, d.stillRed.length ? RED : C.muted, 600]];
   if (d.unresolved.length) parts.push([`${d.unresolved.length} no longer checked`, C.muted, 600]);
   if (d.goneAtHead.length) parts.push([`${d.goneAtHead.length} gone with ${d.goneAtHead.length === 1 ? 'its entry' : 'their entries'}`, C.muted, null]);
@@ -370,13 +408,25 @@ function stations(effects, x, y, P, out, key) {
     const text = stationLabel(e) + (isCore(e) ? '' : ` · ${e.phase === 'after' ? `after the handler${whose}${after ? (after.everyPath ? ' · on every path that runs it' : ' · not on every path that runs it') : ''}` : e.layer === 'beside' ? 'beside the wrapper' : `before the handler${whose}`}`);
     const where = `${text} in ${String(e.site).split('::').pop()}${e.line ? `, line ${e.line}` : ''}`;
     const rows = lines(text, P.fsS, P.W - P.pad - x - r - 10, true, 2);
-    out.push(tg([`effect:${key}:${e.op}:${e.tables.join(',')}`], `<g data-layer="${e.layer || 'core'}">${title(where)}${ring}${rows.map((l, i) => T(x + r + 6 + (i ? 8 : 0), cy + 3.5 + i * P.row * 0.8, l, { size: P.fsS, fill: isCore(e) ? color : C.hullInk })).join('')}</g>`));
-    if (rows.length > 1) out.push(line(x, cy, x, cy + P.row * 1.2));
-    y = cy + P.row * 0.6 + (rows.length - 1) * P.row * 0.8;
+    // the row it touches and where what it writes comes from, under the label
+    // (measured at the size it is drawn at: never below the smallest label)
+    const dsz = Math.max(MIN_LABEL, P.fsS - 1);
+    const detail = stationDetail(e), more = detail ? lines(detail, dsz, P.W - P.pad - x - r - 18, true, 2) : [];
+    const all = [...rows.map(l => [l, P.fsS, isCore(e) ? color : C.hullInk]), ...more.map(l => [l, dsz, C.muted])];
+    out.push(tg([`effect:${key}:${e.op}:${e.tables.join(',')}`], `<g data-layer="${e.layer || 'core'}">${title(detail ? `${where}: ${detail}` : where)}${ring}${all.map(([l, size, fill], i) => T(x + r + 6 + (i ? 8 : 0), cy + 3.5 + i * P.row * 0.8, l, { size, fill })).join('')}</g>`));
+    if (all.length > 1) out.push(line(x, cy, x, cy + P.row * (0.6 + (all.length - 1) * 0.8)));
+    y = cy + P.row * 0.6 + (all.length - 1) * P.row * 0.8;
   }
   return y;
 }
 
+const forkSources = t => {
+  const f = t.from || {};
+  if (f.kind === 'call' || f.kind === 'derived') return (f.sources || []).map(fromWord).join(', ') || null;
+  if (f.kind === 'read') return f.op === 'mint id' ? 'new id' : `${f.table || bare(f.primitive)} as read`;
+  if (f.kind === 'request' || f.kind === 'caller') return [f.kind, ...(f.path || [])].join('.');
+  return null;
+};
 // One subtree from (x, y) down. Returns the y where it ends.
 // A folded step: one shaded box on the line (the map's hull), its role,
 // what it answers instead of running the handler, and its effects.
@@ -467,9 +517,18 @@ function tree(t, depth, x, y, P, out, entry, top) {
     out.push(tg([`words:${t.id}`], `<g>${title(`${t.test} (${t.key})`)}${T(lx, yy, clip(t.words, P.fs, room, false, 400, true), { size: P.fs, italic: true, mono: false, fill: crossNode ? C.hullInk : C.ink })}</g>`));
     if (!P.phone) out.push(T(lx + Math.min(room, width(clip(t.words, P.fs, room, false, 400, true), P.fs, false, 400, true)) + 8, yy, clip(t.test, P.fsS, Math.max(0, room - width(t.words, P.fs, false, 400, true) - 10)), { size: P.fsS, fill: C.faint }));
   } else {
-    for (const [i, l] of lines(t.test, P.fs, room, !guard, 2, guard ? 600 : 400).entries())
+    const rows = lines(t.test, P.fs, room, !guard, 2, guard ? 600 : 400);
+    for (const [i, l] of rows.entries())
       out.push(T(lx, yy + i * P.row * 0.85, l, { size: P.fs, mono: !guard, fill: guard ? RED : crossNode ? C.hullInk : C.ink2, weight: guard ? 600 : null }));
-    if (width(t.test, P.fs, !guard, guard ? 600 : 400) > room) yy += P.row * 0.85;
+    if (rows.length > 1) yy += P.row * 0.85;
+    // what the branch tests comes from: the request, the caller, a read
+    const src = forkSources(t);
+    if (src) {
+      const after = width(rows[rows.length - 1], P.fs, !guard, guard ? 600 : 400) + 8, left = room - after;
+      const text = `← ${src}`;
+      if (width(text, P.fsS, true) <= left) out.push(T(lx + after, yy, text, { size: P.fsS, fill: C.muted }));
+      else { yy += P.row * 0.8; out.push(T(lx, yy, clip(text, P.fsS, room), { size: P.fsS, fill: C.muted })); }
+    }
   }
   y = yy + P.row * 0.35;
   // the spine continues straight down: the arm that reaches the main

package/dist/studio-reference/refund-desk-one-round.bosatsu

@@ -20,7 +20,7 @@ from Yichus/IO import IO, flat_map, pure
 from Yichus/Access import Principal, AccessRule, AccessSpec, OwnerScoped, owner_key
 from Yichus/Data import Db
 from Yichus/Service import Reply, Done, Invalid, NotFound, Refused as Turned, TryAgain, handler, route, service_def, ReadPerm, WritePerm, CreatePerm
-from Yichus/Transaction import Scope, TxTable, Txn, Committed, transaction, replied, tx_table, tx_bind, tx_pure, tx_read, tx_write, tx_insert, tx_new_token
+from Yichus/Transaction import TxTable, Txn, Committed, transaction, replied, stored_table, tx_bind, tx_pure, tx_read, tx_write, tx_insert, tx_new_token
 from Yichus/OpenRouter import ProviderPolicy, ModelRequest, ModelResult, Completed, Refused, RetryableFailure, PermanentFailure, TimedOut, openrouter_call
 from Yichus/Json import JsonObject, JsonString, JsonArray, JsonBool, Parsed, InvalidJson, Rendered, RenderError, Decoded, DecodeError, parse_json, render_json, decode_bind, required_field, as_bool
 from Zafu/Control/IterState import IterState, Continue, Done as Finished
@@ -53,34 +53,33 @@ access_rules = AccessSpec([
   AccessRule("refunds", OwnerScoped),
 ])
 
-def cases[s](scope: Scope[s]) -> TxTable[s, Case]: tx_table(scope, "refunds")
+cases: TxTable[s, Case] = stored_table("refunds")
 
 # Open the order's refund, unless it already has one.
-def open_plan[s](scope: Scope[s], key: String, refund: Refund) -> Txn[s, RefundError, Unit]:
-  reference <- tx_bind(tx_new_token(scope))
-  tx_insert(cases(scope), key, Case(reference, 0, refund, [], None))
+def open_plan[s](key: String, refund: Refund, reference: String) -> Txn[s, RefundError, Unit]:
+  tx_insert(cases, key, Case(reference, 0, refund, [], None))
 
-def read_plan[s](scope: Scope[s], key: String) -> Txn[s, RefundError, Option[Case]]:
-  tx_read(cases(scope), key)
+def read_plan[s](key: String) -> Txn[s, RefundError, Option[Case]]:
+  tx_read(cases, key)
 
 # Append an exchange to an undecided case, or decide it, only if its
 # version is still the one the round read; either raises the version.
-def append_plan[s](scope: Scope[s], key: String, seen: Int, exchange: Exchange) -> Txn[s, RefundError, Bool]:
-  found <- tx_bind(tx_read(cases(scope), key))
+def append_plan[s](key: String, seen: Int, exchange: Exchange) -> Txn[s, RefundError, Bool]:
+  found <- tx_bind(tx_read(cases, key))
   match found:
     case Some(Case(reference, version, refund, record, None)):
       if eq_Int(version, seen):
-        _ <- tx_bind(tx_write(cases(scope), key, Case(reference, version.add(1), refund, record.concat([exchange]), None)))
+        _ <- tx_bind(tx_write(cases, key, Case(reference, version.add(1), refund, record.concat([exchange]), None)))
         tx_pure(True)
       else: tx_pure(False)
     case _: tx_pure(False)
 
-def decide_plan[s](scope: Scope[s], key: String, seen: Int, decision: Decision) -> Txn[s, RefundError, Bool]:
-  found <- tx_bind(tx_read(cases(scope), key))
+def decide_plan[s](key: String, seen: Int, decision: Decision) -> Txn[s, RefundError, Bool]:
+  found <- tx_bind(tx_read(cases, key))
   match found:
     case Some(Case(reference, version, refund, record, None)):
       if eq_Int(version, seen):
-        _ <- tx_bind(tx_write(cases(scope), key, Case(reference, version.add(1), refund, record, Some(decision))))
+        _ <- tx_bind(tx_write(cases, key, Case(reference, version.add(1), refund, record, Some(decision))))
         tx_pure(True)
       else: tx_pure(False)
     case _: tx_pure(False)
@@ -139,20 +138,20 @@ def request_refund(db: Db, p: Principal, refund: Refund) -> IO[Reply[RefundError
   # carries on with the stored refund; a different one for the same order
   # is turned away.
   def round(_: Unit, _: Int) -> IO[IterState[Unit, Reply[RefundError, Decision]]]:
-    found <- flat_map(transaction(db, scope -> read_plan(scope, key)))
+    found <- flat_map(transaction(db, _ -> read_plan(key)))
     match found:
       case Committed(Some(Case(reference, seen, stored, record, decided))):
         if same_refund(stored, refund):
           match (decided, replay(stored, record)):
             case (Some(decision), _): pure(Finished(Done(decision)))
             case (None, Some(Ruled(decision))):
-              saved <- flat_map(transaction(db, scope -> decide_plan(scope, key, seen, decision)))
+              saved <- flat_map(transaction(db, _ -> decide_plan(key, seen, decision)))
               match saved:
                 case Committed(True): pure(Finished(Done(decision)))
                 case _: pure(Continue(()))
             case (None, Some(Perform(request))):
               answer <- flat_map(perform(reference, length_List(record), request))
-              _ <- flat_map(transaction(db, scope -> append_plan(scope, key, seen, Exchange(request, answer))))
+              _ <- flat_map(transaction(db, _ -> append_plan(key, seen, Exchange(request, answer))))
               pure(Continue(()))
             case (None, None): pure(Finished(Turned("this refund's record cannot be read back", Unreadable)))
         else: pure(Finished(Turned("this order already has a refund request for another amount or reason", AlreadyRequested)))
@@ -160,7 +159,11 @@ def request_refund(db: Db, p: Principal, refund: Refund) -> IO[Reply[RefundError
       # The store was busy: read again next round.
       case _: pure(Continue(()))
   def decide():
-    opened <- flat_map(transaction(db, scope -> open_plan(scope, key, refund)))
+    def open_case():
+      scope <- transaction(db)
+      reference <- tx_bind(tx_new_token(scope))
+      open_plan(key, refund, reference)
+    opened <- flat_map(open_case())
     match opened:
       case Committed(_):
         ended <- flat_map(round((), 0))
@@ -177,7 +180,7 @@ def request_refund(db: Db, p: Principal, refund: Refund) -> IO[Reply[RefundError
 
 def refund_status(db: Db, p: Principal, input: StatusRequest) -> IO[Reply[RefundError, RefundView]]:
   StatusRequest(order) = input
-  found <- flat_map(transaction(db, scope -> read_plan(scope, owner_key(p, order))))
+  found <- flat_map(transaction(db, _ -> read_plan(owner_key(p, order))))
   pure(replied(found,
     c -> (
       match c:

package/dist/studio-reference/refund-desk.bosatsu

@@ -14,7 +14,7 @@ from Yichus/IO import IO, flat_map, pure, fold_until
 from Yichus/Access import Principal, AccessRule, AccessSpec, OwnerScoped, owner_key
 from Yichus/Data import Db
 from Yichus/Service import Reply, Done, Invalid, NotFound, Refused as Turned, TryAgain, handler, route, service_def, ReadPerm, WritePerm, CreatePerm
-from Yichus/Transaction import Scope, TxTable, Txn, Committed, transaction, replied, tx_table, tx_bind, tx_pure, tx_read, tx_write, tx_insert, tx_new_token
+from Yichus/Transaction import TxTable, Txn, Committed, transaction, replied, stored_table, tx_bind, tx_pure, tx_read, tx_write, tx_insert, tx_new_token
 from Yichus/OpenRouter import ProviderPolicy, ModelRequest, ModelResult, Completed, Refused, RetryableFailure, PermanentFailure, TimedOut, openrouter_call
 from Yichus/Json import JsonObject, JsonString, JsonArray, JsonBool, Parsed, InvalidJson, Rendered, RenderError, Decoded, DecodeError, parse_json, render_json, decode_bind, required_field, as_bool
 from Zafu/Control/IterState import IterState, Continue, Done as Finished
@@ -47,34 +47,33 @@ access_rules = AccessSpec([
   AccessRule("refunds", OwnerScoped),
 ])
 
-def cases[s](scope: Scope[s]) -> TxTable[s, Case]: tx_table(scope, "refunds")
+cases: TxTable[s, Case] = stored_table("refunds")
 
 # Open the order's refund, unless it already has one.
-def open_plan[s](scope: Scope[s], key: String, refund: Refund) -> Txn[s, RefundError, Unit]:
-  reference <- tx_bind(tx_new_token(scope))
-  tx_insert(cases(scope), key, Case(reference, 0, refund, [], None))
+def open_plan[s](key: String, refund: Refund, reference: String) -> Txn[s, RefundError, Unit]:
+  tx_insert(cases, key, Case(reference, 0, refund, [], None))
 
-def read_plan[s](scope: Scope[s], key: String) -> Txn[s, RefundError, Option[Case]]:
-  tx_read(cases(scope), key)
+def read_plan[s](key: String) -> Txn[s, RefundError, Option[Case]]:
+  tx_read(cases, key)
 
 # Append an exchange to an undecided case, or decide it, only if its
 # version is still the one the round read; either raises the version.
-def append_plan[s](scope: Scope[s], key: String, seen: Int, exchange: Exchange) -> Txn[s, RefundError, Bool]:
-  found <- tx_bind(tx_read(cases(scope), key))
+def append_plan[s](key: String, seen: Int, exchange: Exchange) -> Txn[s, RefundError, Bool]:
+  found <- tx_bind(tx_read(cases, key))
   match found:
     case Some(Case(reference, version, refund, record, None)):
       if eq_Int(version, seen):
-        _ <- tx_bind(tx_write(cases(scope), key, Case(reference, version.add(1), refund, record.concat([exchange]), None)))
+        _ <- tx_bind(tx_write(cases, key, Case(reference, version.add(1), refund, record.concat([exchange]), None)))
         tx_pure(True)
       else: tx_pure(False)
     case _: tx_pure(False)
 
-def decide_plan[s](scope: Scope[s], key: String, seen: Int, decision: Decision) -> Txn[s, RefundError, Bool]:
-  found <- tx_bind(tx_read(cases(scope), key))
+def decide_plan[s](key: String, seen: Int, decision: Decision) -> Txn[s, RefundError, Bool]:
+  found <- tx_bind(tx_read(cases, key))
   match found:
     case Some(Case(reference, version, refund, record, None)):
       if eq_Int(version, seen):
-        _ <- tx_bind(tx_write(cases(scope), key, Case(reference, version.add(1), refund, record, Some(decision))))
+        _ <- tx_bind(tx_write(cases, key, Case(reference, version.add(1), refund, record, Some(decision))))
         tx_pure(True)
       else: tx_pure(False)
     case _: tx_pure(False)
@@ -137,20 +136,20 @@ def request_refund(db: Db, p: Principal, refund: Refund) -> IO[Reply[RefundError
   # carries on with the stored refund; a different one for the same order
   # is turned away.
   def round(_: Unit, _: Int) -> IO[IterState[Unit, Reply[RefundError, Decision]]]:
-    found <- flat_map(transaction(db, scope -> read_plan(scope, key)))
+    found <- flat_map(transaction(db, _ -> read_plan(key)))
     match found:
       case Committed(Some(Case(reference, seen, stored, record, decided))):
         if same_refund(stored, refund):
           match (decided, replay(stored, record)):
             case (Some(decision), _): pure(Finished(Done(decision)))
             case (None, Some(Ruled(decision))):
-              saved <- flat_map(transaction(db, scope -> decide_plan(scope, key, seen, decision)))
+              saved <- flat_map(transaction(db, _ -> decide_plan(key, seen, decision)))
               match saved:
                 case Committed(True): pure(Finished(Done(decision)))
                 case _: pure(Continue(()))
             case (None, Some(Perform(request))):
               answer <- flat_map(perform(reference, length_List(record), request))
-              _ <- flat_map(transaction(db, scope -> append_plan(scope, key, seen, Exchange(request, answer))))
+              _ <- flat_map(transaction(db, _ -> append_plan(key, seen, Exchange(request, answer))))
               pure(Continue(()))
             case (None, None): pure(Finished(Turned("this refund's record cannot be read back", Unreadable)))
         else: pure(Finished(Turned("this order already has a refund request for another amount or reason", AlreadyRequested)))
@@ -158,7 +157,11 @@ def request_refund(db: Db, p: Principal, refund: Refund) -> IO[Reply[RefundError
       # The store was busy: read again next round.
       case _: pure(Continue(()))
   def decide():
-    opened <- flat_map(transaction(db, scope -> open_plan(scope, key, refund)))
+    def open_case():
+      scope <- transaction(db)
+      reference <- tx_bind(tx_new_token(scope))
+      open_plan(key, refund, reference)
+    opened <- flat_map(open_case())
     match opened:
       case Committed(_):
         ended <- flat_map(fold_until(range(rounds), (), round))
@@ -175,7 +178,7 @@ def request_refund(db: Db, p: Principal, refund: Refund) -> IO[Reply[RefundError
 
 def refund_status(db: Db, p: Principal, input: StatusRequest) -> IO[Reply[RefundError, RefundView]]:
   StatusRequest(order) = input
-  found <- flat_map(transaction(db, scope -> read_plan(scope, owner_key(p, order))))
+  found <- flat_map(transaction(db, _ -> read_plan(owner_key(p, order))))
   pure(replied(found,
     c -> (
       match c:

package/dist/studio-reference/withdrawal.bosatsu

@@ -27,7 +27,7 @@ from Yichus/Service import (
 )
 from Yichus/Transaction import (
   Scope, TxTable, Txn, Outcome,
-  tx_table, tx_pure, tx_bind, tx_abort, tx_read, tx_write, tx_insert,
+  stored_table, tx_pure, tx_bind, tx_abort, tx_read, tx_write, tx_insert,
   tx_database_time_millis, transaction
 )
 
@@ -159,11 +159,9 @@ access_rules = AccessSpec([
   AccessRule("withdrawal_receipts", OwnerScoped),
 ])
 
-def accounts_table[s](scope: Scope[s]) -> TxTable[s, Account]:
-  tx_table(scope, "accounts")
+accounts_table: TxTable[s, Account] = stored_table("accounts")
 
-def receipts_table[s](scope: Scope[s]) -> TxTable[s, Receipt]:
-  tx_table(scope, "withdrawal_receipts")
+receipts_table: TxTable[s, Receipt] = stored_table("withdrawal_receipts")
 
 def account_rows(db: Db) -> Table[Account]:
   table(db, "accounts")
@@ -178,12 +176,11 @@ def receipt_rows(db: Db) -> Table[Receipt]:
 # ---------------------------------------------------------------------------
 
 def move_balance[s](
-  scope: Scope[s],
   principal: Principal,
   delta: Int
 ) -> Txn[s, LedgerError, Movement]:
   Principal(uid, _) = principal
-  row <- tx_bind(tx_read(accounts_table(scope), uid))
+  row <- tx_bind(tx_read(accounts_table, uid))
   match row:
     case None: tx_abort(UnknownAccount(uid))
     case Some(Account(id, owner, balance)):
@@ -191,7 +188,7 @@ def move_balance[s](
       if int_lt(next, 0):
         tx_abort(InsufficientFunds(balance, sub(0, delta)))
       else:
-        _ <- tx_bind(tx_write(accounts_table(scope), uid, Account(id, owner, next)))
+        _ <- tx_bind(tx_write(accounts_table, uid, Account(id, owner, next)))
         tx_pure(Movement(balance, next))
 
 # ---------------------------------------------------------------------------
@@ -207,7 +204,7 @@ def withdraw_plan[s](
     case Some(error): tx_abort(error)
     case None:
       key = owner_key(principal, command_local_key(input))
-      previous <- tx_bind(tx_read(receipts_table(scope), key))
+      previous <- tx_bind(tx_read(receipts_table, key))
       match previous:
         case Some(receipt): tx_pure(receipt)
         case None:
@@ -215,17 +212,16 @@ def withdraw_plan[s](
           if int_lt(now, 0): tx_abort(InvalidDatabaseTime(now))
           else:
             WithdrawInput(_, amount) = input
-            moved <- tx_bind(move_balance(scope, principal, sub(0, amount)))
+            moved <- tx_bind(move_balance(principal, sub(0, amount)))
             Movement(_, after) = moved
             receipt = Receipt(input, after, now)
-            _ <- tx_bind(tx_insert(receipts_table(scope), key, receipt))
+            _ <- tx_bind(tx_insert(receipts_table, key, receipt))
             # The receipt filed in the ledger and the receipt in the
             # response are one value, so the customer's copy and the
             # bank's copy cannot say different things.
             tx_pure(receipt)
 
 def deposit_plan[s](
-  scope: Scope[s],
   principal: Principal,
   input: DepositInput
 ) -> Txn[s, LedgerError, Movement]:
@@ -233,7 +229,7 @@ def deposit_plan[s](
     case Some(error): tx_abort(error)
     case None:
       DepositInput(_, amount) = input
-      move_balance(scope, principal, amount)
+      move_balance(principal, amount)
 
 # ---------------------------------------------------------------------------
 # Handlers. The engine injects Db and Principal; nothing here
@@ -253,8 +249,8 @@ def deposit(
   principal: Principal,
   input: DepositInput
 ) -> IO[Outcome[LedgerError, Movement]]:
-  scope <- transaction(db)
-  deposit_plan(scope, principal, input)
+  _ <- transaction(db)
+  deposit_plan(principal, input)
 
 def withdrawal_status(
   db: Db,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yichus",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Local Bosatsu compilation, Yichus analysis, and generated apps using the WebMCP engine",
   "license": "MIT",
   "homepage": "https://yich.us",
@@ -20,7 +20,7 @@
   "dependencies": {
     "zod": "^4.3.6",
     "@modelcontextprotocol/sdk": "^1.26.0",
-    "@yichus/api-mcp": "0.1.3"
+    "@yichus/api-mcp": "0.1.5"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",