@dailephd/my-dev-kit-lab 0.8.2 → 0.9.0

package/benchmarks/projects/agent-success-inventory-node/.gitattributes

@@ -0,0 +1,2 @@
+# Keep checked-out bytes identical on every platform so reference patches apply deterministically.
+* text eol=lf

package/benchmarks/projects/agent-success-inventory-node/README.md

@@ -0,0 +1,74 @@
+# agent-success-inventory-node
+
+A small, dependency-free, in-memory inventory and reservation system written as JavaScript ES modules for
+Node.js `>=24`.
+
+This project is an **implementation benchmark** for the `agent-success-rate` experiment of
+`my-dev-kit-lab`. It is a controlled fixture: the Lab copies it into a disposable sandbox, asks an
+implementation to change code under `src/`, and judges the result with trusted checks that the
+implementation does not receive. The project is not a product and has no database, network access,
+environment dependence, randomness or timestamps.
+
+## Behavior
+
+The system models stock, reservations against that stock, and a fulfillment report. All state lives in
+memory inside one system instance; two systems never share state.
+
+- An item is identified by its `sku` and tracks `received` (all stock ever added) and `available` (stock not
+  held by a reservation or consumed by a fulfilled reservation).
+- A **quantity** for stock or for a reservation must be a positive integer. Zero, negative numbers,
+  fractions, `NaN`, infinities and non-number values are rejected with a `QuantityError` whose `code` is
+  `INVALID_QUANTITY`. Rejection happens before any stock or reservation changes.
+- A **reservation** has an `id` supplied by the caller, a `sku`, a `quantity` and a `status`, which is one of
+  `active`, `fulfilled` or `cancelled`.
+  - Reserving moves the quantity out of `available` exactly once and records an `active` reservation.
+  - A reservation that cannot be completed (unknown sku, insufficient stock, duplicate id) fails with a
+    stable error `code` (`UNKNOWN_SKU`, `INSUFFICIENT_STOCK`, `DUPLICATE_RESERVATION`) and leaves stock and
+    reservation records exactly as they were. A reservation id that never produced a record may be used
+    again.
+  - Cancelling an `active` reservation returns its quantity to `available` and marks it `cancelled`. Cancelling
+    an already cancelled reservation changes nothing. A reservation in another terminal state is not
+    restored (`INVALID_TRANSITION`).
+  - Fulfilling an `active` reservation marks it `fulfilled`; its stock stays consumed.
+- The **fulfillment report** has one row per sku, sorted by sku, plus totals. Each row reports `received`,
+  `available` and `active`, `fulfilled` and `cancelled` buckets of `{ count, quantity }`. Reported figures
+  agree with the store, and `received = available + active.quantity + fulfilled.quantity` holds for every
+  row. The report is deterministic.
+
+## Public API
+
+Everything is exported from `src/index.js`.
+
+| Export | Purpose |
+| --- | --- |
+| `createInventorySystem()` | Returns `{ store, service, report }` for a fresh, independent system. |
+| `InventoryStore` | `addStock`, `getItem`, `listItems`, `takeStock`, `returnStock`, `addReservation`, `getReservation`, `listReservations`, `setReservationStatus`. |
+| `ReservationService` | `reserve({ reservationId, sku, quantity })`, `cancel(id)`, `fulfill(id)`. |
+| `buildFulfillmentReport(store)` | Returns `{ skus, totals }`. |
+| `assertPositiveInteger(value)` | Returns the quantity or throws `QuantityError`. |
+| `RESERVATION_ACTIVE`, `RESERVATION_FULFILLED`, `RESERVATION_CANCELLED` | Reservation status values. |
+| `QuantityError`, `UnknownSkuError`, `InsufficientStockError`, `UnknownReservationError`, `DuplicateReservationError` | Error classes with a stable `code` property. |
+
+Stores return copies of items and reservations, so changing a returned object never changes the system.
+
+## Layout
+
+```
+src/quantity.js            quantity contract
+src/inventoryStore.js      in-memory stock and reservation storage
+src/reservationService.js  reserve, cancel and fulfill
+src/fulfillmentReport.js   deterministic fulfillment report
+src/index.js               public exports and createInventorySystem()
+tests/*.check.mjs          trusted verification checks (owned by the Lab verifier)
+```
+
+## Running checks
+
+```
+npm test
+node --test tests/regression.check.mjs
+```
+
+The files under `tests/` are named `*.check.mjs` on purpose and are run explicitly through Node's built-in
+test runner. They are verification inputs owned by the Lab, not part of the implementation to change.
+No installation step is needed.

package/benchmarks/projects/agent-success-inventory-node/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "agent-success-inventory-node",
+  "version": "0.0.0",
+  "description": "Dependency-free JavaScript implementation benchmark: an in-memory inventory and reservation system.",
+  "private": true,
+  "type": "module",
+  "engines": {
+    "node": ">=24"
+  },
+  "main": "src/index.js",
+  "scripts": {
+    "test": "node --test \"tests/*.check.mjs\""
+  }
+}

package/benchmarks/projects/agent-success-inventory-node/src/fulfillmentReport.js

@@ -0,0 +1,38 @@
+import { RESERVATION_FULFILLED } from "./inventoryStore.js";
+
+function bucket(reservations) {
+  return {
+    count: reservations.length,
+    quantity: reservations.reduce((sum, reservation) => sum + reservation.quantity, 0)
+  };
+}
+
+/**
+ * Builds a deterministic fulfillment report: one row per sku (sorted by sku) and totals across rows.
+ * For every row, received = available + active.quantity + fulfilled.quantity.
+ */
+export function buildFulfillmentReport(store) {
+  const reservations = store.listReservations();
+  const rows = store.listItems().map((item) => {
+    const mine = reservations.filter((reservation) => reservation.sku === item.sku);
+    return {
+      sku: item.sku,
+      received: item.received,
+      available: item.available,
+      active: bucket(mine.filter((reservation) => reservation.status !== RESERVATION_FULFILLED)),
+      fulfilled: bucket(mine.filter((reservation) => reservation.status === RESERVATION_FULFILLED)),
+      cancelled: bucket([])
+    };
+  });
+  const sum = (selector) => rows.reduce((total, row) => total + selector(row), 0);
+  return {
+    skus: rows,
+    totals: {
+      received: sum((row) => row.received),
+      available: sum((row) => row.available),
+      active: sum((row) => row.active.quantity),
+      fulfilled: sum((row) => row.fulfilled.quantity),
+      cancelled: sum((row) => row.cancelled.quantity)
+    }
+  };
+}

package/benchmarks/projects/agent-success-inventory-node/src/index.js

@@ -0,0 +1,26 @@
+import { buildFulfillmentReport } from "./fulfillmentReport.js";
+import { InventoryStore } from "./inventoryStore.js";
+import { ReservationService } from "./reservationService.js";
+
+export { buildFulfillmentReport } from "./fulfillmentReport.js";
+export {
+  DuplicateReservationError,
+  InsufficientStockError,
+  InventoryStore,
+  RESERVATION_ACTIVE,
+  RESERVATION_CANCELLED,
+  RESERVATION_FULFILLED,
+  UnknownReservationError,
+  UnknownSkuError
+} from "./inventoryStore.js";
+export { INVALID_QUANTITY, QuantityError, assertPositiveInteger } from "./quantity.js";
+export { ReservationService } from "./reservationService.js";
+
+/**
+ * Creates an independent in-memory inventory: a store, a reservation service over it, and a report helper.
+ */
+export function createInventorySystem() {
+  const store = new InventoryStore();
+  const service = new ReservationService(store);
+  return { store, service, report: () => buildFulfillmentReport(store) };
+}

package/benchmarks/projects/agent-success-inventory-node/src/inventoryStore.js

@@ -0,0 +1,114 @@
+import { assertPositiveInteger } from "./quantity.js";
+
+export const RESERVATION_ACTIVE = "active";
+export const RESERVATION_FULFILLED = "fulfilled";
+export const RESERVATION_CANCELLED = "cancelled";
+
+export class UnknownSkuError extends Error {
+  constructor(sku) {
+    super(`unknown sku: ${sku}`);
+    this.name = "UnknownSkuError";
+    this.code = "UNKNOWN_SKU";
+  }
+}
+
+export class InsufficientStockError extends Error {
+  constructor(sku) {
+    super(`insufficient stock for sku: ${sku}`);
+    this.name = "InsufficientStockError";
+    this.code = "INSUFFICIENT_STOCK";
+  }
+}
+
+export class UnknownReservationError extends Error {
+  constructor(id) {
+    super(`unknown reservation: ${id}`);
+    this.name = "UnknownReservationError";
+    this.code = "UNKNOWN_RESERVATION";
+  }
+}
+
+export class DuplicateReservationError extends Error {
+  constructor(id) {
+    super(`duplicate reservation: ${id}`);
+    this.name = "DuplicateReservationError";
+    this.code = "DUPLICATE_RESERVATION";
+  }
+}
+
+/**
+ * In-memory inventory and reservation storage. Items and reservations are returned as copies.
+ * Each item tracks `received` (all stock ever added) and `available` (stock not held by a reservation).
+ */
+export class InventoryStore {
+  #items = new Map();
+  #reservations = new Map();
+
+  addStock(sku, quantity) {
+    assertPositiveInteger(quantity);
+    const item = this.#items.get(sku) ?? { sku, available: 0, received: 0 };
+    item.available += quantity;
+    item.received += quantity;
+    this.#items.set(sku, item);
+    return { ...item };
+  }
+
+  getItem(sku) {
+    const item = this.#items.get(sku);
+    return item ? { ...item } : null;
+  }
+
+  /** Items sorted by sku. */
+  listItems() {
+    return [...this.#items.values()]
+      .sort((a, b) => (a.sku < b.sku ? -1 : a.sku > b.sku ? 1 : 0))
+      .map((item) => ({ ...item }));
+  }
+
+  /** Removes stock from `available` for a reservation. */
+  takeStock(sku, quantity) {
+    const item = this.#items.get(sku);
+    if (!item) {
+      throw new UnknownSkuError(sku);
+    }
+    item.available -= quantity;
+    if (item.available < 0) {
+      throw new InsufficientStockError(sku);
+    }
+    return { ...item };
+  }
+
+  /** Returns stock to `available`. */
+  returnStock(sku, quantity) {
+    const item = this.#items.get(sku);
+    if (!item) {
+      throw new UnknownSkuError(sku);
+    }
+    item.available += quantity;
+    return { ...item };
+  }
+
+  addReservation(record) {
+    this.#reservations.set(record.id, { ...record });
+    return { ...record };
+  }
+
+  getReservation(id) {
+    const record = this.#reservations.get(id);
+    return record ? { ...record } : null;
+  }
+
+  /** Reservations in the order they were recorded. */
+  listReservations() {
+    return [...this.#reservations.values()].map((record) => ({ ...record }));
+  }
+
+  setReservationStatus(id, status) {
+    const record = this.#reservations.get(id);
+    if (!record) {
+      throw new UnknownReservationError(id);
+    }
+    record.status = status;
+    return { ...record };
+  }
+}

package/benchmarks/projects/agent-success-inventory-node/src/quantity.js

@@ -0,0 +1,19 @@
+export const INVALID_QUANTITY = "INVALID_QUANTITY";
+
+export class QuantityError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "QuantityError";
+    this.code = INVALID_QUANTITY;
+  }
+}
+
+/**
+ * Returns the quantity when it is a valid stock or reservation quantity, or throws QuantityError.
+ */
+export function assertPositiveInteger(value) {
+  if (typeof value !== "number" || value < 0) {
+    throw new QuantityError("quantity must be a positive integer");
+  }
+  return value;
+}

package/benchmarks/projects/agent-success-inventory-node/src/reservationService.js

@@ -0,0 +1,45 @@
+import {
+  RESERVATION_ACTIVE,
+  RESERVATION_FULFILLED,
+  UnknownReservationError
+} from "./inventoryStore.js";
+import { assertPositiveInteger } from "./quantity.js";
+
+export class ReservationService {
+  constructor(store) {
+    this.store = store;
+  }
+
+  /**
+   * Reserves `quantity` units of `sku` under a caller-supplied reservation id.
+   */
+  reserve({ reservationId, sku, quantity }) {
+    assertPositiveInteger(quantity);
+    this.store.addReservation({ id: reservationId, sku, quantity, status: RESERVATION_ACTIVE });
+    this.store.takeStock(sku, quantity);
+    return this.store.getReservation(reservationId);
+  }
+
+  /**
+   * Cancels a reservation and returns its quantity to available stock.
+   */
+  cancel(reservationId) {
+    const record = this.store.getReservation(reservationId);
+    if (!record) {
+      throw new UnknownReservationError(reservationId);
+    }
+    this.store.returnStock(record.sku, record.quantity);
+    return this.store.setReservationStatus(reservationId, "canceled");
+  }
+
+  /**
+   * Marks a reservation as fulfilled. Fulfilled stock stays consumed.
+   */
+  fulfill(reservationId) {
+    const record = this.store.getReservation(reservationId);
+    if (!record) {
+      throw new UnknownReservationError(reservationId);
+    }
+    return this.store.setReservationStatus(reservationId, RESERVATION_FULFILLED);
+  }
+}

package/benchmarks/projects/agent-success-inventory-node/tests/quantity-edge.check.mjs

@@ -0,0 +1,51 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { INVALID_QUANTITY, QuantityError, assertPositiveInteger, createInventorySystem } from "../src/index.js";
+
+function isQuantityError(error) {
+  return error instanceof QuantityError && error.code === INVALID_QUANTITY;
+}
+
+test("non-finite and not-a-number values are rejected", () => {
+  for (const value of [Number.NaN, Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY]) {
+    assert.throws(() => assertPositiveInteger(value), isQuantityError);
+  }
+});
+
+test("values that only look like zero or a whole number are rejected", () => {
+  for (const value of [-0, 0.1, 1e-9, Number.EPSILON, 0.999999, 2.000001]) {
+    assert.throws(() => assertPositiveInteger(value), isQuantityError);
+  }
+});
+
+test("nonnumeric values are rejected", () => {
+  for (const value of ["3", "", " ", null, undefined, {}, [], [3], true, 3n, () => 3]) {
+    assert.throws(() => assertPositiveInteger(value), isQuantityError);
+  }
+});
+
+test("positive integers are accepted and returned unchanged", () => {
+  for (const value of [1, 2, 10, 1000, Number.MAX_SAFE_INTEGER]) {
+    assert.equal(assertPositiveInteger(value), value);
+  }
+});
+
+test("rejected stock additions never mutate inventory", () => {
+  const { store } = createInventorySystem();
+  store.addStock("gadget", 2);
+  for (const quantity of [Number.NaN, Number.POSITIVE_INFINITY, -0, "4", null]) {
+    assert.throws(() => store.addStock("gadget", quantity), isQuantityError);
+    assert.throws(() => store.addStock("fresh", quantity), isQuantityError);
+  }
+  assert.deepEqual(store.listItems(), [{ sku: "gadget", available: 2, received: 2 }]);
+});
+
+test("rejected reservations never mutate inventory or reservation records", () => {
+  const { store, service } = createInventorySystem();
+  store.addStock("gadget", 4);
+  for (const quantity of [Number.NaN, Number.POSITIVE_INFINITY, -0, 0.25, "2"]) {
+    assert.throws(() => service.reserve({ reservationId: "r-edge", sku: "gadget", quantity }), isQuantityError);
+  }
+  assert.equal(store.getItem("gadget").available, 4);
+  assert.equal(store.getReservation("r-edge"), null);
+});

package/benchmarks/projects/agent-success-inventory-node/tests/quantity-primary.check.mjs

@@ -0,0 +1,46 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { INVALID_QUANTITY, QuantityError, createInventorySystem } from "../src/index.js";
+
+function isQuantityError(error) {
+  return error instanceof QuantityError && error.code === INVALID_QUANTITY;
+}
+
+test("zero is not a valid stock quantity and creates no item", () => {
+  const { store } = createInventorySystem();
+  assert.throws(() => store.addStock("widget", 0), isQuantityError);
+  assert.equal(store.getItem("widget"), null);
+  assert.deepEqual(store.listItems(), []);
+});
+
+test("negative and fractional quantities are rejected before stock changes", () => {
+  const { store } = createInventorySystem();
+  store.addStock("widget", 5);
+  for (const quantity of [-1, -5, 1.5, 0.5]) {
+    assert.throws(() => store.addStock("widget", quantity), isQuantityError);
+  }
+  assert.deepEqual(store.getItem("widget"), { sku: "widget", available: 5, received: 5 });
+});
+
+test("invalid reservation quantities are rejected before inventory or reservations change", () => {
+  const { store, service } = createInventorySystem();
+  store.addStock("widget", 5);
+  for (const quantity of [0, -1, 2.5]) {
+    assert.throws(
+      () => service.reserve({ reservationId: `r-${String(quantity)}`, sku: "widget", quantity }),
+      isQuantityError
+    );
+  }
+  assert.deepEqual(store.getItem("widget"), { sku: "widget", available: 5, received: 5 });
+  assert.deepEqual(store.listReservations(), []);
+});
+
+test("valid positive quantities keep working", () => {
+  const { store, service } = createInventorySystem();
+  store.addStock("widget", 3);
+  store.addStock("widget", 2);
+  assert.equal(store.getItem("widget").available, 5);
+  const reservation = service.reserve({ reservationId: "r-1", sku: "widget", quantity: 4 });
+  assert.equal(reservation.quantity, 4);
+  assert.equal(store.getItem("widget").available, 1);
+});

package/benchmarks/projects/agent-success-inventory-node/tests/regression.check.mjs

@@ -0,0 +1,115 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  InventoryStore,
+  QuantityError,
+  RESERVATION_ACTIVE,
+  RESERVATION_FULFILLED,
+  createInventorySystem
+} from "../src/index.js";
+
+test("addStock accumulates per sku and tracks received stock", () => {
+  const { store } = createInventorySystem();
+  store.addStock("widget", 3);
+  store.addStock("widget", 4);
+  store.addStock("gadget", 1);
+  assert.deepEqual(store.getItem("widget"), { sku: "widget", available: 7, received: 7 });
+  assert.deepEqual(
+    store.listItems().map((item) => item.sku),
+    ["gadget", "widget"]
+  );
+  assert.equal(store.getItem("missing"), null);
+});
+
+test("a valid reservation holds stock and records an active reservation", () => {
+  const { store, service } = createInventorySystem();
+  store.addStock("widget", 5);
+  const reservation = service.reserve({ reservationId: "r-1", sku: "widget", quantity: 2 });
+  assert.deepEqual(reservation, { id: "r-1", sku: "widget", quantity: 2, status: RESERVATION_ACTIVE });
+  assert.deepEqual(store.getItem("widget"), { sku: "widget", available: 3, received: 5 });
+});
+
+test("quantities given as strings or other non-numbers are rejected", () => {
+  const { store, service } = createInventorySystem();
+  store.addStock("widget", 5);
+  assert.throws(() => store.addStock("widget", "2"), QuantityError);
+  assert.throws(() => service.reserve({ reservationId: "r-1", sku: "widget", quantity: "2" }), QuantityError);
+  assert.throws(() => service.reserve({ reservationId: "r-1", sku: "widget", quantity: undefined }), QuantityError);
+  assert.equal(store.getItem("widget").available, 5);
+});
+
+test("negative quantities are rejected", () => {
+  const { store } = createInventorySystem();
+  assert.throws(() => store.addStock("widget", -3), { code: "INVALID_QUANTITY" });
+});
+
+test("reserving an unknown sku fails with the unknown-sku error", () => {
+  const { service } = createInventorySystem();
+  assert.throws(() => service.reserve({ reservationId: "r-1", sku: "missing", quantity: 1 }), {
+    code: "UNKNOWN_SKU"
+  });
+});
+
+test("fulfilling an active reservation keeps its stock consumed", () => {
+  const { store, service } = createInventorySystem();
+  store.addStock("widget", 5);
+  service.reserve({ reservationId: "r-1", sku: "widget", quantity: 2 });
+  const fulfilled = service.fulfill("r-1");
+  assert.equal(fulfilled.status, RESERVATION_FULFILLED);
+  assert.equal(store.getItem("widget").available, 3);
+});
+
+test("cancelling an active reservation restores its stock", () => {
+  const { store, service } = createInventorySystem();
+  store.addStock("widget", 5);
+  service.reserve({ reservationId: "r-1", sku: "widget", quantity: 2 });
+  service.cancel("r-1");
+  assert.equal(store.getItem("widget").available, 5);
+});
+
+test("the report of an untouched inventory mirrors the stock", () => {
+  const { store, report } = createInventorySystem();
+  store.addStock("b-item", 2);
+  store.addStock("a-item", 4);
+  assert.deepEqual(report(), {
+    skus: [
+      {
+        sku: "a-item",
+        received: 4,
+        available: 4,
+        active: { count: 0, quantity: 0 },
+        fulfilled: { count: 0, quantity: 0 },
+        cancelled: { count: 0, quantity: 0 }
+      },
+      {
+        sku: "b-item",
+        received: 2,
+        available: 2,
+        active: { count: 0, quantity: 0 },
+        fulfilled: { count: 0, quantity: 0 },
+        cancelled: { count: 0, quantity: 0 }
+      }
+    ],
+    totals: { received: 6, available: 6, active: 0, fulfilled: 0, cancelled: 0 }
+  });
+});
+
+test("the report counts active and fulfilled reservations", () => {
+  const { store, service, report } = createInventorySystem();
+  store.addStock("widget", 10);
+  service.reserve({ reservationId: "r-1", sku: "widget", quantity: 3 });
+  service.reserve({ reservationId: "r-2", sku: "widget", quantity: 2 });
+  service.fulfill("r-2");
+  const [row] = report().skus;
+  assert.deepEqual(row.active, { count: 1, quantity: 3 });
+  assert.deepEqual(row.fulfilled, { count: 1, quantity: 2 });
+  assert.equal(row.available, 5);
+});
+
+test("inventories are independent of each other", () => {
+  const one = createInventorySystem();
+  const two = createInventorySystem();
+  one.store.addStock("widget", 2);
+  assert.deepEqual(two.store.listItems(), []);
+  assert.ok(new InventoryStore().listReservations().length === 0);
+});

package/benchmarks/projects/agent-success-inventory-node/tests/report-edge.check.mjs

@@ -0,0 +1,109 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { RESERVATION_ACTIVE, RESERVATION_CANCELLED, RESERVATION_FULFILLED, createInventorySystem } from "../src/index.js";
+
+test("repeated cancellation does not restore stock again", () => {
+  const { store, service } = createInventorySystem();
+  store.addStock("widget", 10);
+  service.reserve({ reservationId: "r-1", sku: "widget", quantity: 4 });
+  service.cancel("r-1");
+  service.cancel("r-1");
+  service.cancel("r-1");
+  assert.equal(store.getItem("widget").available, 10);
+  assert.equal(store.getReservation("r-1").status, RESERVATION_CANCELLED);
+});
+
+test("a fulfilled reservation cannot be cancelled back into stock", () => {
+  const { store, service } = createInventorySystem();
+  store.addStock("widget", 10);
+  service.reserve({ reservationId: "r-1", sku: "widget", quantity: 4 });
+  service.fulfill("r-1");
+  try {
+    service.cancel("r-1");
+  } catch {
+    // Rejecting the transition is acceptable; restoring stock is not.
+  }
+  assert.equal(store.getItem("widget").available, 6);
+  assert.equal(store.getReservation("r-1").status, RESERVATION_FULFILLED);
+});
+
+test("a cancelled reservation cannot be fulfilled", () => {
+  const { store, service, report } = createInventorySystem();
+  store.addStock("widget", 10);
+  service.reserve({ reservationId: "r-1", sku: "widget", quantity: 4 });
+  service.cancel("r-1");
+  try {
+    service.fulfill("r-1");
+  } catch {
+    // Rejecting the transition is acceptable; reporting it as fulfilled is not.
+  }
+  assert.equal(store.getReservation("r-1").status, RESERVATION_CANCELLED);
+  assert.deepEqual(report().skus[0].fulfilled, { count: 0, quantity: 0 });
+});
+
+test("unknown reservations are rejected and change nothing", () => {
+  const { store, service } = createInventorySystem();
+  store.addStock("widget", 3);
+  assert.throws(() => service.cancel("nope"), { code: "UNKNOWN_RESERVATION" });
+  assert.throws(() => service.fulfill("nope"), { code: "UNKNOWN_RESERVATION" });
+  assert.equal(store.getItem("widget").available, 3);
+});
+
+test("only the documented lifecycle states can be stored", () => {
+  const { store, service } = createInventorySystem();
+  store.addStock("widget", 3);
+  service.reserve({ reservationId: "r-1", sku: "widget", quantity: 1 });
+  for (const status of ["canceled", "complete", "", undefined, "ACTIVE"]) {
+    assert.throws(() => store.setReservationStatus("r-1", status));
+  }
+  assert.equal(store.getReservation("r-1").status, RESERVATION_ACTIVE);
+});
+
+test("unrelated skus are unaffected by cancellation and fulfillment", () => {
+  const { store, service, report } = createInventorySystem();
+  store.addStock("widget", 10);
+  store.addStock("gadget", 6);
+  service.reserve({ reservationId: "r-1", sku: "widget", quantity: 4 });
+  service.reserve({ reservationId: "r-2", sku: "gadget", quantity: 2 });
+  const gadgetBefore = report().skus.find((row) => row.sku === "gadget");
+  service.cancel("r-1");
+  service.cancel("r-1");
+  const gadgetAfter = report().skus.find((row) => row.sku === "gadget");
+  assert.deepEqual(gadgetAfter, gadgetBefore);
+  assert.deepEqual(gadgetAfter.active, { count: 1, quantity: 2 });
+});
+
+test("the report is deterministic and sorted by sku regardless of insertion order", () => {
+  const build = (order) => {
+    const { store, service, report } = createInventorySystem();
+    for (const sku of order) {
+      store.addStock(sku, 5);
+    }
+    service.reserve({ reservationId: "r-1", sku: "b-item", quantity: 2 });
+    service.reserve({ reservationId: "r-2", sku: "a-item", quantity: 1 });
+    service.cancel("r-2");
+    return report();
+  };
+  const first = build(["b-item", "a-item", "c-item"]);
+  const second = build(["c-item", "a-item", "b-item"]);
+  assert.deepEqual(first, second);
+  assert.deepEqual(
+    first.skus.map((row) => row.sku),
+    ["a-item", "b-item", "c-item"]
+  );
+  assert.deepEqual(first, build(["b-item", "a-item", "c-item"]));
+});
+
+test("every row keeps received equal to available plus active plus fulfilled quantity", () => {
+  const { store, service, report } = createInventorySystem();
+  store.addStock("widget", 9);
+  service.reserve({ reservationId: "r-1", sku: "widget", quantity: 2 });
+  service.reserve({ reservationId: "r-2", sku: "widget", quantity: 3 });
+  service.reserve({ reservationId: "r-3", sku: "widget", quantity: 1 });
+  service.cancel("r-1");
+  service.cancel("r-1");
+  service.fulfill("r-2");
+  for (const row of report().skus) {
+    assert.equal(row.received, row.available + row.active.quantity + row.fulfilled.quantity);
+  }
+});