@reventlessdev/reventless-gwt 1.0.0-alpha.100

package/src/Flow_GWT.res.mjs

@@ -0,0 +1,604 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
+import * as DcbDecode$Reventless from "@reventlessdev/reventless-spec/src/components/DcbDecode.res.mjs";
+import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
+import * as JestBind$ReventlessGwt from "./JestBind.res.mjs";
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as StubRuntime$ReventlessGwt from "./StubRuntime.res.mjs";
+import * as DcbScopeInference$Reventless from "@reventlessdev/reventless-spec/src/components/DcbScopeInference.res.mjs";
+import * as Projection_GWT$ReventlessGwt from "./Projection_GWT.res.mjs";
+
+S.enableJson();
+
+let emptyState_log = [];
+
+let emptyState_lastEvents = [];
+
+let emptyState_lastCommands = [];
+
+let emptyState_lastPublic = [];
+
+let emptyState = {
+  log: emptyState_log,
+  outcome: Outcome$ReventlessGwt.pass,
+  lastEvents: emptyState_lastEvents,
+  lastError: undefined,
+  lastCommands: emptyState_lastCommands,
+  lastPublic: emptyState_lastPublic,
+  lastAggregateId: undefined
+};
+
+let start = Promise.resolve(emptyState);
+
+function recordOutcome(s, o) {
+  let match = s.outcome;
+  if (match.TAG === "Ok") {
+    return {
+      log: s.log,
+      outcome: o,
+      lastEvents: s.lastEvents,
+      lastError: s.lastError,
+      lastCommands: s.lastCommands,
+      lastPublic: s.lastPublic,
+      lastAggregateId: s.lastAggregateId
+    };
+  } else {
+    return s;
+  }
+}
+
+function entryMatchesQuery(entry, query) {
+  if (query.length === 0) {
+    return true;
+  } else {
+    return query.some(qi => {
+      let types = qi.eventTypes;
+      let typeMatch = types !== undefined ? types.includes(entry.eventType) : true;
+      let tags = qi.tags;
+      let tagMatch = tags !== undefined ? tags.every(tag => entry.tags.some(et => {
+          if (et.key === tag.key) {
+            return et.value === tag.value;
+          } else {
+            return false;
+          }
+        })) : true;
+      if (typeMatch) {
+        return tagMatch;
+      } else {
+        return false;
+      }
+    });
+  }
+}
+
+function appendEvents(log, events, schema) {
+  return log.concat(events.map(ev => {
+    let json = Message$ReventlessCore.encode(ev, schema);
+    return {
+      eventType: Message$Reventless.variantNameOfJson(json),
+      tags: DcbTag$Reventless.extractTagsExpanded(schema, ev),
+      json: json,
+      aggregateId: undefined
+    };
+  }));
+}
+
+function appendAggregateEvents(log, id, events, schema) {
+  return log.concat(events.map(ev => {
+    let json = Message$ReventlessCore.encode(ev, schema);
+    return {
+      eventType: Message$Reventless.variantNameOfJson(json),
+      tags: DcbTag$Reventless.extractTagsExpanded(schema, ev),
+      json: json,
+      aggregateId: id
+    };
+  }));
+}
+
+function decodeMatching(log, decoder, query) {
+  return Stdlib_Array.filterMap(log, entry => {
+    if (!entryMatchesQuery(entry, query)) {
+      return;
+    }
+    let d = entry.json;
+    let data;
+    data = typeof d === "object" && d !== null && !Array.isArray(d) ? d : ({});
+    return decoder.decode(entry.eventType, data);
+  });
+}
+
+function decodeAggregateMatching(log, id, decoder) {
+  return Stdlib_Array.filterMap(log, entry => {
+    let eid = entry.aggregateId;
+    if (eid === undefined) {
+      return;
+    }
+    if (eid !== id) {
+      return;
+    }
+    let d = entry.json;
+    let data;
+    data = typeof d === "object" && d !== null && !Array.isArray(d) ? d : ({});
+    return decoder.decode(entry.eventType, data);
+  });
+}
+
+function test(name, timeout, body) {
+  JestBind$ReventlessGwt.testPromise("Flow", name, timeout, async () => (await body()).outcome);
+}
+
+function CommandStep(Spec) {
+  return Behavior => {
+    let consumedDecoder = DcbDecode$Reventless.makeDecoder(Spec.consumedEventSchema);
+    let consumedEventTypes = consumedDecoder.eventTypes;
+    let givenEvents = async (flowP, events) => {
+      let s = await flowP;
+      return {
+        log: appendEvents(s.log, events, Spec.eventSchema),
+        outcome: s.outcome,
+        lastEvents: s.lastEvents,
+        lastError: s.lastError,
+        lastCommands: s.lastCommands,
+        lastPublic: s.lastPublic,
+        lastAggregateId: s.lastAggregateId
+      };
+    };
+    let scopeShape = DcbTag$Reventless.sliceShapeFromSchemas("", Spec.commandSchema, Spec.consumedEventSchema, Spec.eventSchema);
+    let set = new Set();
+    DcbTag$Reventless.extractCrossPartitionTagKeys(Spec.eventSchema).forEach(k => {
+      set.add(k);
+    });
+    DcbScopeInference$Reventless.crossPartitionForSlice(scopeShape).forEach(k => {
+      set.add(k);
+    });
+    let crossPartitionTagKeys = Array.from(set.values()).toSorted(Primitive_string.compare);
+    let tagKeysByEventType = DcbScopeInference$Reventless.infer([scopeShape]).tagKeysByEventType;
+    let whenCommand = async (flowP, command) => {
+      let s = await flowP;
+      let query = DcbTag$Reventless.buildQueryFromCommand(consumedEventTypes, Spec.commandSchema, command, tagKeysByEventType, crossPartitionTagKeys);
+      let history = decodeMatching(s.log, consumedDecoder, query);
+      let state = Stdlib_Array.reduce(history, Behavior.initialState, Behavior.evolve);
+      let events = Behavior.decide(state, command);
+      if (events.TAG !== "Ok") {
+        return {
+          log: s.log,
+          outcome: s.outcome,
+          lastEvents: [],
+          lastError: Message$ReventlessCore.encode(events._0, Spec.errorSchema),
+          lastCommands: s.lastCommands,
+          lastPublic: s.lastPublic,
+          lastAggregateId: undefined
+        };
+      }
+      let events$1 = events._0;
+      return {
+        log: appendEvents(s.log, events$1, Spec.eventSchema),
+        outcome: s.outcome,
+        lastEvents: events$1.map(e => Message$ReventlessCore.encode(e, Spec.eventSchema)),
+        lastError: undefined,
+        lastCommands: s.lastCommands,
+        lastPublic: s.lastPublic,
+        lastAggregateId: undefined
+      };
+    };
+    let thenEvents = async (flowP, expected) => {
+      let s = await flowP;
+      let expectedJson = expected.map(e => Message$ReventlessCore.encode(e, Spec.eventSchema));
+      let err = s.lastError;
+      let o = err !== undefined ? Outcome$ReventlessGwt.fail({
+          TAG: "ErrorMismatch",
+          expected: null,
+          actual: err,
+          actualEvents: s.lastEvents
+        }) : (
+          Primitive_object.equal(s.lastEvents, expectedJson) ? Outcome$ReventlessGwt.pass : Outcome$ReventlessGwt.fail({
+              TAG: "EventsMismatch",
+              expected: expectedJson,
+              actual: s.lastEvents
+            })
+        );
+      return recordOutcome(s, o);
+    };
+    let thenEvent = (flowP, event) => thenEvents(flowP, [event]);
+    let thenError = async (flowP, expected) => {
+      let s = await flowP;
+      let expJson = Message$ReventlessCore.encode(expected, Spec.errorSchema);
+      let actual = s.lastError;
+      let o = actual !== undefined ? (
+          Primitive_object.equal(actual, expJson) ? Outcome$ReventlessGwt.pass : Outcome$ReventlessGwt.fail({
+              TAG: "ErrorMismatch",
+              expected: expJson,
+              actual: actual,
+              actualEvents: s.lastEvents
+            })
+        ) : Outcome$ReventlessGwt.fail({
+          TAG: "ErrorMismatch",
+          expected: expJson,
+          actual: undefined,
+          actualEvents: s.lastEvents
+        });
+      return recordOutcome(s, o);
+    };
+    return {
+      consumedDecoder: consumedDecoder,
+      consumedEventTypes: consumedEventTypes,
+      givenEvents: givenEvents,
+      scopeShape: scopeShape,
+      crossPartitionTagKeys: crossPartitionTagKeys,
+      tagKeysByEventType: tagKeysByEventType,
+      whenCommand: whenCommand,
+      thenEvents: thenEvents,
+      thenEvent: thenEvent,
+      thenError: thenError
+    };
+  };
+}
+
+function AggregateCommandStep(Spec) {
+  return Behavior => {
+    let aggregateDecoder = DcbDecode$Reventless.makeDecoder(Spec.eventSchema);
+    let givenEvents = async (flowP, id, events) => {
+      let s = await flowP;
+      return {
+        log: appendAggregateEvents(s.log, id, events, Spec.eventSchema),
+        outcome: s.outcome,
+        lastEvents: s.lastEvents,
+        lastError: s.lastError,
+        lastCommands: s.lastCommands,
+        lastPublic: s.lastPublic,
+        lastAggregateId: s.lastAggregateId
+      };
+    };
+    let whenCommand = async (flowP, id, command) => {
+      let s = await flowP;
+      let history = decodeAggregateMatching(s.log, id, aggregateDecoder);
+      let state = Stdlib_Array.reduce(history, Behavior.initialState, Behavior.evolve);
+      let events = Behavior.decide(state, command);
+      if (events.TAG !== "Ok") {
+        return {
+          log: s.log,
+          outcome: s.outcome,
+          lastEvents: [],
+          lastError: Message$ReventlessCore.encode(events._0, Spec.errorSchema),
+          lastCommands: s.lastCommands,
+          lastPublic: s.lastPublic,
+          lastAggregateId: id
+        };
+      }
+      let events$1 = events._0;
+      return {
+        log: appendAggregateEvents(s.log, id, events$1, Spec.eventSchema),
+        outcome: s.outcome,
+        lastEvents: events$1.map(e => Message$ReventlessCore.encode(e, Spec.eventSchema)),
+        lastError: undefined,
+        lastCommands: s.lastCommands,
+        lastPublic: s.lastPublic,
+        lastAggregateId: id
+      };
+    };
+    let thenEvents = async (flowP, expected) => {
+      let s = await flowP;
+      let expectedJson = expected.map(e => Message$ReventlessCore.encode(e, Spec.eventSchema));
+      let err = s.lastError;
+      let o = err !== undefined ? Outcome$ReventlessGwt.fail({
+          TAG: "ErrorMismatch",
+          expected: null,
+          actual: err,
+          actualEvents: s.lastEvents
+        }) : (
+          Primitive_object.equal(s.lastEvents, expectedJson) ? Outcome$ReventlessGwt.pass : Outcome$ReventlessGwt.fail({
+              TAG: "EventsMismatch",
+              expected: expectedJson,
+              actual: s.lastEvents
+            })
+        );
+      return recordOutcome(s, o);
+    };
+    let thenEvent = (flowP, event) => thenEvents(flowP, [event]);
+    let thenNoEvent = async flowP => {
+      let s = await flowP;
+      let err = s.lastError;
+      let o = err !== undefined ? Outcome$ReventlessGwt.fail({
+          TAG: "ErrorMismatch",
+          expected: null,
+          actual: err,
+          actualEvents: s.lastEvents
+        }) : (
+          s.lastEvents.length === 0 ? Outcome$ReventlessGwt.pass : Outcome$ReventlessGwt.fail({
+              TAG: "NoEventExpected",
+              actual: s.lastEvents
+            })
+        );
+      return recordOutcome(s, o);
+    };
+    let thenError = async (flowP, expected) => {
+      let s = await flowP;
+      let expJson = Message$ReventlessCore.encode(expected, Spec.errorSchema);
+      let actual = s.lastError;
+      let o = actual !== undefined ? (
+          Primitive_object.equal(actual, expJson) ? Outcome$ReventlessGwt.pass : Outcome$ReventlessGwt.fail({
+              TAG: "ErrorMismatch",
+              expected: expJson,
+              actual: actual,
+              actualEvents: s.lastEvents
+            })
+        ) : Outcome$ReventlessGwt.fail({
+          TAG: "ErrorMismatch",
+          expected: expJson,
+          actual: undefined,
+          actualEvents: s.lastEvents
+        });
+      return recordOutcome(s, o);
+    };
+    return {
+      aggregateDecoder: aggregateDecoder,
+      givenEvents: givenEvents,
+      whenCommand: whenCommand,
+      thenEvents: thenEvents,
+      thenEvent: thenEvent,
+      thenNoEvent: thenNoEvent,
+      thenError: thenError
+    };
+  };
+}
+
+function AutomationStep(Spec) {
+  let consumedDecoder = DcbDecode$Reventless.makeDecoder(Spec.consumedEventSchema);
+  let whenReacts = async flowP => {
+    let s = await flowP;
+    let events = decodeMatching(s.log, consumedDecoder, []);
+    let collected = events.map(e => Spec.collect(e)).flat();
+    let resolvedIds = Stdlib_Array.filterMap(events, e => Spec.resolve(e));
+    let pending = collected.filter(param => !resolvedIds.includes(param[0]));
+    let commands = Stdlib_Array.filterMap(pending, param => Spec.process(param[0], param[1]));
+    return {
+      log: s.log,
+      outcome: s.outcome,
+      lastEvents: s.lastEvents,
+      lastError: s.lastError,
+      lastCommands: commands.map(param => Message$ReventlessCore.encode(param[1], Spec.commandSchema)),
+      lastPublic: s.lastPublic,
+      lastAggregateId: s.lastAggregateId
+    };
+  };
+  let thenIssuesCommands = async (flowP, expected) => {
+    let s = await flowP;
+    let expJson = expected.map(c => Message$ReventlessCore.encode(c, Spec.commandSchema));
+    let o = Primitive_object.equal(s.lastCommands, expJson) ? Outcome$ReventlessGwt.pass : Outcome$ReventlessGwt.fail({
+        TAG: "EventsMismatch",
+        expected: expJson,
+        actual: s.lastCommands
+      });
+    return recordOutcome(s, o);
+  };
+  let thenIssuesCommand = (flowP, command) => thenIssuesCommands(flowP, [command]);
+  let thenIssuesNoCommand = flowP => thenIssuesCommands(flowP, []);
+  return {
+    consumedDecoder: consumedDecoder,
+    whenReacts: whenReacts,
+    thenIssuesCommands: thenIssuesCommands,
+    thenIssuesCommand: thenIssuesCommand,
+    thenIssuesNoCommand: thenIssuesNoCommand
+  };
+}
+
+function ViewStep(Spec) {
+  return Projection => {
+    let P = Projection_GWT$ReventlessGwt.Make(Spec)(Projection);
+    let consumedDecoder = DcbDecode$Reventless.makeDecoder(Spec.consumedEventSchema);
+    let encState = st => Message$ReventlessCore.encode(st, Spec.stateSchema);
+    let thenViewStates = async (flowP, id, expected) => {
+      let s = await flowP;
+      let events = decodeMatching(s.log, consumedDecoder, []);
+      let store = await P.givenEvents(events);
+      let actual = Stdlib_Option.getOr(store[id], []).map(encState);
+      let expectedJson = expected.map(encState);
+      let o = Primitive_object.equal(actual, expectedJson) ? Outcome$ReventlessGwt.pass : Outcome$ReventlessGwt.fail({
+          TAG: "StateMismatch",
+          key: id,
+          expected: expectedJson,
+          actual: actual
+        });
+      return recordOutcome(s, o);
+    };
+    let thenViewState = (flowP, id, state) => thenViewStates(flowP, id, [state]);
+    return {
+      P: P,
+      consumedDecoder: consumedDecoder,
+      encState: encState,
+      thenViewStates: thenViewStates,
+      thenViewState: thenViewState
+    };
+  };
+}
+
+function OutboundStep(Spec) {
+  let consumedDecoder = DcbDecode$Reventless.makeDecoder(Spec.consumedEventSchema);
+  let encItems = arr => arr.map(param => [
+    param[0],
+    Message$ReventlessCore.encode(param[1], Spec.outboundItemSchema)
+  ]);
+  let thenOutbound = async (flowP, expected) => {
+    let s = await flowP;
+    let events = decodeMatching(s.log, consumedDecoder, []);
+    let collected = events.map(e => Spec.collect(e)).flat();
+    let actual = encItems(collected);
+    let expectedJson = encItems(expected);
+    let o = Primitive_object.equal(actual, expectedJson) ? Outcome$ReventlessGwt.pass : Outcome$ReventlessGwt.fail({
+        TAG: "TodoMismatch",
+        expected: expectedJson,
+        actual: actual
+      });
+    return recordOutcome(s, o);
+  };
+  let thenOutboundNothing = flowP => thenOutbound(flowP, []);
+  return {
+    consumedDecoder: consumedDecoder,
+    encItems: encItems,
+    thenOutbound: thenOutbound,
+    thenOutboundNothing: thenOutboundNothing
+  };
+}
+
+function sortJson(arr) {
+  return arr.toSorted((a, b) => Primitive_string.compare(JSON.stringify(a), JSON.stringify(b)));
+}
+
+function ExtensionPointStep(M) {
+  let delegateDecoder = DcbDecode$Reventless.makeDecoder(M.Delegate.eventSchema);
+  let runMapping = async (sourceId, events) => {
+    let f = M.mapOutgoingEvent;
+    if (f === undefined) {
+      return [];
+    }
+    let actions = events.map(ev => f(sourceId, ev, StubRuntime$ReventlessGwt.meta, StubRuntime$ReventlessGwt.queryEngine)).flat();
+    return (await Promise.all(actions.map(async action => {
+      switch (action.TAG) {
+        case "PublishEvent" :
+          return [action._1];
+        case "PublishEventAsync" :
+          let match = await action._0;
+          return [match[1]];
+        case "HandleDirective" :
+          return [];
+      }
+    }))).flat();
+  };
+  let whenPublishedThrough = async flowP => {
+    let s = await flowP;
+    let delegateEvents = Stdlib_Array.filterMap(s.lastEvents, json => {
+      let data;
+      data = typeof json === "object" && json !== null && !Array.isArray(json) ? json : ({});
+      return delegateDecoder.decode(Message$Reventless.variantNameOfJson(json), data);
+    });
+    let sourceId = Stdlib_Option.getOr(s.lastAggregateId, "gwt-id");
+    let publicEvents = await runMapping(sourceId, delegateEvents);
+    return {
+      log: appendEvents(s.log, publicEvents, M.ExtensionPoint.eventSchema),
+      outcome: s.outcome,
+      lastEvents: s.lastEvents,
+      lastError: s.lastError,
+      lastCommands: s.lastCommands,
+      lastPublic: publicEvents.map(e => Message$ReventlessCore.encode(e, M.ExtensionPoint.eventSchema)),
+      lastAggregateId: s.lastAggregateId
+    };
+  };
+  let thenPublicEvents = async (flowP, expected) => {
+    let s = await flowP;
+    let expJson = expected.map(e => Message$ReventlessCore.encode(e, M.ExtensionPoint.eventSchema));
+    let o = Primitive_object.equal(sortJson(s.lastPublic), sortJson(expJson)) ? Outcome$ReventlessGwt.pass : Outcome$ReventlessGwt.fail({
+        TAG: "PublishedActionsMismatch",
+        expected: expJson,
+        actual: s.lastPublic
+      });
+    return recordOutcome(s, o);
+  };
+  let thenPublicEvent = (flowP, event) => thenPublicEvents(flowP, [event]);
+  return {
+    delegateDecoder: delegateDecoder,
+    runMapping: runMapping,
+    whenPublishedThrough: whenPublishedThrough,
+    thenPublicEvents: thenPublicEvents,
+    thenPublicEvent: thenPublicEvent
+  };
+}
+
+function ExtensionStep(M) {
+  let epDecoder = DcbDecode$Reventless.makeDecoder(M.ExtensionPoint.eventSchema);
+  let encCmd = c => Message$ReventlessCore.encode(c, M.Delegate.commandSchema);
+  let whenExtensionReacts = async flowP => {
+    let s = await flowP;
+    let epEvents = Stdlib_Array.filterMap(s.lastPublic, json => {
+      let data;
+      data = typeof json === "object" && json !== null && !Array.isArray(json) ? json : ({});
+      return epDecoder.decode(Message$Reventless.variantNameOfJson(json), data);
+    });
+    let actions = epEvents.map(ev => M.mapIncomingEvent("gwt-id", ev, StubRuntime$ReventlessGwt.meta, StubRuntime$ReventlessGwt.pluginDefinition, StubRuntime$ReventlessGwt.queryEngine)).flat();
+    let nested = await Promise.all(actions.map(async action => {
+      switch (action.TAG) {
+        case "PublishAggregateCommand" :
+          return [Message$ReventlessCore.encode(action._1, M.Delegate.commandSchema)];
+        case "PublishAggregateCommandAsync" :
+          let match = await action._0;
+          return [Message$ReventlessCore.encode(match[1], M.Delegate.commandSchema)];
+        case "PublishAggregateCommandsAsync" :
+          return (await action._0).map(param => Message$ReventlessCore.encode(param[1], M.Delegate.commandSchema));
+        case "PublishStateChangeSliceCommand" :
+          return [Message$ReventlessCore.encode(action._0, M.Delegate.commandSchema)];
+        case "PublishStateChangeSliceCommandAsync" :
+          let cmd = await action._0;
+          return [Message$ReventlessCore.encode(cmd, M.Delegate.commandSchema)];
+        case "PublishStateChangeSliceCommandsAsync" :
+          return (await action._0).map(encCmd);
+        default:
+          return [];
+      }
+    }));
+    return {
+      log: s.log,
+      outcome: s.outcome,
+      lastEvents: s.lastEvents,
+      lastError: s.lastError,
+      lastCommands: nested.flat(),
+      lastPublic: s.lastPublic,
+      lastAggregateId: s.lastAggregateId
+    };
+  };
+  let thenIssuesCommands = async (flowP, expected) => {
+    let s = await flowP;
+    let expJson = expected.map(encCmd);
+    let o = Primitive_object.equal(sortJson(s.lastCommands), sortJson(expJson)) ? Outcome$ReventlessGwt.pass : Outcome$ReventlessGwt.fail({
+        TAG: "PublishedActionsMismatch",
+        expected: expJson,
+        actual: s.lastCommands
+      });
+    return recordOutcome(s, o);
+  };
+  let thenIssuesCommand = (flowP, command) => thenIssuesCommands(flowP, [command]);
+  let thenIssuesNoCommand = flowP => thenIssuesCommands(flowP, []);
+  return {
+    epDecoder: epDecoder,
+    encCmd: encCmd,
+    whenExtensionReacts: whenExtensionReacts,
+    thenIssuesCommands: thenIssuesCommands,
+    thenIssuesCommand: thenIssuesCommand,
+    thenIssuesNoCommand: thenIssuesNoCommand
+  };
+}
+
+let EPMapping;
+
+let ExtMapping;
+
+let describe = JestBind$ReventlessGwt.describe;
+
+export {
+  EPMapping,
+  ExtMapping,
+  emptyState,
+  start,
+  recordOutcome,
+  entryMatchesQuery,
+  appendEvents,
+  appendAggregateEvents,
+  decodeMatching,
+  decodeAggregateMatching,
+  describe,
+  test,
+  CommandStep,
+  AggregateCommandStep,
+  AutomationStep,
+  ViewStep,
+  OutboundStep,
+  sortJson,
+  ExtensionPointStep,
+  ExtensionStep,
+}
+/*  Not a pure module */

package/src/FormatterHuman.res

@@ -0,0 +1,109 @@
+// Terminal-coloured human formatter. Shipped as the default output for
+// `reventless-gwt run`. Uses picocolors for ANSI colours — it is a tiny
+// zero-dependency helper that transparently disables colour when stdout
+// is not a TTY.
+
+type colour = string => string
+type picocolors = {
+  red: colour,
+  green: colour,
+  yellow: colour,
+  cyan: colour,
+  gray: colour,
+  bold: colour,
+  dim: colour,
+}
+
+@module("picocolors") external pc: picocolors = "default"
+
+@val external processStdout: {"write": string => unit} = "process.stdout"
+@val external processCwd: unit => string = "process.cwd"
+@module("node:path") external pathBasename: string => string = "basename"
+@module("node:path") external pathRelative: (string, string) => string = "relative"
+
+let write = (s: string) => processStdout["write"](s)
+let writeLine = (s: string) => write(s ++ "\n")
+
+let formatFilePath = (abs: string) => {
+  let base = pathBasename(abs)
+  let name = if String.endsWith(base, ".res.mjs") {
+    String.slice(base, ~start=0, ~end=String.length(base) - 8)
+  } else {
+    base
+  }
+  let rel = pathRelative(processCwd(), abs)
+  `${name} - ${rel}`
+}
+
+let formatLocation = (loc: option<Collector.location>) =>
+  switch loc {
+  | None => ""
+  | Some(l) => `${l.file}:${Int.toString(l.line)}`
+  }
+
+// Frames one normalized field as a terminal line. Labels are padded so values
+// align at column 12 (`key:`, `expected:`, `actual:`); `error:` is its own
+// shorter form and the `Throw` stack is dumped raw beneath it.
+let renderField = (f: MismatchRender.field) =>
+  switch f {
+  | Expected(v) => `  expected: ${v}`
+  | Actual(v) => `  actual:   ${v}`
+  | Key(k) => `  key:      "${k}"`
+  | ExpectedNoEvents => "  expected no events"
+  | Error(e) => `  error: ${e}`
+  | Stack(s) => s
+  }
+
+let renderMismatch = (m: Outcome.mismatch) =>
+  MismatchRender.normalize(m).fields->Array.map(renderField)->Array.join("\n")
+
+let emitTest = (t: RunnerTypes.testResult) => {
+  let path = t.describePath->Array.join(" > ")
+  let full = path == "" ? t.name : `${path} > ${t.name}`
+  let loc = formatLocation(t.location)
+  let locStr = loc == "" ? "" : ` ${pc.dim(loc)}`
+  switch t.status {
+  | Pass => writeLine(`  ${pc.green("✓")} ${full}${locStr}`)
+  | Skip =>
+    writeLine(
+      `  ${pc.yellow("○")} ${full}${locStr} ${pc.dim(
+          t.skipReason->Option.getOr("skipped"),
+        )}`,
+    )
+  | Fail => {
+      writeLine(`  ${pc.red("✗")} ${pc.bold(full)}${locStr}`)
+      switch t.mismatch {
+      | Some(m) => {
+          writeLine("")
+          writeLine(renderMismatch(m))
+          let hint = Hint.forMismatch(~slice=?t.slice, m)
+          writeLine("")
+          writeLine(`  ${pc.cyan(Hint.format(hint))}`)
+          writeLine("")
+        }
+      | None => ()
+      }
+    }
+  }
+}
+
+let emitFile = (f: RunnerTypes.fileResult) => {
+  writeLine("")
+  writeLine(pc.bold(formatFilePath(f.path)))
+  f.tests->Array.forEach(emitTest)
+}
+
+let emitSummary = (s: RunnerTypes.summary) => {
+  writeLine("")
+  let line = `Tests: ${Int.toString(s.total)}  ${pc.green(
+      Int.toString(s.passed) ++ " passed",
+    )}  ${pc.red(Int.toString(s.failed) ++ " failed")}  ${pc.yellow(
+      Int.toString(s.skipped) ++ " skipped",
+    )}  (${Float.toString(s.durationMs)} ms)`
+  writeLine(line)
+}
+
+let emit = (r: RunnerTypes.runResult) => {
+  r.files->Array.forEach(emitFile)
+  emitSummary(r.summary)
+}