@demlik/tea 0.20.0 → 0.22.0

package/dist/pbt/index.js

@@ -1,6 +1,8 @@
-import '../chunk-DVNXEB7V.js';
-import { replay, applyCell, msgKeysOf } from '../chunk-RKVUVALV.js';
-import * as fc from 'fast-check';
+import { MAX_PICK, resolveGuided, foldEvents, lawTerminates, lawInvariant, lawTrace } from '../chunk-FXWDDNGD.js';
+export { foldEvents, lawInvariant, lawTerminates, lawTrace } from '../chunk-FXWDDNGD.js';
+import '../chunk-BVFS3ICC.js';
+import { msgKeysOf, structuralHash } from '../chunk-A3QPMX5M.js';
+import * as fc3 from 'fast-check';
 
 // src/pbt/arbitraries/ctx.ts
 function stubCtxThrowingProxy() {
@@ -33,93 +35,332 @@ function arbMsg(table, opts) {
     arbitrary: arb,
     weight: weights?.[key] ?? 1
   }));
-  return fc.oneof(...weighted);
+  return fc3.oneof(...weighted);
 }
 function arbConstantMsg(type) {
-  return fc.constant({ type });
+  return fc3.constant({ type });
 }
 function arbRecordMsg(type, fields) {
   const recordArbitraries = {
-    type: fc.constant(type),
+    type: fc3.constant(type),
     ...fields
   };
-  return fc.record(recordArbitraries);
+  return fc3.record(recordArbitraries);
 }
 function arbMsgSequence(msgArb, opts) {
   const minLength = opts?.minLength ?? 0;
   const maxLength = opts?.maxLength ?? 30;
   const prefix = opts?.prefix ?? [];
-  const tail = fc.array(msgArb, { minLength, maxLength });
+  const tail = fc3.array(msgArb, { minLength, maxLength, size: opts?.size });
   if (prefix.length === 0) return tail;
   return tail.map((arr) => [...prefix, ...arr]);
 }
-function arbGuidedSequence(_machine, _ctx, _cells, _opts) {
-  throw new Error(
-    "@demlik/tea/pbt: arbGuidedSequence is not implemented in v1. Use arbMsgSequence with an unguided arbMsg table for now; states that don't accept a given msg should noop in the reducer (mapped-type discipline)."
+function arbGuidedSequence(machine, ctx, cells, opts) {
+  const outside = Object.values(cells.outside ?? {});
+  const answers = Object.entries(cells.answers ?? {});
+  const answerers = answers.map(
+    ([cmdType, cell]) => ({ cmdType, make: cell.make })
   );
+  const arms = [];
+  if (outside.length > 0) {
+    arms.push({
+      weight: 1,
+      arbitrary: fc3.oneof(...outside).map((msg) => ({ kind: "outside", msg }))
+    });
+  }
+  if (answers.length > 0) {
+    arms.push({
+      weight: 2,
+      arbitrary: fc3.tuple(
+        fc3.nat(MAX_PICK),
+        fc3.tuple(...answers.map(([, cell]) => cell.draw))
+      ).map(
+        ([pick, values]) => ({
+          kind: "answer",
+          pick,
+          values
+        })
+      )
+    });
+  }
+  if (arms.length === 0) {
+    throw new Error(
+      "@demlik/tea/pbt: arbGuidedSequence got no cells, in `outside` or `answers`, so it could only draw empty lists."
+    );
+  }
+  const loaded = opts?.loaded ?? null;
+  return fc3.array(fc3.oneof(...arms), {
+    maxLength: opts?.maxLength ?? 60,
+    size: opts?.size ?? "max"
+  }).map((events) => resolveGuided(machine, ctx, loaded, answerers, events));
 }
 
-// src/pbt/runners/replay-fold.ts
-function foldEvents(machine, ctx, loaded, msgs) {
-  const { state: initialState } = replay(machine, {
-    msgs: [],
-    ctx,
-    loaded: loaded ?? null
-  });
-  const states = [initialState];
-  const steps = [];
-  let current = initialState;
-  for (const msg of msgs) {
-    const [next, emitted] = applyCell(machine, current, msg);
-    steps.push({ prev: current, msg, next, cmds: [...emitted] });
-    states.push(next);
-    current = next;
+// src/pbt/runners/msg-tally.ts
+function outline(value) {
+  if (Array.isArray(value)) return "[";
+  if (typeof value === "object" && value !== null) {
+    const proto = Object.getPrototypeOf(value);
+    if (proto === Object.prototype || proto === null) return "{";
+  }
+  return structuralHash(value);
+}
+function differs(a, b) {
+  if (a === b) return false;
+  const shape = outline(a);
+  if (shape !== outline(b)) return true;
+  if (shape === "[") return listsDiffer(a, b);
+  if (shape === "{") {
+    return recordsDiffer(
+      a,
+      b
+    );
+  }
+  return false;
+}
+var slotsOf = (list) => list.length === 1 && !(0 in list) ? [] : list;
+function listsDiffer(a, b) {
+  const left = slotsOf(a);
+  const right = slotsOf(b);
+  if (left.length !== right.length) return true;
+  for (let i = 0; i < left.length; i++) {
+    if (i in left !== i in right || differs(left[i], right[i])) return true;
   }
-  return { states, steps, finalState: current };
+  return false;
 }
+var seenAt = (record2, key) => Object.prototype.propertyIsEnumerable.call(record2, key) ? record2[key] : void 0;
+function recordsDiffer(a, b) {
+  for (const key of /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)])) {
+    if (differs(seenAt(a, key), seenAt(b, key))) return true;
+  }
+  return false;
+}
+function classify(step) {
+  if (step.cmds.length > 0) return { acted: true, refusal: null };
+  try {
+    return { acted: differs(step.prev, step.next), refusal: null };
+  } catch (refusal) {
+    return { acted: true, refusal };
+  }
+}
+var MsgTally = class {
+  #counts = /* @__PURE__ */ new Map();
+  #closed = false;
+  #refusal = null;
+  /** @param msgTypes The machine's Msg types, so one never drawn still reads zero. */
+  constructor(msgTypes) {
+    for (const type of msgTypes) this.#counts.set(type, { drawn: 0, acted: 0 });
+  }
+  /** Count one list's steps, unless the run has already failed. */
+  add(steps) {
+    if (this.#closed) return;
+    for (const step of steps) {
+      const { acted, refusal } = classify(step);
+      const count = this.#counts.get(step.msg.type) ?? { drawn: 0, acted: 0 };
+      this.#counts.set(step.msg.type, {
+        drawn: count.drawn + 1,
+        acted: count.acted + (acted ? 1 : 0)
+      });
+      this.#refusal ??= refusal;
+    }
+  }
+  /** The run has failed. Whatever comes next is shrinking. */
+  close() {
+    this.#closed = true;
+  }
+  /** Each Msg type's count: the machine's types first, then any other drawn. */
+  get counts() {
+    return new Map(this.#counts);
+  }
+  /**
+   * What `structuralHash` threw on the first value the comparison reached and
+   * couldn't read. Such a step counts as acted, since nothing shows it didn't, so
+   * "never acted" can't be trusted here.
+   */
+  get refusal() {
+    return this.#refusal;
+  }
+  /** The Msg types at zero acted, each with what it drew. */
+  get neverActed() {
+    return [...this.#counts].filter(([, count]) => count.acted === 0);
+  }
+};
 
 // src/pbt/runners/property.ts
-function resolveFcParams(opts) {
-  return {
-    numRuns: opts?.numRuns ?? 200,
-    ...opts?.seed !== void 0 ? { seed: opts.seed } : {}
+var PropertyFailure = class extends Error {
+  constructor(report, run, options) {
+    super(report, options);
+    this.run = run;
+  }
+  run;
+  name = "PropertyFailure";
+  _tag = "PropertyFailure";
+};
+var BrokenLaw = class extends Error {
+  constructor(report, reason) {
+    super(`${report}
+reason: ${reason}`);
+    this.report = report;
+    this.reason = reason;
+    this.name = "Error";
+  }
+  report;
+  reason;
+  toString() {
+    return `${this.name}: ${this.report}`;
+  }
+};
+function assertHolds(answer, report) {
+  if (answer === true || answer === null) return;
+  if (answer === false || answer === "") throw new Error(report());
+  throw new BrokenLaw(report(), answer);
+}
+function assertLaw(runner, broken) {
+  if (broken === null) return;
+  const report = `${runner}: ${broken.report}`;
+  throw broken.reason === null ? new Error(report) : new BrokenLaw(report, broken.reason);
+}
+function cmdFault(cmd, declared) {
+  const { type } = Object(cmd);
+  if (typeof cmd !== "object" || typeof type !== "string") {
+    return `${fc3.stringify(cmd)} isn't a Cmd: it has no string \`type\``;
+  }
+  if (declared === null || declared.has(type)) return null;
+  return `${fc3.stringify(cmd)} isn't in machine.cmds: [${[...declared].join(", ")}]`;
+}
+function assertSentCmds({ initCmds, steps }, declared) {
+  for (const cmd of initCmds) {
+    assertHolds(cmdFault(cmd, declared), () => "init sent a bad Cmd");
+  }
+  for (const { msg, cmds } of steps) {
+    for (const cmd of cmds) {
+      assertHolds(
+        cmdFault(cmd, declared),
+        () => `step msg=${fc3.stringify(msg)} sent a bad Cmd`
+      );
+    }
+  }
+}
+function isArbitrary(loaded) {
+  if (typeof loaded !== "object" || loaded === null) return false;
+  const { generate, shrink, canShrinkWithoutContext } = loaded;
+  return typeof generate === "function" && typeof shrink === "function" && typeof canShrinkWithoutContext === "function";
+}
+function withoutUndefined(settings) {
+  return Object.fromEntries(
+    Object.entries(settings).filter(([, value]) => value !== void 0)
+  );
+}
+function causeOf(details) {
+  const { errorWithCause, includeErrorInReport } = details.runConfiguration;
+  const major = Number(fc3.__version.split(".")[0]);
+  return (major >= 4 ? !includeErrorInReport : errorWithCause) ? { cause: details.errorInstance } : void 0;
+}
+function settle(details, tally) {
+  const run = {
+    numRuns: details.numRuns,
+    numShrinks: details.numShrinks,
+    seed: details.seed,
+    path: details.counterexamplePath,
+    msgCounts: tally.counts
   };
+  const { reporter } = fc3.readConfigureGlobal();
+  if (reporter) {
+    reporter(details);
+    return run;
+  }
+  const report = fc3.defaultReportMessage(details);
+  if (report === void 0) return run;
+  const cause = causeOf(details);
+  const broken = details.errorInstance;
+  throw new PropertyFailure(
+    cause && broken instanceof BrokenLaw ? `${report}
+
+reason: ${broken.reason}` : report,
+    run,
+    cause
+  );
 }
-function runProperty(machine, ctx, seqArb, opts, check) {
-  fc.assert(
-    fc.property(seqArb, (msgs) => {
-      check(foldEvents(machine, ctx, opts?.loaded ?? null, msgs));
-    }),
-    resolveFcParams(opts)
+function assertEveryTypeActed(run, tally) {
+  const { refusal, neverActed } = tally;
+  const ranOver = `after ${run.numRuns} runs, seed ${run.seed}`;
+  if (refusal !== null) {
+    const why = refusal instanceof Error ? refusal.message : String(refusal);
+    throw new PropertyFailure(
+      `Property failed ${ranOver}: failOnNeverActed can't tell what acted, because a state isn't plain data.
+
+${why}`,
+      run
+    );
+  }
+  if (neverActed.length === 0) return;
+  const named = neverActed.map(
+    ([type, { drawn }]) => `  ${type} (drawn ${drawn})`
+  );
+  throw new PropertyFailure(
+    `Property failed ${ranOver}: ${neverActed.length} Msg type(s) never acted:
+${named.join("\n")}`,
+    run
   );
 }
-function propertyTerminates(machine, ctx, seqArb, terminal, opts) {
-  runProperty(machine, ctx, seqArb, opts, ({ finalState }) => {
-    if (!terminal(finalState)) {
-      throw new Error(
-        `propertyTerminates: final state did not match terminal predicate. Final: ${JSON.stringify(finalState)}`
-      );
+function runProperty(machine, ctx, seqArb, opts, check2) {
+  const { loaded, failOnNeverActed, failOnUndeclaredCmd, ...settings } = opts ?? {};
+  const params = {
+    ...withoutUndefined(settings),
+    numRuns: settings.numRuns ?? 200
+  };
+  const tally = new MsgTally(msgKeysOf(machine));
+  const declared = failOnUndeclaredCmd && machine.cmds ? new Set(machine.cmds.map((def) => def.cmdType)) : null;
+  const runList = (msgs, start) => {
+    let steps = [];
+    try {
+      const result = foldEvents(machine, ctx, start, msgs);
+      steps = result.steps;
+      assertSentCmds(result, declared);
+      check2(result);
+    } catch (error) {
+      if (!fc3.PreconditionFailure.isFailure(error)) {
+        tally.add(steps);
+        tally.close();
+      }
+      throw error;
     }
+    tally.add(steps);
+  };
+  const checkActed = failOnNeverActed && !settings.path;
+  const finish = (details) => {
+    const run = settle(details, tally);
+    if (checkActed && !details.failed) assertEveryTypeActed(run, tally);
+    return run;
+  };
+  return isArbitrary(loaded) ? finish(
+    fc3.check(
+      fc3.property(seqArb, loaded, (msgs, drawn) => {
+        runList(msgs, drawn);
+      }),
+      params
+    )
+  ) : finish(
+    fc3.check(
+      fc3.property(seqArb, (msgs) => {
+        runList(msgs, loaded ?? null);
+      }),
+      params
+    )
+  );
+}
+function propertyTerminates(machine, ctx, seqArb, terminal, opts) {
+  return runProperty(machine, ctx, seqArb, opts, (fold) => {
+    assertLaw("propertyTerminates", lawTerminates(fold, terminal));
   });
 }
 function propertyInvariant(machine, ctx, seqArb, invariant, opts) {
-  runProperty(machine, ctx, seqArb, opts, ({ steps }) => {
-    for (const step of steps) {
-      if (!invariant(step)) {
-        throw new Error(
-          `propertyInvariant: failed at step msg=${JSON.stringify(step.msg)} prev=${JSON.stringify(step.prev)} next=${JSON.stringify(step.next)} cmds=${JSON.stringify(step.cmds)}`
-        );
-      }
-    }
+  return runProperty(machine, ctx, seqArb, opts, (fold) => {
+    assertLaw("propertyInvariant", lawInvariant(fold, invariant));
   });
 }
 function propertyTrace(machine, ctx, seqArb, predicate, opts) {
-  runProperty(machine, ctx, seqArb, opts, ({ steps, finalState }) => {
-    if (!predicate(steps, finalState)) {
-      throw new Error(
-        `propertyTrace: predicate failed on trace length=${steps.length}, final=${JSON.stringify(finalState)}`
-      );
-    }
+  return runProperty(machine, ctx, seqArb, opts, (fold) => {
+    assertLaw("propertyTrace", lawTrace(fold, predicate));
   });
 }
 
@@ -128,6 +369,6 @@ function msgTypeKeys(machine) {
   return msgKeysOf(machine);
 }
 
-export { arbConstantMsg, arbGuidedSequence, arbMsg, arbMsgSequence, arbRecordMsg, foldEvents, msgTypeKeys, propertyInvariant, propertyTerminates, propertyTrace, stubCtxThrowingProxy };
+export { PropertyFailure, arbConstantMsg, arbGuidedSequence, arbMsg, arbMsgSequence, arbRecordMsg, msgTypeKeys, propertyInvariant, propertyTerminates, propertyTrace, stubCtxThrowingProxy };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map