@nano133/nanoterra 0.14.0 → 0.14.1

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.14.1 (2026-11-03)
+
+- **The shop's Firestore adapter: a lost race is the next amount, never an error.** When many buyers of one price order at the same instant, they all race
+  for one amount's document, and Firestore retries the losers. A loser that lost on every attempt got ABORTED (gRPC code 10), and `insert` let it through:
+  `reserveOrder` threw a raw Firestore error, not the next amount and not `ShopBusy`. `insert` now answers an ABORTED (code `10`, or the web SDK's
+  `"aborted"`) as "taken": an aborted transaction wrote nothing, so the order goes on to the next amount, and `ShopBusy` comes after the last one. Any other
+  error still goes to the caller. Found by the conformance case "25 at the same instant" on the Firestore emulator (about 1 run in 6 failed). New tests: the
+  adapter on the fake with an injected ABORTED, and on the emulator a burst of 25 at once that counts the ABORTED answers.
+
 ## 0.14.0 (2026-11-02)
 
 - **"Free play" in /admin (Wes, 2026-11-02):** the Game card's fifth setting, a switch, On by default. Off says that the game has no free play: a player must pay in

package/dist/shop/adapters/firestore.js

@@ -20,6 +20,11 @@ const text = (v, fallback = "") => (typeof v === "string" ? v : fallback);
 const num = (v, fallback = 0) => (typeof v === "number" && Number.isFinite(v) ? v : fallback);
 const orNull = (v) => (typeof v === "string" ? v : null);
 const STATUSES = ["open", "paid", "expired", "paid_late"];
+/** A transaction that lost to other ones on every attempt: the Admin SDK's gRPC code 10, or the web SDK's "aborted". */
+const aborted = (e) => {
+    const code = e?.code;
+    return code === 10 || code === "aborted";
+};
 function orderOf(id, d) {
     return {
         id,
@@ -110,14 +115,23 @@ export function createFirestoreShop(db, collections = {}) {
         async insert(o) {
             const lockRef = col("amounts").doc(o.amount);
             const orderRef = col("orders").doc(o.id);
-            return db.runTransaction(async (tx) => {
-                const [lock, order] = [await tx.get(lockRef), await tx.get(orderRef)];
-                if (lock.exists || order.exists)
+            try {
+                return await db.runTransaction(async (tx) => {
+                    const [lock, order] = [await tx.get(lockRef), await tx.get(orderRef)];
+                    if (lock.exists || order.exists)
+                        return false;
+                    tx.set(lockRef, { orderId: o.id, holdUntil: o.holdUntil });
+                    tx.set(orderRef, dataOf({ ...o, amountLock: o.amount, status: "open", hash: null, payer: null, paidAt: null }));
+                    return true;
+                });
+            }
+            catch (e) {
+                // Many buyers of one price at the same instant all race for one amount's document. Firestore retries the losers, and one that loses on every
+                // attempt gets ABORTED. An aborted transaction wrote nothing, so it is "taken": reserveOrder goes on to the next amount (ShopBusy after the last).
+                if (aborted(e))
                     return false;
-                tx.set(lockRef, { orderId: o.id, holdUntil: o.holdUntil });
-                tx.set(orderRef, dataOf({ ...o, amountLock: o.amount, status: "open", hash: null, payer: null, paidAt: null }));
-                return true;
-            });
+                throw e;
+            }
         },
         async order(id) {
             const snap = await col("orders").doc(id).get();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nano133/nanoterra",
-  "version": "0.14.0",
+  "version": "0.14.1",
   "description": "Nanoterra for a creator's game, in one package: the player's sign-in ticket, the player's character (a toon body on the island's skeleton), the looks ladder, the admin and its wallet sign-in, the friends list, an options menu, emotes, the player's sign-in (a passkey or a wallet app) and a shop that sells looks for Nano with no key on the server.",
   "type": "module",
   "main": "dist/index.js",

package/src/shop/adapters/firestore.ts

@@ -55,6 +55,11 @@ const text = (v: unknown, fallback = ""): string => (typeof v === "string" ? v :
 const num = (v: unknown, fallback = 0): number => (typeof v === "number" && Number.isFinite(v) ? v : fallback);
 const orNull = (v: unknown): string | null => (typeof v === "string" ? v : null);
 const STATUSES: readonly OrderStatus[] = ["open", "paid", "expired", "paid_late"];
+/** A transaction that lost to other ones on every attempt: the Admin SDK's gRPC code 10, or the web SDK's "aborted". */
+const aborted = (e: unknown): boolean => {
+  const code = (e as { code?: unknown } | null)?.code;
+  return code === 10 || code === "aborted";
+};
 
 function orderOf(id: string, d: Record<string, unknown>): ShopOrder {
   return {
@@ -149,13 +154,20 @@ export function createFirestoreShop(db: FirestoreShopLike, collections: ShopColl
     async insert(o) {
       const lockRef = col("amounts").doc(o.amount);
       const orderRef = col("orders").doc(o.id);
-      return db.runTransaction(async (tx) => {
-        const [lock, order] = [await tx.get(lockRef), await tx.get(orderRef)];
-        if (lock.exists || order.exists) return false;
-        tx.set(lockRef, { orderId: o.id, holdUntil: o.holdUntil });
-        tx.set(orderRef, dataOf({ ...o, amountLock: o.amount, status: "open", hash: null, payer: null, paidAt: null }));
-        return true;
-      });
+      try {
+        return await db.runTransaction(async (tx) => {
+          const [lock, order] = [await tx.get(lockRef), await tx.get(orderRef)];
+          if (lock.exists || order.exists) return false;
+          tx.set(lockRef, { orderId: o.id, holdUntil: o.holdUntil });
+          tx.set(orderRef, dataOf({ ...o, amountLock: o.amount, status: "open", hash: null, payer: null, paidAt: null }));
+          return true;
+        });
+      } catch (e) {
+        // Many buyers of one price at the same instant all race for one amount's document. Firestore retries the losers, and one that loses on every
+        // attempt gets ABORTED. An aborted transaction wrote nothing, so it is "taken": reserveOrder goes on to the next amount (ShopBusy after the last).
+        if (aborted(e)) return false;
+        throw e;
+      }
     },
 
     async order(id) {