الأبحاث · جولةُ البرمجة الأولى
CB-2-07 — إعادة هيكلة · JavaScript/TypeScript · عالٍ
جولةُ البرمجة الأولى · 2026-10-12 · GAIBRA v2.30.04 · واجبُ التشغيل
| الترتيب | المتنافس | الرمز أمام المحكّم | الكلمات | الاختبارات | Opus | Grok | المجموع | الصدق (Opus · Grok) |
|---|---|---|---|---|---|---|---|---|
| 1 | GAIBRA | ب | 2,265 | 15/15 | 93.0 | 96.0 | 94.5 | 11 · 12 |
| 2 | Claude Sonnet | هـ | 1,634 | 15/15 | 94.0 | 93.0 | 93.5 | 10 · 11 |
| 3 | DeepSeek | أ | 1,754 | 14/15 | 74.7 | 79.7 | 77.2 | 6 · 8 |
| 4 | ChatGPT | ج | 1,017 | 14/15 | 66.7 | 75.7 | 71.2 | 7 · 9 |
| 5 | Gemini | د | 683 | 2/15 | 26.7 | 46.7 | 36.7 | 4 · 7 |
اختلف المحكّمان على المركز الأوّل: Opus اختار Claude Sonnet، وGrok اختار GAIBRA.
نصُّ السيناريو كما كتبه المولّد
Our restaurant POS order module grew by accretion and every new rule ("a served order can no longer be cancelled", "only new orders can add items", "payment requires a total > 0") was bolted on as another nested if. We keep shipping regressions when we touch it.
Current code (runs on Node 20, single file):
JavaScript
"use strict";
class OrderManager {
  constructor() {
  this.orders = new Map();
  this.nextId = 1;
  }
  createOrder(tableNo) {
  const id = this.nextId++;
  this.orders.set(id, { id, tableNo, status: "new", items: \[], paid: false, fired: false });
  return id;
  }
  addItem(id, name, price) {
  const o = this.orders.get(id);
  if (!o) throw new Error("unknown order");
  if (o.status !== "new") throw new Error("cannot add items to order in status " + o.status);
  if (typeof price !== "number" || price <= 0) throw new Error("price must be positive");
  o.items.push({ name, price });
  return o.items.length;
  }
  fire(id) { // send to kitchen
  const o = this.orders.get(id);
  if (!o) throw new Error("unknown order");
  if (o.status === "cancelled") throw new Error("order is cancelled");
  if (o.status !== "new") throw new Error("order already sent to kitchen");
  if (o.items.length === 0) throw new Error("cannot fire an empty order");
  o.status = "preparing"; o.fired = true;
  }
  markReady(id) {
  const o = this.orders.get(id);
  if (!o) throw new Error("unknown order");
  if (o.status === "cancelled") throw new Error("order is cancelled");
  if (o.status !== "preparing") throw new Error("order is not being prepared");
  o.status = "ready";
  }
  serve(id) {
  const o = this.orders.get(id);
  if (!o) throw new Error("unknown order");
  if (o.status === "cancelled") throw new Error("order is cancelled");
  if (o.status !== "ready") throw new Error("order is not ready");
  o.status = "served";
  }
  pay(id, amount) {
  const o = this.orders.get(id);
  if (!o) throw new Error("unknown order");
  if (o.status !== "served") throw new Error("only served orders can be paid");
  const total = o.items.reduce((s, i) => s + i.price, 0);
  if (amount < total) throw new Error("insufficient amount");
  o.status = "paid"; o.paid = true;
  return amount - total;
  }
  cancel(id) {
  const o = this.orders.get(id);
  if (!o) throw new Error("unknown order");
  if (o.status === "paid") throw new Error("paid orders cannot be cancelled");
  if (o.status === "served") throw new Error("served orders cannot be cancelled");
  if (o.status === "cancelled") throw new Error("order already cancelled");
  o.status = "cancelled";
  }
  getStatus(id) {
  const o = this.orders.get(id);
  if (!o) throw new Error("unknown order");
  return { ...o };
  }
}
module.exports = { OrderManager };
What I want: restructure this into an explicit finite-state machine — a single transition table (state × event → guard → new state) instead of scattered conditionals, while keeping the public API (class name, method names and signatures, and every exact error message string) unchanged, so the rest of the POS and our existing integration tests don't notice. The redundant paid/fired flags should disappear in favor of deriving whatever is needed from status, without changing what getStatus returns (keep the flags in its output for compatibility, computed from status). Note createOrder and addItem's price validation and the insufficient-amount change calculation must behave identically.
Constraints: single file, Node 20, standard library only, under 300 lines. Add a short \_\_main\_\_-style demo or comment showing the transition table you ended up with.
الردودُ الخمسة كما وصلت المحكّمين
بGAIBRA
"use strict";
/\*
 \* Transition table: state × event → guard → next state
 \*
 \* state | addItem | fire | markReady | serve | pay | cancel
 \* NEW | \[pricePositive] NEW | \[hasItems] PREPARING | ✗ | ✗ | ✗ | CANCELLED\_UNFIRED
 \* PREPARING | ✗ | ✗ | READY | ✗ | ✗ | CANCELLED\_FIRED
 \* READY | ✗ | ✗ | ✗ | SERVED | ✗ | CANCELLED\_FIRED
 \* SERVED | ✗ | ✗ | ✗ | ✗ | \[amountCoversTotal] PAID | ✗
 \* PAID | ✗ | ✗ | ✗ | ✗ | ✗ | ✗
 \* CANCELLED\_UNFIRED | ✗ | ✗ | ✗ | ✗ | ✗ | ✗
 \* CANCELLED\_FIRED | ✗ | ✗ | ✗ | ✗ | ✗ | ✗
 \*
 \* ✗ = rejected with the exact legacy message for that (state, event) cell.
 \* Both CANCELLED\_\* states are exposed as status "cancelled"; they differ only in the derived `fired` flag.
 \* Run `node <this file>` to print the live table and execute the self-checks.
 \*/
/\*\* Internal FSM states. The public status string is a projection of these (see STATE\_VIEW). \*/
const OrderState = Object.freeze({
  NEW: "NEW",
  PREPARING: "PREPARING",
  READY: "READY",
  SERVED: "SERVED",
  PAID: "PAID",
  CANCELLED\_UNFIRED: "CANCELLED\_UNFIRED",
  CANCELLED\_FIRED: "CANCELLED\_FIRED",
});
/\*\* Events, named after the public methods that raise them. \*/
const OrderEvent = Object.freeze({
  ADD\_ITEM: "addItem",
  FIRE: "fire",
  MARK\_READY: "markReady",
  SERVE: "serve",
  PAY: "pay",
  CANCEL: "cancel",
});
/\*\* Public projection of each state: legacy status string plus compatibility flags derived from the state. \*/
const STATE\_VIEW = Object.freeze({
  \[OrderState.NEW]: Object.freeze({ status: "new", paid: false, fired: false }),
  \[OrderState.PREPARING]: Object.freeze({ status: "preparing", paid: false, fired: true }),
  \[OrderState.READY]: Object.freeze({ status: "ready", paid: false, fired: true }),
  \[OrderState.SERVED]: Object.freeze({ status: "served", paid: false, fired: true }),
  \[OrderState.PAID]: Object.freeze({ status: "paid", paid: true, fired: true }),
  \[OrderState.CANCELLED\_UNFIRED]: Object.freeze({ status: "cancelled", paid: false, fired: false }),
  \[OrderState.CANCELLED\_FIRED]: Object.freeze({ status: "cancelled", paid: false, fired: true }),
});
/\*\* Every error message string, byte-for-byte identical to the legacy implementation. \*/
const Message = Object.freeze({
  UNKNOWN\_ORDER: "unknown order",
  CANNOT\_ADD\_ITEMS\_PREFIX: "cannot add items to order in status ",
  PRICE\_NOT\_POSITIVE: "price must be positive",
  ORDER\_CANCELLED: "order is cancelled",
  ALREADY\_SENT: "order already sent to kitchen",
  EMPTY\_ORDER: "cannot fire an empty order",
  NOT\_PREPARING: "order is not being prepared",
  NOT\_READY: "order is not ready",
  ONLY\_SERVED\_PAYABLE: "only served orders can be paid",
  INSUFFICIENT\_AMOUNT: "insufficient amount",
  PAID\_NOT\_CANCELLABLE: "paid orders cannot be cancelled",
  SERVED\_NOT\_CANCELLABLE: "served orders cannot be cancelled",
  ALREADY\_CANCELLED: "order already cancelled",
});
/\*\* Sum of item prices, computed exactly as the legacy code did (same reduce, same order). \*/
function orderTotal(order) {
  return order.items.reduce((sum, item) => sum + item.price, 0);
}
/\*\* Guards return null when the transition may proceed, or the exact error message when it may not. \*/
const Guard = Object.freeze({
  pricePositive: (order, { price }) =>
  typeof price !== "number" || price <= 0 ? Message.PRICE\_NOT\_POSITIVE : null,
  hasItems: (order) => (order.items.length === 0 ? Message.EMPTY\_ORDER : null),
  amountCoversTotal: (order, { amount }) =>
  amount < orderTotal(order) ? Message.INSUFFICIENT\_AMOUNT : null,
});
/\*\* Effects run after all guards pass; their return value becomes the public method's return value. \*/
const Effect = Object.freeze({
  appendItem: (order, { name, price }) => {
  order.items.push({ name, price });
  return order.items.length;
  },
  returnChange: (order, { amount }) => amount - orderTotal(order),
});
function allow(next, guards = \[], effect = null) {
  return Object.freeze({ next, guards: Object.freeze(guards), effect });
}
function reject(message) {
  return Object.freeze({ rejection: message });
}
function rejectAddItem(state) {
  return reject(Message.CANNOT\_ADD\_ITEMS\_PREFIX + STATE\_VIEW\[state].status);
}
function cancelledRow(state) {
  return Object.freeze({
  \[OrderEvent.ADD\_ITEM]: rejectAddItem(state),
  \[OrderEvent.FIRE]: reject(Message.ORDER\_CANCELLED),
  \[OrderEvent.MARK\_READY]: reject(Message.ORDER\_CANCELLED),
  \[OrderEvent.SERVE]: reject(Message.ORDER\_CANCELLED),
  \[OrderEvent.PAY]: reject(Message.ONLY\_SERVED\_PAYABLE),
  \[OrderEvent.CANCEL]: reject(Message.ALREADY\_CANCELLED),
  });
}
/\*\* The single source of truth for order lifecycle rules. \*/
const TRANSITIONS = Object.freeze({
  \[OrderState.NEW]: Object.freeze({
  \[OrderEvent.ADD\_ITEM]: allow(OrderState.NEW, \[Guard.pricePositive], Effect.appendItem),
  \[OrderEvent.FIRE]: allow(OrderState.PREPARING, \[Guard.hasItems]),
  \[OrderEvent.MARK\_READY]: reject(Message.NOT\_PREPARING),
  \[OrderEvent.SERVE]: reject(Message.NOT\_READY),
  \[OrderEvent.PAY]: reject(Message.ONLY\_SERVED\_PAYABLE),
  \[OrderEvent.CANCEL]: allow(OrderState.CANCELLED\_UNFIRED),
  }),
  \[OrderState.PREPARING]: Object.freeze({
  \[OrderEvent.ADD\_ITEM]: rejectAddItem(OrderState.PREPARING),
  \[OrderEvent.FIRE]: reject(Message.ALREADY\_SENT),
  \[OrderEvent.MARK\_READY]: allow(OrderState.READY),
  \[OrderEvent.SERVE]: reject(Message.NOT\_READY),
  \[OrderEvent.PAY]: reject(Message.ONLY\_SERVED\_PAYABLE),
  \[OrderEvent.CANCEL]: allow(OrderState.CANCELLED\_FIRED),
  }),
  \[OrderState.READY]: Object.freeze({
  \[OrderEvent.ADD\_ITEM]: rejectAddItem(OrderState.READY),
  \[OrderEvent.FIRE]: reject(Message.ALREADY\_SENT),
  \[OrderEvent.MARK\_READY]: reject(Message.NOT\_PREPARING),
  \[OrderEvent.SERVE]: allow(OrderState.SERVED),
  \[OrderEvent.PAY]: reject(Message.ONLY\_SERVED\_PAYABLE),
  \[OrderEvent.CANCEL]: allow(OrderState.CANCELLED\_FIRED),
  }),
  \[OrderState.SERVED]: Object.freeze({
  \[OrderEvent.ADD\_ITEM]: rejectAddItem(OrderState.SERVED),
  \[OrderEvent.FIRE]: reject(Message.ALREADY\_SENT),
  \[OrderEvent.MARK\_READY]: reject(Message.NOT\_PREPARING),
  \[OrderEvent.SERVE]: reject(Message.NOT\_READY),
  \[OrderEvent.PAY]: allow(OrderState.PAID, \[Guard.amountCoversTotal], Effect.returnChange),
  \[OrderEvent.CANCEL]: reject(Message.SERVED\_NOT\_CANCELLABLE),
  }),
  \[OrderState.PAID]: Object.freeze({
  \[OrderEvent.ADD\_ITEM]: rejectAddItem(OrderState.PAID),
  \[OrderEvent.FIRE]: reject(Message.ALREADY\_SENT),
  \[OrderEvent.MARK\_READY]: reject(Message.NOT\_PREPARING),
  \[OrderEvent.SERVE]: reject(Message.NOT\_READY),
  \[OrderEvent.PAY]: reject(Message.ONLY\_SERVED\_PAYABLE),
  \[OrderEvent.CANCEL]: reject(Message.PAID\_NOT\_CANCELLABLE),
  }),
  \[OrderState.CANCELLED\_UNFIRED]: cancelledRow(OrderState.CANCELLED\_UNFIRED),
  \[OrderState.CANCELLED\_FIRED]: cancelledRow(OrderState.CANCELLED\_FIRED),
});
/\*\* Fails at load time if any state × event cell is missing, so an incomplete edit never reaches runtime. \*/
function assertTableComplete() {
  for (const state of Object.values(OrderState)) {
  if (!STATE\_VIEW\[state] || !TRANSITIONS\[state]) throw new Error(`FSM: state ${state} lacks a view or row`);
  for (const event of Object.values(OrderEvent)) {
  if (!TRANSITIONS\[state]\[event]) throw new Error(`FSM: missing cell ${state} × ${event}`);
  }
  }
}
assertTableComplete();
function requireOrder(orders, id) {
  const order = orders.get(id);
  if (!order) throw new Error(Message.UNKNOWN\_ORDER);
  return order;
}
/\*\* Order of checks: unknown order → cell rejection → guards in order → effect → state change. \*/
function dispatch(orders, id, event, payload) {
  const order = requireOrder(orders, id);
  const cell = TRANSITIONS\[order.state]\[event];
  if (cell.rejection !== undefined) throw new Error(cell.rejection);
  for (const guard of cell.guards) {
  const failure = guard(order, payload);
  if (failure !== null) throw new Error(failure);
  }
  const result = cell.effect === null ? undefined : cell.effect(order, payload);
  order.state = cell.next;
  return result;
}
/\*\* Restaurant order lifecycle manager driven by an explicit transition table. \*/
class OrderManager {
  constructor() {
  this.orders = new Map();
  this.nextId = 1;
  }
  /\*\* Creates an order in status "new" and returns its numeric id. \*/
  createOrder(tableNo) {
  const id = this.nextId++;
  this.orders.set(id, { id, tableNo, state: OrderState.NEW, items: \[] });
  return id;
  }
  /\*\* Adds an item to a "new" order; returns the item count. Throws on unknown order, wrong status or non-positive price. \*/
  addItem(id, name, price) {
  return dispatch(this.orders, id, OrderEvent.ADD\_ITEM, { name, price });
  }
  /\*\* Sends a non-empty "new" order to the kitchen. \*/
  fire(id) {
  dispatch(this.orders, id, OrderEvent.FIRE, {});
  }
  /\*\* Marks a "preparing" order as ready. \*/
  markReady(id) {
  dispatch(this.orders, id, OrderEvent.MARK\_READY, {});
  }
  /\*\* Marks a "ready" order as served. \*/
  serve(id) {
  dispatch(this.orders, id, OrderEvent.SERVE, {});
  }
  /\*\* Pays a "served" order; returns the change (amount - total). \*/
  pay(id, amount) {
  return dispatch(this.orders, id, OrderEvent.PAY, { amount });
  }
  /\*\* Cancels an order that is not yet served, paid or cancelled. \*/
  cancel(id) {
  dispatch(this.orders, id, OrderEvent.CANCEL, {});
  }
  /\*\* Returns { id, tableNo, status, items, paid, fired } with flags derived from the FSM state. \*/
  getStatus(id) {
  const order = requireOrder(this.orders, id);
  const view = STATE\_VIEW\[order.state];
  return { id: order.id, tableNo: order.tableNo, status: view.status, items: order.items, paid: view.paid, fired: view.fired };
  }
}
function describeCell(cell) {
  if (cell.rejection !== undefined) return `✗ ${cell.rejection}`;
  const guards = cell.guards.map((guard) => guard.name).join(", ");
  return guards ? `\[${guards}] → ${cell.next}` : `→ ${cell.next}`;
}
function runDemo() {
  const assert = require("node:assert/strict");
  const table = {};
  for (const state of Object.values(OrderState)) {
  table\[state] = {};
  for (const event of Object.values(OrderEvent)) table\[state]\[event] = describeCell(TRANSITIONS\[state]\[event]);
  }
  console.table(table);
  const expectError = (fn, message) => assert.throws(fn, { name: "Error", message });
  const pos = new OrderManager();
  const dinner = pos.createOrder(4);
  assert.equal(pos.addItem(dinner, "Burger", 12.5), 1);
  assert.equal(pos.addItem(dinner, "Fries", 4.5), 2);
  pos.fire(dinner);
  assert.deepEqual(\[pos.getStatus(dinner).status, pos.getStatus(dinner).fired], \["preparing", true]);
  expectError(() => pos.addItem(dinner, "Cola", 3), "cannot add items to order in status preparing");
  expectError(() => pos.fire(dinner), "order already sent to kitchen");
  pos.markReady(dinner);
  pos.serve(dinner);
  expectError(() => pos.pay(dinner, 10), "insufficient amount");
  assert.equal(pos.pay(dinner, 20), 3);
  const paidView = pos.getStatus(dinner);
  assert.deepEqual(Object.keys(paidView), \["id", "tableNo", "status", "items", "paid", "fired"]);
  assert.deepEqual(paidView, {
  id: 1, tableNo: 4, status: "paid",
  items: \[{ name: "Burger", price: 12.5 }, { name: "Fries", price: 4.5 }], paid: true, fired: true,
  });
  expectError(() => pos.cancel(dinner), "paid orders cannot be cancelled");
  const walkout = pos.createOrder(7);
  pos.cancel(walkout);
  assert.deepEqual(\[pos.getStatus(walkout).status, pos.getStatus(walkout).fired], \["cancelled", false]);
  expectError(() => pos.fire(walkout), "order is cancelled");
  expectError(() => pos.addItem(walkout, "Tea", 2), "cannot add items to order in status cancelled");
  expectError(() => pos.pay(walkout, 5), "only served orders can be paid");
  expectError(() => pos.cancel(walkout), "order already cancelled");
  const sentBack = pos.createOrder(9);
  assert.equal(pos.addItem(sentBack, "Soup", 6), 1);
  pos.fire(sentBack);
  pos.cancel(sentBack);
  assert.deepEqual(\[pos.getStatus(sentBack).status, pos.getStatus(sentBack).fired], \["cancelled", true]);
  const empty = pos.createOrder(2);
  expectError(() => pos.fire(empty), "cannot fire an empty order");
  expectError(() => pos.addItem(empty, "Water", 0), "price must be positive");
  expectError(() => pos.markReady(empty), "order is not being prepared");
  expectError(() => pos.serve(empty), "order is not ready");
  expectError(() => pos.getStatus(99), "unknown order");
  console.log("All demo checks passed.");
}
if (require.main === module) runDemo();
module.exports = { OrderManager };
Explanation
The flags and the status do not carry the same information, and that is the real finding of this refactor. In your original code, cancel never resets fired, so an order cancelled while "new" reports fired: false, while one cancelled from "preparing" or "ready" reports fired: true. Both report status: "cancelled". The fired flag therefore cannot be computed from the public status string alone. Your requirement to derive the flags from status and your requirement to keep getStatus unchanged only seemed to conflict.
The fix is to make the machine's state richer than the string it exposes. The table has seven internal states, and CANCELLED\_UNFIRED and CANCELLED\_FIRED both project to "cancelled" through STATE\_VIEW. Every flag is now a pure function of one field, and nothing in the record can drift out of step with it.
The dispatcher preserves your error precedence exactly. It looks up the order first ("unknown order"). Next it checks the cell's rejection, then runs the guards in order, then the effect, and only then changes the state. This reproduces the subtle orderings in the old code. A cancelled order asked to fire still says "order is cancelled" instead of "order already sent to kitchen". pay on a cancelled order still says "only served orders can be paid", because the old pay never checked for cancellation. addItem on a non-new order still reports the status error before it looks at the price. No guard mutates anything, so a rejected call leaves the order untouched, as it did before.
assertTableComplete runs when the module is loaded. Each regression you described came from a rule added in one method and forgotten in another. With this check, adding a state or an event without deciding every cell fails at require time, before any order is affected. I used module-level functions instead of #private methods on purpose. A private method would add a brand check that throws a different TypeError when someone calls a method with .call on another object.
Here is every behaviour difference from the original. First, records inside the public manager.orders map now have the shape { id, tableNo, state, items } instead of status/paid/fired. Code that reads those records directly, or writes status onto them, will see the change. getStatus also no longer echoes extra properties someone attached to a record. Second, running the file directly with node now prints the table and runs the assertions. Third, loading the module now performs the completeness check. Error classes (plain Error), message strings, return values, getStatus key order, and the floating-point order of the total are all unchanged.
Your rule that "payment requires a total > 0" has no explicit guard. That matches the original, where it holds only indirectly: firing needs at least one item, and each item needs a price that passes price <= 0. That indirect protection has holes the refactor does not close.
Important
Three defects are kept deliberately because you required that "the insufficient-amount change calculation must behave identically", that "addItem's price validation" be preserved, and that getStatus not change what it returns. First, pay(id) with a missing or non-numeric amount marks the order paid and returns NaN, because undefined < total is false. Second, addItem accepts NaN and Infinity, and one NaN price lets any later payment succeed. Third, getStatus returns the live items array, so a caller pushing into it bypasses the "only new orders can add items" rule.
I did not run this code. The demo's expected values come from tracing your original code by hand on the same inputs.
Usage
Save the file under its current name and run node order-manager.js once. It prints the live state × event matrix and either passes every assertion or stops at the first mismatch. Then run your existing integration suite against it unchanged.
After the suite passes, close the three defects as a separate, versioned change. Each one is a single line in the table: an amountIsFinite guard ahead of amountCoversTotal, a Number.isFinite(price) condition in pricePositive, and items: order.items.map(item => ({ ...item })) in getStatus. Because each fix lives in the table, the rest of the code stays as it is.
هـClaude Sonnet
I’ll restructure it into a table-driven state machine, then fuzz it against your original to confirm identical behavior.
Now a differential fuzz test against the original.
order-manager.js is the state-machine version. It is 224 lines, uses only the standard library, and keeps the same class, method signatures and error strings.
How it’s structured
TRANSITIONS is the single table of state × event → guard → new state (+ effect). There are 8 rows.
REJECTIONS gives the exact error message for each state/event pair that has no transition.
GUARDS holds the checks that run after a transition is found: price, non-empty, and sufficient amount.
\_dispatch is now the only place where status changes.
At load time the module checks that every state × event pair has either a transition or a rejection message. If you add a state or event and forget a rule, it fails on startup instead of silently letting the order through.
Running node order-manager.js prints both tables and a sample order lifecycle. The transition table is also in the header comment.
Verified: I ran a differential fuzz test against your original code: 500,000 random operations, including odd prices and amounts like NaN, "5", undefined and Infinity, plus unknown order IDs. Return values, error messages, which check fires first, and getStatus output (including key order) all matched. The sandbox has Node 22, but nothing in the file needs anything newer than Node 20.
Things to know
fired can’t be worked out from status alone. A cancelled order may or may not have reached the kitchen, and the old flag kept that distinction. So cancel now records which state it came from in cancelledFrom. That’s a fact about the transition, not a duplicate flag, and getStatus().fired comes out the same as before.
The records inside this.orders no longer have paid/fired. If any POS code reads manager.orders directly instead of calling getStatus, it will see that change.
Existing quirks are kept on purpose:
pay(id, undefined) or pay(id, NaN) still succeeds and returns NaN change.
NaN and Infinity prices still pass validation.
getStatus().items is still the same array the order uses, not a copy.
These look like bugs. If you want them fixed, it’s a one-line guard change each, but it would be a deliberate change in behavior.
“Payment requires total > 0” has no explicit check, same as your current code. It already holds because fire rejects empty orders and prices must be positive.
Order manager
JS
"use strict";
 
/\*
 \* Restaurant order lifecycle as an explicit finite-state machine.
 \*
 \* Every rule lives in one of three tables:
 \* TRANSITIONS state × event → guard → new state (+ effect producing the return value)
 \* REJECTIONS the exact error for an event fired in a state with no transition
 \* GUARDS conditions checked only after a transition is found
 \*
 \* from event guard to effect
 \* ---------- ---------- ------------ ---------- -------------
 \* new addItem validPrice new appendItem
 \* new fire hasItems preparing
 \* preparing markReady ready
 \* ready serve served
 \* served pay coversTotal paid makeChange
 \* new cancel cancelled rememberOrigin
 \* preparing cancel cancelled rememberOrigin
 \* ready cancel cancelled rememberOrigin
 \*
 \* Any (state, event) pair not listed is rejected with its REJECTIONS message.
 \* The module checks at load time that every pair is covered by exactly one of
 \* the two tables, so a new state or event cannot silently fall through.
 \*
 \* Run `node order-manager.js` to print the table and a sample run.
 \*/
 
const State = Object.freeze({
  NEW: "new",
  PREPARING: "preparing",
  READY: "ready",
  SERVED: "served",
  PAID: "paid",
  CANCELLED: "cancelled",
});
 
const EVENTS = Object.freeze(\["addItem", "fire", "markReady", "serve", "pay", "cancel"]);
 
// States in which the order has been sent to the kitchen.
const FIRED\_STATES = new Set(\[State.PREPARING, State.READY, State.SERVED, State.PAID]);
 
const orderTotal = (o) => o.items.reduce((s, i) => s + i.price, 0);
 
// Guards return an error message to reject the event, or null to allow it.
// They must not mutate the order.
const GUARDS = Object.freeze({
  validPrice: (o, { price }) =>
  typeof price !== "number" || price <= 0 ? "price must be positive" : null,
  hasItems: (o) => (o.items.length === 0 ? "cannot fire an empty order" : null),
  coversTotal: (o, { amount }) => (amount < orderTotal(o) ? "insufficient amount" : null),
});
 
// Effects run after the guard passes; their return value is the method's return value.
const EFFECTS = Object.freeze({
  appendItem: (o, { name, price }) => {
  o.items.push({ name, price });
  return o.items.length;
  },
  makeChange: (o, { amount }) => amount - orderTotal(o),
  // "cancelled" alone cannot tell whether the kitchen had the order, so remember where we came from.
  rememberOrigin: (o, \_payload, from) => {
  o.cancelledFrom = from;
  },
});
 
const TRANSITIONS = Object.freeze(\[
  // from event guard to effect
  \[State.NEW, "addItem", "validPrice", State.NEW, "appendItem"],
  \[State.NEW, "fire", "hasItems", State.PREPARING, null],
  \[State.PREPARING, "markReady", null, State.READY, null],
  \[State.READY, "serve", null, State.SERVED, null],
  \[State.SERVED, "pay", "coversTotal", State.PAID, "makeChange"],
  \[State.NEW, "cancel", null, State.CANCELLED, "rememberOrigin"],
  \[State.PREPARING, "cancel", null, State.CANCELLED, "rememberOrigin"],
  \[State.READY, "cancel", null, State.CANCELLED, "rememberOrigin"],
].map((\[from, event, guard, to, effect]) => Object.freeze({ from, event, guard, to, effect })));
 
// Error for an event in a state with no transition. "\*" covers every other state;
// a function receives the current state.
const REJECTIONS = Object.freeze({
  addItem: { "\*": (s) => "cannot add items to order in status " + s },
  fire: { \[State.CANCELLED]: "order is cancelled", "\*": "order already sent to kitchen" },
  markReady: { \[State.CANCELLED]: "order is cancelled", "\*": "order is not being prepared" },
  serve: { \[State.CANCELLED]: "order is cancelled", "\*": "order is not ready" },
  pay: { "\*": "only served orders can be paid" },
  cancel: {
  \[State.PAID]: "paid orders cannot be cancelled",
  \[State.SERVED]: "served orders cannot be cancelled",
  \[State.CANCELLED]: "order already cancelled",
  },
});
 
const keyOf = (state, event) => state + "|" + event;
 
function rejectionFor(state, event) {
  const rules = REJECTIONS\[event] || {};
  const msg = Object.prototype.hasOwnProperty.call(rules, state) ? rules\[state] : rules\["\*"];
  return typeof msg === "function" ? msg(state) : msg;
}
 
// Build the lookup index and verify the tables are complete and consistent.
const INDEX = (() => {
  const index = new Map();
  const states = new Set(Object.values(State));
  for (const t of TRANSITIONS) {
  if (!states.has(t.from) || !states.has(t.to)) throw new Error("FSM: unknown state in " + keyOf(t.from, t.event));
  if (!EVENTS.includes(t.event)) throw new Error("FSM: unknown event " + t.event);
  if (t.guard \&\& !GUARDS\[t.guard]) throw new Error("FSM: unknown guard " + t.guard);
  if (t.effect \&\& !EFFECTS\[t.effect]) throw new Error("FSM: unknown effect " + t.effect);
  const k = keyOf(t.from, t.event);
  if (index.has(k)) throw new Error("FSM: duplicate transition " + k);
  index.set(k, t);
  }
  for (const s of states) {
  for (const e of EVENTS) {
  if (!index.has(keyOf(s, e)) \&\& typeof rejectionFor(s, e) !== "string") {
  throw new Error("FSM: no transition or rejection for " + keyOf(s, e));
  }
  }
  }
  return index;
})();
 
class OrderManager {
  constructor() {
  this.orders = new Map();
  this.nextId = 1;
  }
 
  createOrder(tableNo) {
  const id = this.nextId++;
  this.orders.set(id, { id, tableNo, status: State.NEW, items: \[], cancelledFrom: null });
  return id;
  }
 
  addItem(id, name, price) {
  return this.\_dispatch(id, "addItem", { name, price });
  }
 
  fire(id) { // send to kitchen
  this.\_dispatch(id, "fire");
  }
 
  markReady(id) {
  this.\_dispatch(id, "markReady");
  }
 
  serve(id) {
  this.\_dispatch(id, "serve");
  }
 
  pay(id, amount) {
  return this.\_dispatch(id, "pay", { amount });
  }
 
  cancel(id) {
  this.\_dispatch(id, "cancel");
  }
 
  getStatus(id) {
  const o = this.\_get(id);
  // Same keys, order and shallow-copy semantics as before; flags are derived.
  return {
  id: o.id,
  tableNo: o.tableNo,
  status: o.status,
  items: o.items,
  paid: o.status === State.PAID,
  fired: FIRED\_STATES.has(o.status) ||
  (o.status === State.CANCELLED \&\& FIRED\_STATES.has(o.cancelledFrom)),
  };
  }
 
  \_get(id) {
  const o = this.orders.get(id);
  if (!o) throw new Error("unknown order");
  return o;
  }
 
  // The only place an order's status changes.
  \_dispatch(id, event, payload = {}) {
  const o = this.\_get(id);
  const from = o.status;
  const t = INDEX.get(keyOf(from, event));
  if (!t) throw new Error(rejectionFor(from, event));
  if (t.guard) {
  const err = GUARDS\[t.guard](o, payload);
  if (err) throw new Error(err);
  }
  const result = t.effect ? EFFECTS\[t.effect](o, payload, from) : undefined;
  o.status = t.to;
  return result;
  }
}
 
module.exports = { OrderManager, State, TRANSITIONS, REJECTIONS };
 
if (require.main === module) {
  console.log("Transitions (state × event → guard → new state):");
  console.table(TRANSITIONS.map((t) => ({
  from: t.from, event: t.event, guard: t.guard || "", to: t.to, effect: t.effect || "",
  })));
 
  console.log("Rejections (no transition for state × event):");
  const rows = \[];
  for (const s of Object.values(State)) {
  const row = { state: s };
  for (const e of EVENTS) row\[e] = INDEX.has(keyOf(s, e)) ? "→ " + INDEX.get(keyOf(s, e)).to : rejectionFor(s, e);
  rows.push(row);
  }
  console.table(rows);
 
  const m = new OrderManager();
  const id = m.createOrder(7);
  m.addItem(id, "Shawarma", 18);
  m.addItem(id, "Mint lemonade", 12);
  m.fire(id);
  m.markReady(id);
  m.serve(id);
  console.log("change from 50:", m.pay(id, 50));
  console.log(m.getStatus(id));
  try { m.cancel(id); } catch (e) { console.log("cancel after pay →", e.message); }
}
 
جChatGPT
The key is to separate transition rules from action-specific validation. A single transition table determines which states accept each event, evaluates the guard, and supplies the next state. The public methods remain unchanged, and getStatus() derives paid and fired from status.
One compatibility detail matters: the original fire() checks for "cancelled" before checking whether the order is "new". The table-driven implementation below preserves that error precedence, along with all existing error strings.
Refactored implementation — order-manager.js
"use strict";
class OrderManager {
  constructor() {
  this.orders = new Map();
  this.nextId = 1;
  }
  /\*
  \* Transition table: current state -> event -> guard / next state.
  \*
  \* State Event Guard Next state
  \* ----------------------------------------------------------------
  \* new addItem valid price new (no transition)
  \* new fire at least one item preparing
  \* new cancel always cancelled
  \* preparing markReady always ready
  \* preparing cancel always cancelled
  \* ready serve always served
  \* ready cancel always cancelled
  \* served pay amount >= total paid
  \* paid cancel forbidden -
  \* cancelled fire forbidden -
  \* cancelled markReady forbidden -
  \* cancelled serve forbidden -
  \* cancelled cancel forbidden -
  \*
  \* Events without a transition are rejected by their method-specific
  \* error handler, preserving the original public error messages.
  \*/
  static TRANSITIONS = Object.freeze({
  new: Object.freeze({
  fire: {
  guard: (o) => o.items.length > 0,
  next: "preparing",
  error: "cannot fire an empty order"
  },
  cancel: { next: "cancelled" }
  }),
  preparing: Object.freeze({
  markReady: { next: "ready" },
  cancel: { next: "cancelled" }
  }),
  ready: Object.freeze({
  serve: { next: "served" },
  cancel: { next: "cancelled" }
  }),
  served: Object.freeze({
  pay: {
  guard: (o, amount) => amount >= OrderManager.total(o),
  next: "paid",
  error: "insufficient amount"
  }
  }),
  paid: Object.freeze({}),
  cancelled: Object.freeze({})
  });
  static total(o) {
  return o.items.reduce((sum, item) => sum + item.price, 0);
  }
  \_getOrder(id) {
  const o = this.orders.get(id);
  if (!o) throw new Error("unknown order");
  return o;
  }
  \_transition(o, event, ...args) {
  const rule = OrderManager.TRANSITIONS\[o.status]?.\[event];
  if (!rule) return false;
  if (rule.guard \&\& !rule.guard(o, ...args)) {
  throw new Error(rule.error);
  }
  o.status = rule.next;
  return true;
  }
  createOrder(tableNo) {
  const id = this.nextId++;
  this.orders.set(id, {
  id, tableNo, status: "new", items: \[]
  });
  return id;
  }
  addItem(id, name, price) {
  const o = this.\_getOrder(id);
  if (o.status !== "new") {
  throw new Error(
  "cannot add items to order in status " + o.status
  );
  }
  // Keep the original validation semantics, including NaN behavior.
  if (typeof price !== "number" || price <= 0) {
  throw new Error("price must be positive");
  }
  o.items.push({ name, price });
  return o.items.length;
  }
  fire(id) {
  const o = this.\_getOrder(id);
  // Preserve original error precedence.
  if (o.status === "cancelled") {
  throw new Error("order is cancelled");
  }
  if (o.status !== "new") {
  throw new Error("order already sent to kitchen");
  }
  this.\_transition(o, "fire");
  // "fired" is derived from status; no stored flag is needed.
  }
  markReady(id) {
  const o = this.\_getOrder(id);
  if (o.status === "cancelled") {
  throw new Error("order is cancelled");
  }
  if (o.status !== "preparing") {
  throw new Error("order is not being prepared");
  }
  this.\_transition(o, "markReady");
  }
  serve(id) {
  const o = this.\_getOrder(id);
  if (o.status === "cancelled") {
  throw new Error("order is cancelled");
  }
  if (o.status !== "ready") {
  throw new Error("order is not ready");
  }
  this.\_transition(o, "serve");
  }
  pay(id, amount) {
  const o = this.\_getOrder(id);
  if (o.status !== "served") {
  throw new Error("only served orders can be paid");
  }
  const total = OrderManager.total(o);
  if (amount < total) {
  throw new Error("insufficient amount");
  }
  this.\_transition(o, "pay", amount);
  return amount - total;
  }
  cancel(id) {
  const o = this.\_getOrder(id);
  if (o.status === "paid") {
  throw new Error("paid orders cannot be cancelled");
  }
  if (o.status === "served") {
  throw new Error("served orders cannot be cancelled");
  }
  if (o.status === "cancelled") {
  throw new Error("order already cancelled");
  }
  this.\_transition(o, "cancel");
  }
  getStatus(id) {
  const o = this.\_getOrder(id);
  return {
  ...o,
  paid: o.status === "paid",
  fired: \[
  "preparing", "ready", "served", "paid"
  ].includes(o.status)
  };
  }
}
module.exports = { OrderManager };
Compatibility notes
Public API: The class name, constructor, method names, parameters, and return values remain unchanged.
Exact errors: All original error strings are preserved, including the order of checks where that affects which error is thrown.
Derived flags: paid is true only in the paid state. fired is true in preparing, ready, served, and paid.
Price validation: The original check is retained exactly. In particular, NaN is still accepted by addItem() because NaN <= 0 is false.
Payment calculation: The total is still calculated using the same JavaScript number addition, and change is still amount - total. No new rounding is introduced.
No dependencies: Uses only standard JavaScript features available in Node 20.
Important design distinction
The transition table is the source of truth for allowed state changes, but the public methods still contain a few checks to preserve legacy error messages and precedence. This is intentional: a generic transition rejection alone cannot always reproduce the original method-specific errors.
One limitation of the exact compatibility requirement is that the original getStatus() returns a shallow copy of the order. The refactored version keeps that behavior, including the fact that the items array remains shared with the internal order. Changing it to a deep copy would be a separate behavioral change.
أDeepSeek
Here's a restructured version using an explicit finite-state machine. The public API and every error message are preserved exactly.
javascript
"use strict";
// ─────────────────────────────────────────────────────────────────────────────
// Finite State Machine definition for Order lifecycle.
//
// States: new → preparing → ready → served → paid
// ↘ cancelled (from new/preparing/ready)
//
// TRANSITION TABLE
// ┌────────────┬───────────────┬──────────────────────────────────────────────┬───────────────┐
// │ From state │ Event │ Guard (returns error string, or null to pass)│ To state │
// ├────────────┼───────────────┼──────────────────────────────────────────────┼───────────────┤
// │ new │ addItem │ price must be a positive number │ new │
// │ new │ fire │ items.length > 0 │ preparing │
// │ preparing │ markReady │ — │ ready │
// │ ready │ serve │ — │ served │
// │ served │ pay │ amount >= total │ paid │
// │ new │ cancel │ — │ cancelled │
// │ preparing │ cancel │ — │ cancelled │
// │ ready │ cancel │ — │ cancelled │
// └────────────┴───────────────┴──────────────────────────────────────────────┴───────────────┘
//
// Transitions that must fail (and their exact error messages) are encoded as
// "reject" rows in the table, so no conditional lives outside the FSM.
// ─────────────────────────────────────────────────────────────────────────────
const S = Object.freeze({
  NEW: "new",
  PREPARING: "preparing",
  READY: "ready",
  SERVED: "served",
  PAID: "paid",
  CANCELLED: "cancelled",
});
// Derive compatibility flags from status (so they disappear from stored state).
function flagsFor(status) {
  return {
  paid: status === S.PAID,
  fired: status === S.PREPARING || status === S.READY || status === S.SERVED || status === S.PAID,
  };
}
// A transition entry: { from, event, guard?, to } or { from, event, reject: msg }.
// `guard` throws the exact legacy error string when it fails.
const TRANSITIONS = \[
  // addItem: only allowed from "new"; price must be positive.
  {
  from: S.NEW,
  event: "addItem",
  guard: (o, args) =>
  typeof args.price !== "number" || args.price <= 0
  ? "price must be positive"
  : null,
  to: S.NEW,
  },
  {
  from: S.PREPARING,
  event: "addItem",
  reject: (o) => "cannot add items to order in status " + o.status,
  },
  {
  from: S.READY,
  event: "addItem",
  reject: (o) => "cannot add items to order in status " + o.status,
  },
  {
  from: S.SERVED,
  event: "addItem",
  reject: (o) => "cannot add items to order in status " + o.status,
  },
  {
  from: S.PAID,
  event: "addItem",
  reject: (o) => "cannot add items to order in status " + o.status,
  },
  {
  from: S.CANCELLED,
  event: "addItem",
  reject: (o) => "cannot add items to order in status " + o.status,
  },
  // fire: only from "new"; must have items.
  {
  from: S.NEW,
  event: "fire",
  guard: (o) =>
  o.items.length === 0 ? "cannot fire an empty order" : null,
  to: S.PREPARING,
  },
  {
  from: S.CANCELLED,
  event: "fire",
  reject: () => "order is cancelled",
  },
  {
  from: S.PREPARING,
  event: "fire",
  reject: () => "order already sent to kitchen",
  },
  {
  from: S.READY,
  event: "fire",
  reject: () => "order already sent to kitchen",
  },
  {
  from: S.SERVED,
  event: "fire",
  reject: () => "order already sent to kitchen",
  },
  {
  from: S.PAID,
  event: "fire",
  reject: () => "order already sent to kitchen",
  },
  // markReady: only from "preparing".
  {
  from: S.PREPARING,
  event: "markReady",
  to: S.READY,
  },
  {
  from: S.CANCELLED,
  event: "markReady",
  reject: () => "order is cancelled",
  },
  {
  from: S.NEW,
  event: "markReady",
  reject: () => "order is not being prepared",
  },
  {
  from: S.READY,
  event: "markReady",
  reject: () => "order is not being prepared",
  },
  {
  from: S.SERVED,
  event: "markReady",
  reject: () => "order is not being prepared",
  },
  {
  from: S.PAID,
  event: "markReady",
  reject: () => "order is not being prepared",
  },
  // serve: only from "ready".
  {
  from: S.READY,
  event: "serve",
  to: S.SERVED,
  },
  {
  from: S.CANCELLED,
  event: "serve",
  reject: () => "order is cancelled",
  },
  {
  from: S.NEW,
  event: "serve",
  reject: () => "order is not ready",
  },
  {
  from: S.PREPARING,
  event: "serve",
  reject: () => "order is not ready",
  },
  {
  from: S.SERVED,
  event: "serve",
  reject: () => "order is not ready",
  },
  {
  from: S.PAID,
  event: "serve",
  reject: () => "order is not ready",
  },
  // pay: only from "served"; amount must cover total.
  {
  from: S.SERVED,
  event: "pay",
  guard: (o, args) => {
  const total = o.items.reduce((s, i) => s + i.price, 0);
  return args.amount < total ? "insufficient amount" : null;
  },
  to: S.PAID,
  },
  {
  from: S.NEW,
  event: "pay",
  reject: () => "only served orders can be paid",
  },
  {
  from: S.PREPARING,
  event: "pay",
  reject: () => "only served orders can be paid",
  },
  {
  from: S.READY,
  event: "pay",
  reject: () => "only served orders can be paid",
  },
  {
  from: S.PAID,
  event: "pay",
  reject: () => "only served orders can be paid",
  },
  {
  from: S.CANCELLED,
  event: "pay",
  reject: () => "only served orders can be paid",
  },
  // cancel: from new/preparing/ready; not from served/paid/cancelled.
  { from: S.NEW, event: "cancel", to: S.CANCELLED },
  { from: S.PREPARING, event: "cancel", to: S.CANCELLED },
  { from: S.READY, event: "cancel", to: S.CANCELLED },
  {
  from: S.PAID,
  event: "cancel",
  reject: () => "paid orders cannot be cancelled",
  },
  {
  from: S.SERVED,
  event: "cancel",
  reject: () => "served orders cannot be cancelled",
  },
  {
  from: S.CANCELLED,
  event: "cancel",
  reject: () => "order already cancelled",
  },
];
// Index the table for O(1) lookup.
const TABLE = new Map();
for (const t of TRANSITIONS) {
  const key = t.from + "\\u0000" + t.event;
  if (TABLE.has(key)) throw new Error("duplicate transition: " + key);
  TABLE.set(key, t);
}
class OrderManager {
  constructor() {
  this.orders = new Map();
  this.nextId = 1;
  }
  // Internal: fetch order or throw the legacy "unknown order" message.
  \_get(id) {
  const o = this.orders.get(id);
  if (!o) throw new Error("unknown order");
  return o;
  }
  // Internal: run the FSM. `args` carries event payload (price/amount, etc.).
  // Returns the transition entry so callers can compute side-effect results.
  \_transition(o, event, args = {}) {
  const t = TABLE.get(o.status + "\\u0000" + event);
  if (!t) throw new Error("unknown order"); // unreachable with full table
  if (t.reject) throw new Error(t.reject(o));
  if (t.guard) {
  const err = t.guard(o, args);
  if (err) throw new Error(err);
  }
  o.status = t.to;
  return t;
  }
  createOrder(tableNo) {
  const id = this.nextId++;
  this.orders.set(id, { id, tableNo, status: S.NEW, items: \[] });
  return id;
  }
  addItem(id, name, price) {
  const o = this.\_get(id);
  this.\_transition(o, "addItem", { name, price });
  o.items.push({ name, price });
  return o.items.length;
  }
  fire(id) {
  const o = this.\_get(id);
  this.\_transition(o, "fire");
  }
  markReady(id) {
  const o = this.\_get(id);
  this.\_transition(o, "markReady");
  }
  serve(id) {
  const o = this.\_get(id);
  this.\_transition(o, "serve");
  }
  pay(id, amount) {
  const o = this.\_get(id);
  this.\_transition(o, "pay", { amount });
  const total = o.items.reduce((s, i) => s + i.price, 0);
  return amount - total;
  }
  cancel(id) {
  const o = this.\_get(id);
  this.\_transition(o, "cancel");
  }
  getStatus(id) {
  const o = this.\_get(id);
  // Keep paid/fired in the output for compatibility, computed from status.
  return { ...o, ...flagsFor(o.status) };
  }
}
module.exports = { OrderManager };
// ─────────────────────────────────────────────────────────────────────────────
// \_\_main\_\_-style demo — exercises the FSM and prints the transition table.
// ─────────────────────────────────────────────────────────────────────────────
if (require.main === module) {
  const om = new OrderManager();
  const id = om.createOrder(5);
  console.log("created:", om.getStatus(id));
  om.addItem(id, "Soup", 6.5);
  om.addItem(id, "Steak", 22);
  console.log("after addItem:", om.getStatus(id));
  om.fire(id);
  console.log("after fire:", om.getStatus(id));
  om.markReady(id);
  om.serve(id);
  console.log("after serve:", om.getStatus(id));
  const change = om.pay(id, 30);
  console.log("change:", change, "status:", om.getStatus(id));
  // Show the table we ended up with.
  console.log("\\nTransition table:");
  for (const t of TRANSITIONS) {
  if (t.reject) {
  console.log(` ${t.from.padEnd(10)} --${t.event.padEnd(10)}--> REJECT`);
  } else {
  console.log(` ${t.from.padEnd(10)} --${t.event.padEnd(10)}--> ${t.to}`);
  }
  }
}
What changed
Single transition table. All rules live in one TRANSITIONS array (state × event → guard/reject → new state). Method bodies are now three lines: fetch order, look up transition, apply side-effect.
paid / fired removed from stored state. They're derived from status inside getStatus via flagsFor, so the returned shape is unchanged.
Exact error strings preserved. Rejects and guards return the same message strings the original code threw — including the interpolated "cannot add items to order in status " + o.status.
Behavioral parity:
addItem still validates typeof price === "number" \&\& price > 0, still returns items.length.
pay still returns amount - total and only succeeds on served.
createOrder produces the same object shape minus the redundant flags.
Under 300 lines, single file, Node 20 stdlib only. The if (require.main === module) block prints the table so you can eyeball it.
Notes on the design
Rows are grouped by event for readability; the table is indexed into a Map at load time so lookups are O(1) and duplicate (state, event) pairs fail fast at startup.
"Reject" rows make the failure modes explicit data rather than if-chains, which is what you asked for — but they do inflate the table. If you later add states, the TABLE map + the if (!t) throw "unknown order" fallback keeps things safe.
The FSM is data, so you can serialize it, test it exhaustively, or render it as a diagram without touching OrderManager.
دGemini
Here is the refactored code using a clean, explicit Finite-State Machine pattern driven by a transition table.Transition Matrix DesignCurrent StateEventTarget StateGuardActionsnewaddItemnewprice > 0Append itemnewfirepreparingitems.length > 0Set status to preparingpreparingmarkReadyready—Set status to readyreadyserveserved—Set status to servedservedpaypaidamount >= totalCompute change, set status to paidnew / preparing / readycancelcancelled—Set status to cancelledImplementationJavaScript"use strict";
/\*\*
 \* State Transition Table
 \* Format: { \[currentState]: { \[event]: { target, guard?, action? } } }
 \*/
const TRANSITIONS = {
  new: {
  addItem: {
  target: "new",
  guard: ({ price }) => {
  if (typeof price !== "number" || price <= 0) {
  throw new Error("price must be positive");
  }
  },
  action: (order, { name, price }) => {
  order.items.push({ name, price });
  return order.items.length;
  },
  },
  fire: {
  target: "preparing",
  guard: (order) => {
  if (order.items.length === 0) throw new Error("cannot fire an empty order");
  },
  },
  cancel: { target: "cancelled" },
  },
  preparing: {
  markReady: { target: "ready" },
  cancel: { target: "cancelled" },
  },
  ready: {
  serve: { target: "served" },
  cancel: { target: "cancelled" },
  },
  served: {
  pay: {
  target: "paid",
  action: (order, { amount }) => {
  const total = order.items.reduce((sum, item) => sum + item.price, 0);
  if (amount < total) throw new Error("insufficient amount");
  return amount - total;
  },
  },
  },
  paid: {},
  cancelled: {},
};
/\*\*
 \* Specific error mapping when events are triggered on invalid states
 \*/
const INVALID\_STATE\_ERRORS = {
  addItem: (status) => `cannot add items to order in status ${status}`,
  fire: (status) =>
  status === "cancelled" ? "order is cancelled" : "order already sent to kitchen",
  markReady: (status) =>
  status === "cancelled" ? "order is cancelled" : "order is not being prepared",
  serve: (status) =>
  status === "cancelled" ? "order is cancelled" : "order is not ready",
  pay: (status) => "only served orders can be paid",
  cancel: (status) =>
  status === "paid"
  ? "paid orders cannot be cancelled"
  : status === "served"
  ? "served orders cannot be cancelled"
  : "order already cancelled",
};
class OrderManager {
  constructor() {
  this.orders = new Map();
  this.nextId = 1;
  }
  createOrder(tableNo) {
  const id = this.nextId++;
  // Internal state omits paid/fired flags
  this.orders.set(id, { id, tableNo, status: "new", items: \[] });
  return id;
  }
  \_dispatch(id, event, payload = {}) {
  const order = this.orders.get(id);
  if (!order) throw new Error("unknown order");
  const stateTransitions = TRANSITIONS\[order.status];
  const transition = stateTransitions ? stateTransitions\[event] : null;
  if (!transition) {
  const errorFormatter = INVALID\_STATE\_ERRORS\[event];
  const message = errorFormatter
  ? errorFormatter(order.status)
  : `Invalid event ${event} for status ${order.status}`;
  throw new Error(message);
  }
  if (transition.guard) {
  transition.guard(order, payload);
  }
  order.status = transition.target;
  if (transition.action) {
  return transition.action(order, payload);
  }
  }
  addItem(id, name, price) {
  return this.\_dispatch(id, "addItem", { name, price });
  }
  fire(id) {
  this.\_dispatch(id, "fire");
  }
  markReady(id) {
  this.\_dispatch(id, "markReady");
  }
  serve(id) {
  this.\_dispatch(id, "serve");
  }
  pay(id, amount) {
  return this.\_dispatch(id, "pay", { amount });
  }
  cancel(id) {
  this.\_dispatch(id, "cancel");
  }
  getStatus(id) {
  const order = this.orders.get(id);
  if (!order) throw new Error("unknown order");
  // Reconstruct paid/fired flags dynamically for backward compatibility
  return {
  ...order,
  fired: \["preparing", "ready", "served", "paid"].includes(order.status),
  paid: order.status === "paid",
  };
  }
}
module.exports = { OrderManager };
// --- Demo Run ---
if (require.main === module) {
  const manager = new OrderManager();
  const id = manager.createOrder(5);
  manager.addItem(id, "Burger", 12.5);
  manager.addItem(id, "Fries", 4.0);
  console.log("Status after items:", manager.getStatus(id));
  manager.fire(id);
  manager.markReady(id);
  manager.serve(id);
  const change = manager.pay(id, 20.0);
  console.log(`Paid $20, Change: $${change}`);
  console.log("Final Status:", manager.getStatus(id));
}