yichus 0.3.1 → 0.3.2

package/dist/studio-page/system-map.js

@@ -440,7 +440,7 @@ function renderService(map, W, opts) {
   // path that takes two lines lifts the row.
   const roleText = e => [...new Set(e.members.flatMap(m => m.roles))].map(r => dense && rolePrefix ? r.slice(rolePrefix.length) : r).join(', ');
   // the lines a fork's types take from x to end (none when not even a letter fits: then they are its tooltip)
-  const forkLines = (types, room) => (!types.length || dense ? [] : room < tw(`${types.join(',')[0]}…`, fsS) ? [''] : wrapped(types.join(','), room, { size: fsS }));
+  const forkLines = (types, room) => (dense ? [] : forkTypeLines(types, room, fsS));
   const gapL = lineGap(fs);
   const titleSz = phone ? 9.5 : 10.5;
   // a hull's name over its first row, on as many lines as the gap between risers takes
@@ -1227,9 +1227,26 @@ function wallPathGaps(x0, x1, yTop, yBot, openings, r = 14) {
 // line; each package is a stretch starting with a tick and its name; the
 // parts' labels alternate above and below the line so it never wraps at
 // phone width. A package with many forks draws one fork with a count.
+// The lines a fork's types take in `room` at `size`: none for no types, one
+// empty line when not even a letter fits (the types are then its tooltip).
+// Lines break between types, so a long list keeps its lines, a type too
+// long for a line clipped where the line ends. Only a type broken mid-word
+// across lines (a line that ends inside a type) with the rest clipped puts
+// the types on one line, clipped.
+export function forkTypeLines(types, room, size) {
+  const s = types.join(',');
+  if (!types.length) return [];
+  if (room < tw(`${s[0]}…`, size)) return [''];
+  const ls = wrapped(s, room, { size });
+  const brokenMidWord = ls.slice(0, -1).some(l => !l.endsWith(',')) && ls.slice(1).some(l => l.endsWith('…'));
+  return brokenMidWord ? [clip(s, size, room)] : ls;
+}
+
 // A gathered mark's count, said in words: what it counts, never a bare ×n.
 const SET_WORDS = { forkset: ['choice', 'choices'], dbset: ['db use', 'db uses'], genset: ['generic part', 'generic parts'], stepset: ['step', 'steps'] };
 export const setWord = (kind, n) => `${n} ${SET_WORDS[kind][n === 1 ? 0 : 1]}`;
+// a db use off every path whose handle is handed in on some paths only: a ? beside its station
+const strayUnknown = (x, y, phone) => mark.unknown(x + (phone ? 6 : 7.5), y - (phone ? 6 : 7.5), phone ? 3.6 : 4.4);
 
 export function quietItems(map, placed, { services = false, dense = false, phone = false, drawn = new Set(), socketFns = new Map(), genericById = new Map(), exportsLeft = [], strays = [] } = {}) {
   const pkgOf = id => String(id).split('::')[0];
@@ -1250,7 +1267,8 @@ export function quietItems(map, placed, { services = false, dense = false, phone
   for (const u of strays) { const p = pkgOf(u.definition); pk(p); if (!strayBy.has(p)) strayBy.set(p, []); strayBy.get(p).push(u); }
   for (const [p, us] of strayBy) {
     const defs = [...new Set(us.map(u => u.definition))];
-    P.get(p).parts.push({ kind: 'dbset', label: defs.length === 1 && !dense ? bare(defs[0]) : setWord('dbset', defs.length), n: defs.length, writes: us.some(u => u.writes), keys: us.map(u => `use:${u.i}`) });
+    const mixed = us.filter(u => u.how === 'mixed');
+    P.get(p).parts.push({ kind: 'dbset', label: defs.length === 1 && !dense ? bare(defs[0]) : setWord('dbset', defs.length), n: defs.length, writes: us.some(u => u.writes), mixed: mixed.length > 0, keys: [...us.map(u => `use:${u.i}`), ...mixed.map(u => `unknown:${u.i}`)] });
   }
   // forks (and bare generic parts) of one package gathered under one mark with a count when the line would be long
   const total = [...list.values()].reduce((n, l) => n + l.length, 0);
@@ -1277,7 +1295,7 @@ export function quietItems(map, placed, { services = false, dense = false, phone
   const forks = of('forkset'), dbs = of('dbset'), others = all.filter(it => !forks.includes(it) && !dbs.includes(it));
   const n = list => list.reduce((c, it) => c + (it.n || 1), 0);
   if (forks.length) parts.push({ kind: 'forkset', label: setWord('forkset', n(forks)), n: n(forks), fork: [...new Set(forks.flatMap(it => it.fork))], keys: forks.flatMap(it => it.keys) });
-  if (dbs.length) parts.push({ kind: 'dbset', label: setWord('dbset', n(dbs)), n: n(dbs), writes: dbs.some(it => it.writes), keys: dbs.flatMap(it => it.keys) });
+  if (dbs.length) parts.push({ kind: 'dbset', label: setWord('dbset', n(dbs)), n: n(dbs), writes: dbs.some(it => it.writes), mixed: dbs.some(it => it.mixed), keys: dbs.flatMap(it => it.keys) });
   parts.push(...others);
   if (steps.length) parts.push({ kind: 'stepset', label: setWord('stepset', steps.length), n: steps.length, keys: steps.map(st => `step:${st.pkg}:${st.type}`) });
   return [{ pkg: '', exports: [], steps: [], parts, gathered: groups.length }];
@@ -1390,6 +1408,7 @@ function angledQuiet(pkgs, lsx, lex, y0, phone, fsS) {
     g.parts.forEach((it, i) => {
       const x = xs[i];
       let gg = it.kind === 'forkset' ? mark.fork(x - (phone ? 3 : 4), ry, phone ? 0.7 : 0.85) : it.kind === 'dbset' ? mark.station(x, ry, phone ? 3.6 : 4.6, it.writes) : it.socket ? mark.socket(x, ry, phone ? 4.2 : 5.4) : mark.dot(x, ry, phone ? 2.8 : 3.4);
+      if (it.mixed) gg += strayUnknown(x, ry, phone);
       if (it.fork) gg += mark.fork(x + 1, ry - (phone ? 7 : 9), phone ? 0.5 : 0.6);
       gg += rot(x + 2, ry - (phone ? 12 : 15), -ang, ups.get(it));
       over.push(tg(it.keys, gg));
@@ -1468,7 +1487,7 @@ export function layoutQuiet(pkgs, lsx, lex, y0, phone, fsS0, bands = []) {
         // a step set's count starts past its loop's arrowhead
         let gg = '', tx = it.kind === 'stepset' ? x + (phone ? 6 : 8) : x - 3;
         if (it.kind === 'forkset') gg += mark.fork(x - (phone ? 3 : 4), ry, phone ? 0.75 : 0.9);
-        else if (it.kind === 'dbset') gg += mark.station(x, ry, phone ? 3.6 : 4.6, it.writes);
+        else if (it.kind === 'dbset') gg += mark.station(x, ry, phone ? 3.6 : 4.6, it.writes) + (it.mixed ? strayUnknown(x, ry, phone) : '');
         else if (it.kind === 'stepset') gg += mark.loop(x, ry - 0.5, phone ? 4.2 : 5.4);
         else if (it.socket) gg += mark.socket(x, ry, phone ? 4.6 : 6);
         else gg += mark.dot(x, ry, phone ? 3 : 3.8);

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.2",
   "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.4"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",