eyeling 1.19.5 → 1.19.6

package/examples/extra/fibonacci.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Exact Fibonacci benchmark using BigInt throughout.
+ * The main path is iterative, while fast doubling is used as an independent cross-check.
+ */
+
+function fibonacciIterative(n) {
+  let a = 0n;
+  let b = 1n;
+  for (let i = 0; i < n; i += 1) {
+    const t = a + b;
+    a = b;
+    b = t;
+  }
+  return a;
+}
+
+// Independent cross-check based on the fast-doubling identities.
+function fastDoubling(n) {
+  if (n === 0) return [0n, 1n];
+  const [a, b] = fastDoubling(Math.floor(n / 2));
+  const c = a * (2n * b - a);
+  const d = a * a + b * b;
+  if (n % 2 === 0) return [c, d];
+  return [d, c + d];
+}
+
+// Compute the requested values, then verify a few known identities and size facts.
+function main() {
+  const targets = [0, 1, 10, 100, 1000, 10000];
+  const vals = targets.map((n) => fibonacciIterative(n));
+
+  const f10Ok = vals[2] === 55n;
+  const f1000Str = vals[4].toString();
+  const f10000Str = vals[5].toString();
+  const f1000Digits = f1000Str.length;
+  const f10000Digits = f10000Str.length;
+
+  let fastOk = true;
+  for (let i = 0; i < targets.length; i += 1) {
+    const [a] = fastDoubling(targets[i]);
+    if (a !== vals[i]) fastOk = false;
+  }
+
+  const f99 = fibonacciIterative(99);
+  const f100 = fibonacciIterative(100);
+  const f101 = fibonacciIterative(101);
+  const cassiniOk = f101 * f99 === f100 * f100 + 1n;
+  const f10000Last3Ok = f10000Str.endsWith('875');
+
+  const ok = f10Ok && fastOk && cassiniOk && f1000Digits === 209 && f10000Digits === 2090 && f10000Last3Ok;
+
+  const lines = [];
+  lines.push('=== Answer ===');
+  lines.push('The requested Fibonacci values are computed exactly, up to F(10000).');
+  lines.push('');
+  lines.push('=== Reason Why ===');
+  lines.push(
+    'The main computation uses the defining recurrence F(n+1)=F(n)+F(n-1), and the results are cross-checked with fast doubling.',
+  );
+  for (let i = 0; i < targets.length; i += 1) {
+    lines.push(`value[${i}]          : F(${targets[i]}) = ${vals[i].toString()}`);
+  }
+  lines.push(`digits in F(1000)   : ${f1000Digits}`);
+  lines.push(`digits in F(10000)  : ${f10000Digits}`);
+  lines.push('');
+  lines.push('=== Check ===');
+  lines.push(`F(10) = 55            : ${f10Ok ? 'yes' : 'no'}`);
+  lines.push(`fast doubling agrees  : ${fastOk ? 'yes' : 'no'}`);
+  lines.push(`Cassini at n=100      : ${cassiniOk ? 'yes' : 'no'}`);
+  lines.push(`F(1000) has 209 digits: ${f1000Digits === 209 ? 'yes' : 'no'}`);
+  lines.push(`F(10000) has 2090 digits: ${f10000Digits === 2090 ? 'yes' : 'no'}`);
+  lines.push(`F(10000) ends in 875  : ${f10000Last3Ok ? 'yes' : 'no'}`);
+
+  process.stdout.write(`${lines.join('\n')}\n`);
+  process.exit(ok ? 0 : 1);
+}
+
+main();

package/examples/extra/goldbach-1000.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Goldbach sweep for all even targets up to 1000.
+ * A sieve provides the prime table; the report summarizes sparse, rich, and balanced decompositions.
+ */
+
+const LIMIT = 1000;
+
+function sieve(limit) {
+  const prime = new Array(limit + 1).fill(true);
+  prime[0] = false;
+  prime[1] = false;
+  for (let p = 2; p * p <= limit; p += 1) {
+    if (!prime[p]) continue;
+    for (let m = p * p; m <= limit; m += p) prime[m] = false;
+  }
+  return prime;
+}
+
+function collectPrimes(prime, limit) {
+  const out = [];
+  for (let i = 2; i <= limit; i += 1) if (prime[i]) out.push(i);
+  return out;
+}
+
+function goldbachPairs(target, primes, prime) {
+  let count = 0;
+  for (const p of primes) {
+    if (p > Math.floor(target / 2)) break;
+    const q = target - p;
+    if (prime[q]) count += 1;
+  }
+  return count;
+}
+
+// Sweep the entire range and summarize the decomposition counts.
+function main() {
+  const prime = sieve(LIMIT);
+  const primes = collectPrimes(prime, LIMIT);
+
+  let totalDecompositions = 0;
+  let fewest = Number.MAX_SAFE_INTEGER;
+  let most = 0;
+  let richestTarget = 4;
+  const hardest = [];
+  let allRepresented = true;
+
+  for (let target = 4; target <= LIMIT; target += 2) {
+    const count = goldbachPairs(target, primes, prime);
+    totalDecompositions += count;
+    if (count === 0) allRepresented = false;
+    if (count < fewest) {
+      fewest = count;
+      hardest.length = 0;
+      hardest.push(target);
+    } else if (count === fewest) {
+      hardest.push(target);
+    }
+    if (count > most) {
+      most = count;
+      richestTarget = target;
+    }
+  }
+
+  let bestA = 0;
+  let bestB = 0;
+  let bestDiff = Number.MAX_SAFE_INTEGER;
+  for (const p of primes) {
+    if (p > LIMIT / 2) break;
+    const q = LIMIT - p;
+    if (prime[q] && q >= p) {
+      const diff = q - p;
+      if (diff < bestDiff) {
+        bestDiff = diff;
+        bestA = p;
+        bestB = q;
+      }
+    }
+  }
+
+  const primeCountOk = primes.length === 168;
+  const balancedPairOk = bestA + bestB === LIMIT && prime[bestA] && prime[bestB];
+  const ok = allRepresented && primeCountOk && balancedPairOk;
+
+  const lines = [];
+  lines.push('=== Answer ===');
+  lines.push('Every even integer from 4 through 1000 has at least one Goldbach decomposition in the tested range.');
+  lines.push('');
+  lines.push('=== Reason Why ===');
+  lines.push(
+    'The program builds a prime table, enumerates unordered pairs p+q=n for each even target, and summarizes sparse and rich cases.',
+  );
+  lines.push(`even targets checked : ${(LIMIT - 4) / 2 + 1}`);
+  lines.push(`total decompositions : ${totalDecompositions}`);
+  lines.push(`fewest decompositions: ${fewest}`);
+  lines.push(`hardest targets      : ${hardest.join(', ')}`);
+  lines.push(`most decompositions  : ${most}`);
+  lines.push(`richest target       : ${richestTarget}`);
+  lines.push(`balanced pair(1000)  : ${bestA} + ${bestB}`);
+  lines.push('');
+  lines.push('=== Check ===');
+  lines.push(`all represented      : ${allRepresented ? 'yes' : 'no'}`);
+  lines.push(`prime count known    : ${primeCountOk ? 'yes' : 'no'}`);
+  lines.push(`balanced pair valid  : ${balancedPairOk ? 'yes' : 'no'}`);
+
+  process.stdout.write(`${lines.join('\n')}\n`);
+  process.exit(ok ? 0 : 1);
+}
+
+main();

package/examples/extra/gps.js

@@ -0,0 +1,274 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Small route-planning case with fixed legs, costs, and trust-style metrics.
+ * Routes are composed forward from the primitive descriptions and then filtered by the goal constraints.
+ */
+
+const CITY = {
+  GENT: 0,
+  BRUGGE: 1,
+  KORTRIJK: 2,
+  OOSTENDE: 3,
+};
+
+const ACTION = {
+  DRIVE_GENT_BRUGGE: 0,
+  DRIVE_GENT_KORTRIJK: 1,
+  DRIVE_KORTRIJK_BRUGGE: 2,
+  DRIVE_BRUGGE_OOSTENDE: 3,
+};
+
+// Primitive route descriptions: each one is a direct edge with its accumulated metrics.
+const DESCRIPTIONS = [
+  {
+    from: CITY.GENT,
+    to: CITY.BRUGGE,
+    action: ACTION.DRIVE_GENT_BRUGGE,
+    durationSeconds: 1500,
+    costMilli: 6,
+    beliefPpm: 960000,
+    comfortPpm: 990000,
+  },
+  {
+    from: CITY.GENT,
+    to: CITY.KORTRIJK,
+    action: ACTION.DRIVE_GENT_KORTRIJK,
+    durationSeconds: 1600,
+    costMilli: 7,
+    beliefPpm: 960000,
+    comfortPpm: 990000,
+  },
+  {
+    from: CITY.KORTRIJK,
+    to: CITY.BRUGGE,
+    action: ACTION.DRIVE_KORTRIJK_BRUGGE,
+    durationSeconds: 1600,
+    costMilli: 7,
+    beliefPpm: 960000,
+    comfortPpm: 990000,
+  },
+  {
+    from: CITY.BRUGGE,
+    to: CITY.OOSTENDE,
+    action: ACTION.DRIVE_BRUGGE_OOSTENDE,
+    durationSeconds: 900,
+    costMilli: 4,
+    beliefPpm: 980000,
+    comfortPpm: 1000000,
+  },
+];
+
+const GOAL = {
+  maxDurationSeconds: 5000,
+  maxCostMilli: 5000,
+  minBeliefPpm: 200000,
+  minComfortPpm: 400000,
+  maxStages: 1,
+};
+
+function multiplyPpm(left, right) {
+  return Math.floor((left * right) / 1000000);
+}
+
+function actionName(action) {
+  switch (action) {
+    case ACTION.DRIVE_GENT_BRUGGE:
+      return 'drive_gent_brugge';
+    case ACTION.DRIVE_GENT_KORTRIJK:
+      return 'drive_gent_kortrijk';
+    case ACTION.DRIVE_KORTRIJK_BRUGGE:
+      return 'drive_kortrijk_brugge';
+    case ACTION.DRIVE_BRUGGE_OOSTENDE:
+      return 'drive_brugge_oostende';
+    default:
+      return '?';
+  }
+}
+
+function stageCount(route) {
+  return route.actions.length > 0 ? 1 : 0;
+}
+
+function routeSatisfies(route, c) {
+  return (
+    route.durationSeconds <= c.maxDurationSeconds &&
+    route.costMilli <= c.maxCostMilli &&
+    route.beliefPpm >= c.minBeliefPpm &&
+    route.comfortPpm >= c.minComfortPpm &&
+    stageCount(route) <= c.maxStages
+  );
+}
+
+function routeEquals(a, b) {
+  return (
+    a.from === b.from &&
+    a.to === b.to &&
+    a.actions.length === b.actions.length &&
+    a.durationSeconds === b.durationSeconds &&
+    a.costMilli === b.costMilli &&
+    a.beliefPpm === b.beliefPpm &&
+    a.comfortPpm === b.comfortPpm &&
+    a.actions.every((action, i) => action === b.actions[i])
+  );
+}
+
+function compareRoutes(left, right) {
+  if (left.actions.length < right.actions.length) return -1;
+  if (left.actions.length > right.actions.length) return 1;
+  for (let i = 0; i < left.actions.length && i < right.actions.length; i += 1) {
+    if (left.actions[i] < right.actions[i]) return -1;
+    if (left.actions[i] > right.actions[i]) return 1;
+  }
+  return 0;
+}
+
+function routeMatchesDescriptions(route) {
+  let current = route.from;
+  let durationSeconds = 0;
+  let costMilli = 0;
+  let beliefPpm = 1000000;
+  let comfortPpm = 1000000;
+
+  for (const action of route.actions) {
+    let found = false;
+    for (const d of DESCRIPTIONS) {
+      if (d.from === current && d.action === action) {
+        current = d.to;
+        durationSeconds += d.durationSeconds;
+        costMilli += d.costMilli;
+        beliefPpm = multiplyPpm(beliefPpm, d.beliefPpm);
+        comfortPpm = multiplyPpm(comfortPpm, d.comfortPpm);
+        found = true;
+        break;
+      }
+    }
+    if (!found) return false;
+  }
+
+  return (
+    current === route.to &&
+    durationSeconds === route.durationSeconds &&
+    costMilli === route.costMilli &&
+    beliefPpm === route.beliefPpm &&
+    comfortPpm === route.comfortPpm
+  );
+}
+
+// Compose longer routes from the primitive descriptions until no new route appears.
+function inferGoalRoutes() {
+  const known = [];
+  let agendaHead = 0;
+
+  for (const d of DESCRIPTIONS) {
+    known.push({
+      from: d.from,
+      to: d.to,
+      actions: [d.action],
+      durationSeconds: d.durationSeconds,
+      costMilli: d.costMilli,
+      beliefPpm: d.beliefPpm,
+      comfortPpm: d.comfortPpm,
+    });
+  }
+
+  while (agendaHead < known.length) {
+    const rest = known[agendaHead++];
+    for (const d of DESCRIPTIONS) {
+      if (d.to === rest.from) {
+        const route = {
+          from: d.from,
+          to: rest.to,
+          actions: [d.action, ...rest.actions],
+          durationSeconds: d.durationSeconds + rest.durationSeconds,
+          costMilli: d.costMilli + rest.costMilli,
+          beliefPpm: multiplyPpm(d.beliefPpm, rest.beliefPpm),
+          comfortPpm: multiplyPpm(d.comfortPpm, rest.comfortPpm),
+        };
+        let duplicate = false;
+        for (const knownRoute of known) {
+          if (routeEquals(knownRoute, route)) {
+            duplicate = true;
+            break;
+          }
+        }
+        if (!duplicate) known.push(route);
+      }
+    }
+  }
+
+  return known
+    .filter((route) => route.from === CITY.GENT && route.to === CITY.OOSTENDE && routeSatisfies(route, GOAL))
+    .sort(compareRoutes);
+}
+
+function formatDecimal(value, scale, digits) {
+  const fractionalScale = 10 ** digits;
+  const scaled = value * fractionalScale;
+  const rounded = Math.floor((scaled + Math.floor(scale / 2)) / scale);
+  const whole = Math.floor(rounded / fractionalScale);
+  const fractional = rounded % fractionalScale;
+  return `${whole}.${String(fractional).padStart(digits, '0')}`;
+}
+
+function routeLines(index, route) {
+  const lines = [];
+  lines.push(`Route #${index}`);
+  lines.push(` Steps    : ${route.actions.length}`);
+  lines.push(` Duration : ${route.durationSeconds} s (≤ ${GOAL.maxDurationSeconds})`);
+  lines.push(` Cost     : ${formatDecimal(route.costMilli, 1000, 3)} (≤ ${formatDecimal(GOAL.maxCostMilli, 1000, 1)})`);
+  lines.push(
+    ` Belief   : ${formatDecimal(route.beliefPpm, 1000000, 3)} (≥ ${formatDecimal(GOAL.minBeliefPpm, 1000000, 1)})`,
+  );
+  lines.push(
+    ` Comfort  : ${formatDecimal(route.comfortPpm, 1000000, 3)} (≥ ${formatDecimal(GOAL.minComfortPpm, 1000000, 1)})`,
+  );
+  lines.push(` Stages   : ${stageCount(route)} (≤ ${GOAL.maxStages})`);
+  for (let i = 0; i < route.actions.length; i += 1) {
+    lines.push(`   ${i + 1}. ${actionName(route.actions[i])}`);
+  }
+  return lines;
+}
+
+// Emit every route that satisfies the fixed Gent -> Oostende goal.
+function main() {
+  const routes = inferGoalRoutes();
+
+  let allRoutesSatisfyConstraints = true;
+  let allRoutesHitGoalEndpoints = true;
+  let allMetricsRecompute = true;
+  for (const route of routes) {
+    allRoutesSatisfyConstraints &&= routeSatisfies(route, GOAL);
+    allRoutesHitGoalEndpoints &&= route.from === CITY.GENT && route.to === CITY.OOSTENDE;
+    allMetricsRecompute &&= routeMatchesDescriptions(route);
+  }
+
+  const ok = routes.length === 2 && allRoutesSatisfyConstraints && allRoutesHitGoalEndpoints && allMetricsRecompute;
+
+  const lines = [];
+  lines.push('=== Answer ===');
+  lines.push('The GPS case finds all goal routes from Gent to Oostende that satisfy the route constraints.');
+  lines.push('case      : gps');
+  lines.push(`routes    : ${routes.length}`);
+  lines.push('');
+  lines.push('=== Reason Why ===');
+  lines.push(
+    'Routes are built compositionally from direct descriptions, with duration and cost added and belief and comfort combined multiplicatively.',
+  );
+  for (let i = 0; i < routes.length; i += 1) {
+    lines.push(...routeLines(i + 1, routes[i]));
+    if (i + 1 !== routes.length) lines.push('');
+  }
+  lines.push('');
+  lines.push('=== Check ===');
+  lines.push(`all routes satisfy constraints : ${allRoutesSatisfyConstraints ? 'yes' : 'no'}`);
+  lines.push(`all routes hit goal endpoints  : ${allRoutesHitGoalEndpoints ? 'yes' : 'no'}`);
+  lines.push(`metrics recompute from steps   : ${allMetricsRecompute ? 'yes' : 'no'}`);
+  lines.push(`expected route count (= 2)     : ${routes.length === 2 ? 'yes' : 'no'}`);
+
+  process.stdout.write(`${lines.join('\n')}\n`);
+  process.exit(ok ? 0 : 1);
+}
+
+main();

package/examples/extra/kaprekar-6174.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Kaprekar 6174 exploration over all admissible four-digit starts.
+ * The script records traces, a convergence histogram, and a few representative witnesses.
+ */
+
+function digits4(n) {
+  return [Math.floor(n / 1000) % 10, Math.floor(n / 100) % 10, Math.floor(n / 10) % 10, n % 10];
+}
+
+function sort4(digits, descending) {
+  digits.sort((a, b) => (descending ? b - a : a - b));
+}
+
+function build4(d) {
+  return d[0] * 1000 + d[1] * 100 + d[2] * 10 + d[3];
+}
+
+function hasTwoDistinctDigits(n) {
+  const d = digits4(n);
+  for (let i = 1; i < 4; i += 1) if (d[i] !== d[0]) return true;
+  return false;
+}
+
+function kaprekarStep(n) {
+  const hi = digits4(n);
+  const lo = [...hi];
+  sort4(hi, true);
+  sort4(lo, false);
+  return build4(hi) - build4(lo);
+}
+
+function kaprekarTrace(start, cap) {
+  const out = [];
+  let cur = start;
+  while (out.length < cap) {
+    out.push(cur);
+    if (cur === 6174) break;
+    cur = kaprekarStep(cur);
+  }
+  return out;
+}
+
+function fmt4(n) {
+  return String(n).padStart(4, '0');
+}
+
+// Explore the full start space and then print a compact convergence summary.
+function main() {
+  let validStarts = 0;
+  let repdigits = 0;
+  let maxIterations = 0;
+  let worstCaseStarts = 0;
+  const hist = new Array(8).fill(0);
+  let worstTrace = [];
+  const leadingTrace = kaprekarTrace(2111, 16);
+  let allReach = true;
+  let boundOk = true;
+
+  for (let start = 0; start <= 9999; start += 1) {
+    if (!hasTwoDistinctDigits(start)) {
+      repdigits += 1;
+      continue;
+    }
+    const trace = kaprekarTrace(start, 16);
+    const steps = trace.length ? trace.length - 1 : 0;
+    validStarts += 1;
+    if (trace[trace.length - 1] !== 6174) allReach = false;
+    if (steps > 7) boundOk = false;
+    if (steps < 8) hist[steps] += 1;
+    if (steps > maxIterations) {
+      maxIterations = steps;
+      worstCaseStarts = 1;
+      worstTrace = trace.slice();
+    } else if (steps === maxIterations) {
+      worstCaseStarts += 1;
+    }
+  }
+
+  const fixedPointOk = kaprekarStep(6174) === 6174;
+  const histTotal = hist.reduce((sum, n) => sum + n, 0);
+  const histogramOk = histTotal === validStarts;
+  const ok = fixedPointOk && allReach && boundOk && histogramOk;
+
+  const lines = [];
+  lines.push('=== Answer ===');
+  lines.push('Every valid four-digit start tested reaches 6174, and all of them do so within seven iterations.');
+  lines.push('');
+  lines.push('=== Reason Why ===');
+  lines.push(
+    "The program applies Kaprekar's routine to every non-repdigit start, records the iteration count, and keeps witness traces.",
+  );
+  lines.push(`valid starts checked: ${validStarts}`);
+  lines.push(`repdigits excluded  : ${repdigits}`);
+  lines.push(`max iterations      : ${maxIterations}`);
+  lines.push(`worst-case starts   : ${worstCaseStarts}`);
+  lines.push(`worst trace         : ${worstTrace.map(fmt4).join(' -> ')}`);
+  lines.push(`leading-zero trace  : ${leadingTrace.map(fmt4).join(' -> ')}`);
+  lines.push('');
+  lines.push('=== Check ===');
+  lines.push(`6174 fixed point    : ${fixedPointOk ? 'yes' : 'no'}`);
+  lines.push(`all starts reach it : ${allReach ? 'yes' : 'no'}`);
+  lines.push(`bound <= 7 verified : ${boundOk ? 'yes' : 'no'}`);
+  lines.push(`histogram total ok  : ${histogramOk ? 'yes' : 'no'}`);
+
+  process.stdout.write(`${lines.join('\n')}\n`);
+  process.exit(ok ? 0 : 1);
+}
+
+main();

package/examples/extra/matrix-mechanics.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Toy matrix-mechanics example over 2x2 matrices.
+ * It highlights spectrum, involution, and a non-zero commutator in a compact exact model.
+ */
+
+function m2(a11, a12, a21, a22) {
+  return { a11, a12, a21, a22 };
+}
+
+function mul(a, b) {
+  return m2(
+    a.a11 * b.a11 + a.a12 * b.a21,
+    a.a11 * b.a12 + a.a12 * b.a22,
+    a.a21 * b.a11 + a.a22 * b.a21,
+    a.a21 * b.a12 + a.a22 * b.a22,
+  );
+}
+
+function sub(a, b) {
+  return m2(a.a11 - b.a11, a.a12 - b.a12, a.a21 - b.a21, a.a22 - b.a22);
+}
+
+function trace(a) {
+  return a.a11 + a.a22;
+}
+
+function det(a) {
+  return a.a11 * a.a22 - a.a12 * a.a21;
+}
+
+// Evaluate the tiny model exactly, then verify the expected algebraic properties.
+function main() {
+  const H = m2(1, 0, 0, 2);
+  const X = m2(0, 1, 1, 0);
+  const HX = mul(H, X);
+  const XH = mul(X, H);
+  const C = sub(HX, XH);
+  const commutatorNonzero = !!(C.a11 || C.a12 || C.a21 || C.a22);
+  const spectrumOk = trace(H) === 3 && det(H) === 2;
+  const XX = mul(X, X);
+  const involution = XX.a11 === 1 && XX.a12 === 0 && XX.a21 === 0 && XX.a22 === 1;
+  const ok = spectrumOk && involution && commutatorNonzero;
+
+  const lines = [];
+  lines.push('=== Answer ===');
+  lines.push(
+    'In this toy matrix-mechanics model, the Hamiltonian has two discrete energy levels and does not commute with a second observable.',
+  );
+  lines.push('');
+  lines.push('=== Reason Why ===');
+  lines.push(`H  = [[${H.a11},${H.a12}],[${H.a21},${H.a22}]]`);
+  lines.push(`X  = [[${X.a11},${X.a12}],[${X.a21},${X.a22}]]`);
+  lines.push(`HX = [[${HX.a11},${HX.a12}],[${HX.a21},${HX.a22}]]`);
+  lines.push(`XH = [[${XH.a11},${XH.a12}],[${XH.a21},${XH.a22}]]`);
+  lines.push(`[H,X] = [[${C.a11},${C.a12}],[${C.a21},${C.a22}]]`);
+  lines.push('');
+  lines.push('=== Check ===');
+  lines.push(`trace/determinant match energy levels: ${spectrumOk ? 'yes' : 'no'}`);
+  lines.push(`X^2 = I                           : ${involution ? 'yes' : 'no'}`);
+  lines.push(`[H,X] != 0                        : ${commutatorNonzero ? 'yes' : 'no'}`);
+
+  process.stdout.write(`${lines.join('\n')}\n`);
+  process.exit(ok ? 0 : 1);
+}
+
+main();