@reventlessdev/reventless-gwt 1.0.0-alpha.100

package/src/FormatterHuman.res.mjs

@@ -0,0 +1,115 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodepath from "node:path";
+import Picocolors from "picocolors";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Hint$ReventlessGwt from "./Hint.res.mjs";
+import * as MismatchRender$ReventlessGwt from "./MismatchRender.res.mjs";
+
+function write(s) {
+  process.stdout.write(s);
+}
+
+function writeLine(s) {
+  process.stdout.write(s + "\n");
+}
+
+function formatFilePath(abs) {
+  let base = Nodepath.basename(abs);
+  let name = base.endsWith(".res.mjs") ? base.slice(0, base.length - 8 | 0) : base;
+  let rel = Nodepath.relative(process.cwd(), abs);
+  return name + ` - ` + rel;
+}
+
+function formatLocation(loc) {
+  if (loc !== undefined) {
+    return loc.file + `:` + loc.line.toString();
+  } else {
+    return "";
+  }
+}
+
+function renderField(f) {
+  if (typeof f !== "object") {
+    return "  expected no events";
+  }
+  switch (f.TAG) {
+    case "Expected" :
+      return `  expected: ` + f._0;
+    case "Actual" :
+      return `  actual:   ` + f._0;
+    case "Key" :
+      return `  key:      "` + f._0 + `"`;
+    case "Error" :
+      return `  error: ` + f._0;
+    case "Stack" :
+      return f._0;
+  }
+}
+
+function renderMismatch(m) {
+  return MismatchRender$ReventlessGwt.normalize(m).fields.map(renderField).join("\n");
+}
+
+function emitTest(t) {
+  let path = t.describePath.join(" > ");
+  let full = path === "" ? t.name : path + ` > ` + t.name;
+  let loc = formatLocation(t.location);
+  let locStr = loc === "" ? "" : ` ` + Picocolors.dim(loc);
+  let match = t.status;
+  switch (match) {
+    case "Pass" :
+      let s = `  ` + Picocolors.green("✓") + ` ` + full + locStr;
+      return process.stdout.write(s + "\n");
+    case "Fail" :
+      let s$1 = `  ` + Picocolors.red("✗") + ` ` + Picocolors.bold(full) + locStr;
+      process.stdout.write(s$1 + "\n");
+      let m = t.mismatch;
+      if (m === undefined) {
+        return;
+      }
+      process.stdout.write("\n");
+      let s$2 = renderMismatch(m);
+      process.stdout.write(s$2 + "\n");
+      let hint = Hint$ReventlessGwt.forMismatch(t.slice, m);
+      process.stdout.write("\n");
+      let s$3 = `  ` + Picocolors.cyan(Hint$ReventlessGwt.format(hint));
+      process.stdout.write(s$3 + "\n");
+      return process.stdout.write("\n");
+    case "Skip" :
+      let s$4 = `  ` + Picocolors.yellow("○") + ` ` + full + locStr + ` ` + Picocolors.dim(Stdlib_Option.getOr(t.skipReason, "skipped"));
+      return process.stdout.write(s$4 + "\n");
+  }
+}
+
+function emitFile(f) {
+  process.stdout.write("\n");
+  let s = Picocolors.bold(formatFilePath(f.path));
+  process.stdout.write(s + "\n");
+  f.tests.forEach(emitTest);
+}
+
+function emitSummary(s) {
+  process.stdout.write("\n");
+  let s$1 = `Tests: ` + s.total.toString() + `  ` + Picocolors.green(s.passed.toString() + " passed") + `  ` + Picocolors.red(s.failed.toString() + " failed") + `  ` + Picocolors.yellow(s.skipped.toString() + " skipped") + `  (` + s.durationMs.toString() + ` ms)`;
+  process.stdout.write(s$1 + "\n");
+}
+
+function emit(r) {
+  r.files.forEach(emitFile);
+  emitSummary(r.summary);
+}
+
+export {
+  write,
+  writeLine,
+  formatFilePath,
+  formatLocation,
+  renderField,
+  renderMismatch,
+  emitTest,
+  emitFile,
+  emitSummary,
+  emit,
+}
+/* node:path Not a pure module */

package/src/FormatterJson.res

@@ -0,0 +1,264 @@
+// Structured JSON formatter — the AI loop's primary input and the substrate
+// for any programmatic consumer. Ships both a single-envelope mode and an
+// NDJSON streaming mode (`--stream`). Shape matches §3.3 of
+// `docs/analysis/given-when-then-specifications.md`.
+
+// 1.1.0 — additive: `PublishedActionsMismatch` mismatch kind for the
+// Delegate_GWT / cross-plugin Flow_GWT boundary steps.
+// The default the emitted envelope carries; the `--schema-version` CLI flag
+// overrides it (threaded through `emit` / `streamRunStart`) so a consumer can
+// pin the schema version its AI prompt was built against.
+let defaultSchemaVersion = "1.1.0"
+
+@val external processStdout: {"write": string => unit} = "process.stdout"
+let write = (s: string) => processStdout["write"](s)
+let writeLine = (s: string) => write(s ++ "\n")
+
+// Re-render a JSON value as a dual-rendered `{type, payload, rendered}` entry.
+let renderValue = (j: JSON.t): JSON.t => {
+  let obj = Dict.make()
+  switch j {
+  | Object(dict) =>
+    switch dict->Dict.get("TAG") {
+    | Some(String(tag)) => {
+        obj->Dict.set("type", JSON.Encode.string(tag))
+        let payloadKeys =
+          dict
+          ->Dict.keysToArray
+          ->Array.filter(k => k != "TAG" && String.startsWith(k, "_"))
+        let payload = switch payloadKeys {
+        | [] => JSON.Encode.null
+        | ["_0"] =>
+          dict->Dict.get("_0")->Option.getOr(JSON.Encode.null)
+        | _ => {
+            let payloadDict = Dict.make()
+            payloadKeys->Array.forEach(k =>
+              payloadDict->Dict.set(
+                k,
+                dict->Dict.get(k)->Option.getOr(JSON.Encode.null),
+              )
+            )
+            JSON.Encode.object(payloadDict)
+          }
+        }
+        obj->Dict.set("payload", payload)
+      }
+    | _ => {
+        obj->Dict.set("type", JSON.Encode.null)
+        obj->Dict.set("payload", j)
+      }
+    }
+  | String(s) => {
+      obj->Dict.set("type", JSON.Encode.string(s))
+      obj->Dict.set("payload", JSON.Encode.null)
+    }
+  | _ => {
+      obj->Dict.set("type", JSON.Encode.null)
+      obj->Dict.set("payload", j)
+    }
+  }
+  obj->Dict.set("rendered", JSON.Encode.string(RenderRescript.render(j)))
+  JSON.Encode.object(obj)
+}
+
+let renderValues = (arr: array<JSON.t>): JSON.t =>
+  arr->Array.map(renderValue)->JSON.Encode.array
+
+let mismatchJson = (m: Outcome.mismatch, slice: option<string>): JSON.t => {
+  let obj = Dict.make()
+  obj->Dict.set("kind", JSON.Encode.string(Outcome.kindName(m)))
+  let optVal = o =>
+    switch o {
+    | Some(v) => renderValue(v)
+    | None => JSON.Encode.null
+    }
+  switch m {
+  | EventsMismatch({expected, actual}) => {
+      obj->Dict.set("expected", renderValues(expected))
+      obj->Dict.set("actual", renderValues(actual))
+      obj->Dict.set("fieldDiff", Diff.toJsonArray(Diff.diffArrays(expected, actual)))
+    }
+  | ErrorMismatch({expected, actual, actualEvents}) => {
+      obj->Dict.set("expected", renderValue(expected))
+      obj->Dict.set("actual", optVal(actual))
+      obj->Dict.set("actualEvents", renderValues(actualEvents))
+    }
+  | StateMismatch({key, expected, actual}) => {
+      obj->Dict.set("key", JSON.Encode.string(key))
+      obj->Dict.set("expected", optVal(expected))
+      obj->Dict.set("actual", optVal(actual))
+      let eJson = expected->Option.getOr(JSON.Encode.null)
+      let aJson = actual->Option.getOr(JSON.Encode.null)
+      obj->Dict.set("fieldDiff", Diff.toJsonArray(Diff.diff(eJson, aJson)))
+    }
+  | NoEventExpected({actual}) => obj->Dict.set("actual", renderValues(actual))
+  | TodoMismatch({expected, actual}) => {
+      let pairArr = pairs =>
+        pairs
+        ->Array.map(((id, v)) => {
+          let d = Dict.make()
+          d->Dict.set("id", JSON.Encode.string(id))
+          d->Dict.set("value", renderValue(v))
+          JSON.Encode.object(d)
+        })
+        ->JSON.Encode.array
+      obj->Dict.set("expected", pairArr(expected))
+      obj->Dict.set("actual", pairArr(actual))
+    }
+  | AppendConditionMismatch({expected, actual}) => {
+      obj->Dict.set("expected", expected)
+      obj->Dict.set("actual", actual)
+    }
+  | TranslateError({expected, actual}) => {
+      obj->Dict.set("expected", JSON.Encode.string(expected))
+      obj->Dict.set(
+        "actual",
+        actual->Option.mapOr(JSON.Encode.null, JSON.Encode.string),
+      )
+    }
+  | QueryRowsMismatch({expected, actual}) => {
+      obj->Dict.set("expected", renderValues(expected))
+      obj->Dict.set("actual", renderValues(actual))
+      obj->Dict.set("fieldDiff", Diff.toJsonArray(Diff.diffArrays(expected, actual)))
+    }
+  | PublishedActionsMismatch({expected, actual}) => {
+      obj->Dict.set("expected", renderValues(expected))
+      obj->Dict.set("actual", renderValues(actual))
+      obj->Dict.set("fieldDiff", Diff.toJsonArray(Diff.diffArrays(expected, actual)))
+    }
+  | Throw({error, stack}) => {
+      obj->Dict.set("error", JSON.Encode.string(error))
+      obj->Dict.set("stack", JSON.Encode.string(stack))
+    }
+  }
+  let hint = Hint.forMismatch(~slice?, m)
+  obj->Dict.set("hint", Hint.toJson(hint))
+  JSON.Encode.object(obj)
+}
+
+let locationJson = (loc: option<Collector.location>): JSON.t =>
+  switch loc {
+  | None => JSON.Encode.null
+  | Some(l) => {
+      let d = Dict.make()
+      d->Dict.set("file", JSON.Encode.string(l.file))
+      d->Dict.set("line", JSON.Encode.int(l.line))
+      d->Dict.set("column", JSON.Encode.int(l.column))
+      JSON.Encode.object(d)
+    }
+  }
+
+let testJson = (t: RunnerTypes.testResult): JSON.t => {
+  let d = Dict.make()
+  d->Dict.set("id", JSON.Encode.string(t.id))
+  d->Dict.set("name", JSON.Encode.string(t.name))
+  d->Dict.set(
+    "describePath",
+    t.describePath->Array.map(JSON.Encode.string)->JSON.Encode.array,
+  )
+  d->Dict.set("status", JSON.Encode.string(RunnerTypes.statusString(t.status)))
+  d->Dict.set("durationMs", JSON.Encode.float(t.durationMs))
+  d->Dict.set("location", locationJson(t.location))
+  switch t.mismatch {
+  | Some(m) => d->Dict.set("mismatch", mismatchJson(m, t.slice))
+  | None => ()
+  }
+  switch t.skipReason {
+  | Some(r) => d->Dict.set("skipReason", JSON.Encode.string(r))
+  | None => ()
+  }
+  JSON.Encode.object(d)
+}
+
+let fileJson = (f: RunnerTypes.fileResult): JSON.t => {
+  let d = Dict.make()
+  d->Dict.set("path", JSON.Encode.string(f.path))
+  d->Dict.set("tests", f.tests->Array.map(testJson)->JSON.Encode.array)
+  JSON.Encode.object(d)
+}
+
+let summaryJson = (s: RunnerTypes.summary): JSON.t => {
+  let d = Dict.make()
+  d->Dict.set("total", JSON.Encode.int(s.total))
+  d->Dict.set("passed", JSON.Encode.int(s.passed))
+  d->Dict.set("failed", JSON.Encode.int(s.failed))
+  d->Dict.set("skipped", JSON.Encode.int(s.skipped))
+  d->Dict.set("files", JSON.Encode.int(s.files))
+  JSON.Encode.object(d)
+}
+
+let envelope = (
+  r: RunnerTypes.runResult,
+  ~toolVersion: string,
+  ~schemaVersion: string,
+): JSON.t => {
+  let d = Dict.make()
+  d->Dict.set("schemaVersion", JSON.Encode.string(schemaVersion))
+  d->Dict.set("tool", JSON.Encode.string("reventless-gwt"))
+  d->Dict.set("toolVersion", JSON.Encode.string(toolVersion))
+  d->Dict.set("startedAt", JSON.Encode.string(r.summary.startedAt))
+  d->Dict.set("durationMs", JSON.Encode.float(r.summary.durationMs))
+  d->Dict.set("summary", summaryJson(r.summary))
+  d->Dict.set("files", r.files->Array.map(fileJson)->JSON.Encode.array)
+  JSON.Encode.object(d)
+}
+
+let emit = (r: RunnerTypes.runResult, ~toolVersion: string, ~schemaVersion=defaultSchemaVersion) =>
+  write(JSON.stringify(envelope(r, ~toolVersion, ~schemaVersion), ~space=2) ++ "\n")
+
+// Streaming variant — NDJSON events.
+let streamRunStart = (~toolVersion: string, ~startedAt: string, ~schemaVersion=defaultSchemaVersion) => {
+  let d = Dict.make()
+  d->Dict.set("type", JSON.Encode.string("runStarted"))
+  d->Dict.set("schemaVersion", JSON.Encode.string(schemaVersion))
+  d->Dict.set("toolVersion", JSON.Encode.string(toolVersion))
+  d->Dict.set("at", JSON.Encode.string(startedAt))
+  writeLine(JSON.stringify(JSON.Encode.object(d)))
+}
+
+let streamFileStart = (path: string) => {
+  let d = Dict.make()
+  d->Dict.set("type", JSON.Encode.string("fileStarted"))
+  d->Dict.set("path", JSON.Encode.string(path))
+  writeLine(JSON.stringify(JSON.Encode.object(d)))
+}
+
+let streamTest = (t: RunnerTypes.testResult) => {
+  let d = Dict.make()
+  d->Dict.set("type", JSON.Encode.string("testResult"))
+  let tj = testJson(t)
+  // Fold testJson's object keys into the envelope.
+  switch tj {
+  | Object(inner) =>
+    inner->Dict.keysToArray->Array.forEach(k =>
+      d->Dict.set(k, inner->Dict.getUnsafe(k))
+    )
+  | _ => ()
+  }
+  writeLine(JSON.stringify(JSON.Encode.object(d)))
+}
+
+let streamFileFinished = (f: RunnerTypes.fileResult) => {
+  let passed = ref(0)
+  let failed = ref(0)
+  f.tests->Array.forEach(t =>
+    switch t.status {
+    | Pass => passed := passed.contents + 1
+    | Fail => failed := failed.contents + 1
+    | Skip => ()
+    }
+  )
+  let d = Dict.make()
+  d->Dict.set("type", JSON.Encode.string("fileFinished"))
+  d->Dict.set("path", JSON.Encode.string(f.path))
+  d->Dict.set("passed", JSON.Encode.int(passed.contents))
+  d->Dict.set("failed", JSON.Encode.int(failed.contents))
+  writeLine(JSON.stringify(JSON.Encode.object(d)))
+}
+
+let streamRunEnd = (r: RunnerTypes.runResult) => {
+  let d = Dict.make()
+  d->Dict.set("type", JSON.Encode.string("runFinished"))
+  d->Dict.set("summary", summaryJson(r.summary))
+  writeLine(JSON.stringify(JSON.Encode.object(d)))
+}

package/src/FormatterJson.res.mjs

@@ -0,0 +1,322 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Diff$ReventlessGwt from "./Diff.res.mjs";
+import * as Hint$ReventlessGwt from "./Hint.res.mjs";
+import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
+import * as RunnerTypes$ReventlessGwt from "./RunnerTypes.res.mjs";
+import * as RenderRescript$ReventlessGwt from "./RenderRescript.res.mjs";
+
+let defaultSchemaVersion = "1.1.0";
+
+function write(s) {
+  process.stdout.write(s);
+}
+
+function writeLine(s) {
+  process.stdout.write(s + "\n");
+}
+
+function renderValue(j) {
+  let obj = {};
+  let exit = 0;
+  if (j === null || Array.isArray(j)) {
+    exit = 1;
+  } else {
+    switch (typeof j) {
+      case "string" :
+        obj["type"] = j;
+        obj["payload"] = null;
+        break;
+      case "object" :
+        let match = j["TAG"];
+        let exit$1 = 0;
+        if (typeof match === "string") {
+          obj["type"] = match;
+          let payloadKeys = Object.keys(j).filter(k => {
+            if (k !== "TAG") {
+              return k.startsWith("_");
+            } else {
+              return false;
+            }
+          });
+          let payload;
+          let exit$2 = 0;
+          let len = payloadKeys.length;
+          if (len !== 1) {
+            if (len !== 0) {
+              exit$2 = 3;
+            } else {
+              payload = null;
+            }
+          } else {
+            let match$1 = payloadKeys[0];
+            if (match$1 === "_0") {
+              payload = Stdlib_Option.getOr(j["_0"], null);
+            } else {
+              exit$2 = 3;
+            }
+          }
+          if (exit$2 === 3) {
+            let payloadDict = {};
+            payloadKeys.forEach(k => {
+              payloadDict[k] = Stdlib_Option.getOr(j[k], null);
+            });
+            payload = payloadDict;
+          }
+          obj["payload"] = payload;
+        } else {
+          exit$1 = 2;
+        }
+        if (exit$1 === 2) {
+          obj["type"] = null;
+          obj["payload"] = j;
+        }
+        break;
+      default:
+        exit = 1;
+    }
+  }
+  if (exit === 1) {
+    obj["type"] = null;
+    obj["payload"] = j;
+  }
+  obj["rendered"] = RenderRescript$ReventlessGwt.render(undefined, j);
+  return obj;
+}
+
+function renderValues(arr) {
+  return arr.map(renderValue);
+}
+
+function mismatchJson(m, slice) {
+  let obj = {};
+  obj["kind"] = Outcome$ReventlessGwt.kindName(m);
+  let optVal = o => {
+    if (o !== undefined) {
+      return renderValue(o);
+    } else {
+      return null;
+    }
+  };
+  switch (m.TAG) {
+    case "EventsMismatch" :
+      let actual = m.actual;
+      let expected = m.expected;
+      obj["expected"] = expected.map(renderValue);
+      obj["actual"] = actual.map(renderValue);
+      obj["fieldDiff"] = Diff$ReventlessGwt.toJsonArray(Diff$ReventlessGwt.diffArrays(expected, actual));
+      break;
+    case "ErrorMismatch" :
+      obj["expected"] = renderValue(m.expected);
+      obj["actual"] = optVal(m.actual);
+      obj["actualEvents"] = m.actualEvents.map(renderValue);
+      break;
+    case "StateMismatch" :
+      let actual$1 = m.actual;
+      let expected$1 = m.expected;
+      obj["key"] = m.key;
+      obj["expected"] = optVal(expected$1);
+      obj["actual"] = optVal(actual$1);
+      let eJson = Stdlib_Option.getOr(expected$1, null);
+      let aJson = Stdlib_Option.getOr(actual$1, null);
+      obj["fieldDiff"] = Diff$ReventlessGwt.toJsonArray(Diff$ReventlessGwt.diff(eJson, aJson));
+      break;
+    case "NoEventExpected" :
+      obj["actual"] = m.actual.map(renderValue);
+      break;
+    case "TodoMismatch" :
+      let pairArr = pairs => pairs.map(param => {
+        let d = {};
+        d["id"] = param[0];
+        d["value"] = renderValue(param[1]);
+        return d;
+      });
+      obj["expected"] = pairArr(m.expected);
+      obj["actual"] = pairArr(m.actual);
+      break;
+    case "AppendConditionMismatch" :
+      obj["expected"] = m.expected;
+      obj["actual"] = m.actual;
+      break;
+    case "TranslateError" :
+      obj["expected"] = m.expected;
+      obj["actual"] = Stdlib_Option.mapOr(m.actual, null, prim => prim);
+      break;
+    case "QueryRowsMismatch" :
+      let actual$2 = m.actual;
+      let expected$2 = m.expected;
+      obj["expected"] = expected$2.map(renderValue);
+      obj["actual"] = actual$2.map(renderValue);
+      obj["fieldDiff"] = Diff$ReventlessGwt.toJsonArray(Diff$ReventlessGwt.diffArrays(expected$2, actual$2));
+      break;
+    case "PublishedActionsMismatch" :
+      let actual$3 = m.actual;
+      let expected$3 = m.expected;
+      obj["expected"] = expected$3.map(renderValue);
+      obj["actual"] = actual$3.map(renderValue);
+      obj["fieldDiff"] = Diff$ReventlessGwt.toJsonArray(Diff$ReventlessGwt.diffArrays(expected$3, actual$3));
+      break;
+    case "Throw" :
+      obj["error"] = m.error;
+      obj["stack"] = m.stack;
+      break;
+  }
+  let hint = Hint$ReventlessGwt.forMismatch(slice, m);
+  obj["hint"] = Hint$ReventlessGwt.toJson(hint);
+  return obj;
+}
+
+function locationJson(loc) {
+  if (loc === undefined) {
+    return null;
+  }
+  let d = {};
+  d["file"] = loc.file;
+  d["line"] = loc.line;
+  d["column"] = loc.column;
+  return d;
+}
+
+function testJson(t) {
+  let d = {};
+  d["id"] = t.id;
+  d["name"] = t.name;
+  d["describePath"] = t.describePath.map(prim => prim);
+  d["status"] = RunnerTypes$ReventlessGwt.statusString(t.status);
+  d["durationMs"] = t.durationMs;
+  d["location"] = locationJson(t.location);
+  let m = t.mismatch;
+  if (m !== undefined) {
+    d["mismatch"] = mismatchJson(m, t.slice);
+  }
+  let r = t.skipReason;
+  if (r !== undefined) {
+    d["skipReason"] = r;
+  }
+  return d;
+}
+
+function fileJson(f) {
+  let d = {};
+  d["path"] = f.path;
+  d["tests"] = f.tests.map(testJson);
+  return d;
+}
+
+function summaryJson(s) {
+  let d = {};
+  d["total"] = s.total;
+  d["passed"] = s.passed;
+  d["failed"] = s.failed;
+  d["skipped"] = s.skipped;
+  d["files"] = s.files;
+  return d;
+}
+
+function envelope(r, toolVersion, schemaVersion) {
+  let d = {};
+  d["schemaVersion"] = schemaVersion;
+  d["tool"] = "reventless-gwt";
+  d["toolVersion"] = toolVersion;
+  d["startedAt"] = r.summary.startedAt;
+  d["durationMs"] = r.summary.durationMs;
+  d["summary"] = summaryJson(r.summary);
+  d["files"] = r.files.map(fileJson);
+  return d;
+}
+
+function emit(r, toolVersion, schemaVersionOpt) {
+  let schemaVersion = schemaVersionOpt !== undefined ? schemaVersionOpt : defaultSchemaVersion;
+  process.stdout.write(JSON.stringify(envelope(r, toolVersion, schemaVersion), undefined, 2) + "\n");
+}
+
+function streamRunStart(toolVersion, startedAt, schemaVersionOpt) {
+  let schemaVersion = schemaVersionOpt !== undefined ? schemaVersionOpt : defaultSchemaVersion;
+  let d = {};
+  d["type"] = "runStarted";
+  d["schemaVersion"] = schemaVersion;
+  d["toolVersion"] = toolVersion;
+  d["at"] = startedAt;
+  let s = JSON.stringify(d);
+  process.stdout.write(s + "\n");
+}
+
+function streamFileStart(path) {
+  let d = {};
+  d["type"] = "fileStarted";
+  d["path"] = path;
+  let s = JSON.stringify(d);
+  process.stdout.write(s + "\n");
+}
+
+function streamTest(t) {
+  let d = {};
+  d["type"] = "testResult";
+  let tj = testJson(t);
+  if (typeof tj === "object" && tj !== null && !Array.isArray(tj)) {
+    Object.keys(tj).forEach(k => {
+      d[k] = tj[k];
+    });
+  }
+  let s = JSON.stringify(d);
+  process.stdout.write(s + "\n");
+}
+
+function streamFileFinished(f) {
+  let passed = {
+    contents: 0
+  };
+  let failed = {
+    contents: 0
+  };
+  f.tests.forEach(t => {
+    let match = t.status;
+    switch (match) {
+      case "Pass" :
+        passed.contents = passed.contents + 1 | 0;
+        return;
+      case "Fail" :
+        failed.contents = failed.contents + 1 | 0;
+        return;
+      case "Skip" :
+        return;
+    }
+  });
+  let d = {};
+  d["type"] = "fileFinished";
+  d["path"] = f.path;
+  d["passed"] = passed.contents;
+  d["failed"] = failed.contents;
+  let s = JSON.stringify(d);
+  process.stdout.write(s + "\n");
+}
+
+function streamRunEnd(r) {
+  let d = {};
+  d["type"] = "runFinished";
+  d["summary"] = summaryJson(r.summary);
+  let s = JSON.stringify(d);
+  process.stdout.write(s + "\n");
+}
+
+export {
+  defaultSchemaVersion,
+  write,
+  writeLine,
+  renderValue,
+  renderValues,
+  mismatchJson,
+  locationJson,
+  testJson,
+  fileJson,
+  summaryJson,
+  envelope,
+  emit,
+  streamRunStart,
+  streamFileStart,
+  streamTest,
+  streamFileFinished,
+  streamRunEnd,
+}
+/* No side effect */