eyeling 1.19.4 → 1.19.6

package/examples/extra/delfour.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Standalone retail-insight envelope demo with fixed policy, payload, and catalog data.
+ * The checks verify integrity, authorization, minimization, and the recommendation outcome.
+ */
+
+const crypto = require('node:crypto');
+
+const SECRET = 'neutral-insight-demo-shared-secret';
+const PHONE_CREATED_AT = '2025-10-05T20:33:48.907163+00:00';
+const PHONE_EXPIRES_AT = '2025-10-05T22:33:48.907185+00:00';
+const SCANNER_AUTH_AT = '2025-10-05T20:35:48.907163+00:00';
+
+// Fixed product catalog used by the recommendation step.
+const CATALOG = [
+  { id: 'prod:BIS_001', name: 'Classic Tea Biscuits', sugarTenths: 120 },
+  { id: 'prod:BIS_101', name: 'Low-Sugar Tea Biscuits', sugarTenths: 30 },
+  { id: 'prod:CHOC_050', name: 'Milk Chocolate Bar', sugarTenths: 150 },
+  { id: 'prod:CHOC_150', name: '85% Dark Chocolate', sugarTenths: 60 },
+];
+
+function sha256Hex(text) {
+  return crypto.createHash('sha256').update(text).digest('hex');
+}
+
+function hmacSha256Hex(secret, text) {
+  return crypto.createHmac('sha256', secret).update(text).digest('hex');
+}
+
+function runDemo() {
+  const insightId = 'https://example.org/insight/delfour';
+  const insightJson = `{"createdAt":"${PHONE_CREATED_AT}","expiresAt":"${PHONE_EXPIRES_AT}","id":"${insightId}","metric":"sugar_g_per_serving","retailer":"Delfour","scopeDevice":"self-scanner","scopeEvent":"pick_up_scanner","suggestionPolicy":"lower_metric_first_higher_price_ok","threshold":10.0,"type":"ins:Insight"}`;
+  const policyJson = `{"duty":{"action":"odrl:delete","constraint":{"leftOperand":"odrl:dateTime","operator":"odrl:eq","rightOperand":"${PHONE_EXPIRES_AT}"}},"permission":{"action":"odrl:use","constraint":{"leftOperand":"odrl:purpose","operator":"odrl:eq","rightOperand":"shopping_assist"},"target":"${insightId}"},"profile":"Delfour-Insight-Policy","prohibition":{"action":"odrl:distribute","constraint":{"leftOperand":"odrl:purpose","operator":"odrl:eq","rightOperand":"marketing"},"target":"${insightId}"},"type":"odrl:Policy"}`;
+  const envelopeJson = `{"insight":${insightJson},"policy":${policyJson}}`;
+
+  const payloadHashHex = sha256Hex(envelopeJson);
+  const hmacHex = hmacSha256Hex(SECRET, envelopeJson);
+  const checkHash = sha256Hex(envelopeJson);
+  const checkHmac = hmacSha256Hex(SECRET, envelopeJson);
+
+  return {
+    insightJson,
+    policyJson,
+    payloadHashHex,
+    hmacHex,
+    signatureVerified: checkHmac === hmacHex,
+    payloadHashMatches: checkHash === payloadHashHex,
+    minimizationOk: !insightJson.includes('Diabetes') && !insightJson.includes('medical'),
+    authorizationAllowed: SCANNER_AUTH_AT < PHONE_EXPIRES_AT && policyJson.includes('shopping_assist'),
+    dutyTimingOk: true,
+    scanned: CATALOG[0],
+    alternative: CATALOG[1],
+  };
+}
+
+// Report the policy outcome, recommendation, and integrity checks.
+// Build the final ARC-style report and exit non-zero if a check fails.
+function main() {
+  const s = runDemo();
+  const bannerFlagsHighSugar = s.scanned.sugarTenths >= 100;
+  const alternativeIsLower = s.alternative.sugarTenths < s.scanned.sugarTenths;
+  const marketingProhibited = s.policyJson.includes('marketing') && s.policyJson.includes('odrl:distribute');
+  const scopeComplete =
+    s.insightJson.includes('scopeDevice') &&
+    s.insightJson.includes('scopeEvent') &&
+    s.insightJson.includes('expiresAt');
+  const ok =
+    s.signatureVerified &&
+    s.payloadHashMatches &&
+    s.minimizationOk &&
+    scopeComplete &&
+    s.authorizationAllowed &&
+    bannerFlagsHighSugar &&
+    alternativeIsLower &&
+    s.dutyTimingOk &&
+    marketingProhibited;
+
+  const lines = [];
+  lines.push('=== Answer ===');
+  lines.push(
+    'The scanner is allowed to use a neutral shopping insight and recommends Low-Sugar Tea Biscuits instead of Classic Tea Biscuits.',
+  );
+  lines.push('');
+  lines.push('=== Reason Why ===');
+  lines.push(
+    'The phone desensitizes a diabetes-related household condition into a scoped low-sugar need, wraps it in an expiring Insight+Policy envelope, and signs it.',
+  );
+  lines.push(`scanned product      : ${s.scanned.name}`);
+  lines.push(`suggested alternative: ${s.alternative.name}`);
+  lines.push(`payload SHA-256      : ${s.payloadHashHex}`);
+  lines.push(`HMAC-SHA256          : ${s.hmacHex}`);
+  lines.push('');
+  lines.push('=== Check ===');
+  lines.push(`signature verifies             : ${s.signatureVerified ? 'yes' : 'no'}`);
+  lines.push(`payload hash matches           : ${s.payloadHashMatches ? 'yes' : 'no'}`);
+  lines.push(`minimization strips sensitive terms: ${s.minimizationOk ? 'yes' : 'no'}`);
+  lines.push(`scope complete                 : ${scopeComplete ? 'yes' : 'no'}`);
+  lines.push(`authorization allowed          : ${s.authorizationAllowed ? 'yes' : 'no'}`);
+  lines.push(`high-sugar banner              : ${bannerFlagsHighSugar ? 'yes' : 'no'}`);
+  lines.push(`alternative lowers sugar       : ${alternativeIsLower ? 'yes' : 'no'}`);
+  lines.push(`duty timing consistent         : ${s.dutyTimingOk ? 'yes' : 'no'}`);
+  lines.push(`marketing prohibited           : ${marketingProhibited ? 'yes' : 'no'}`);
+
+  process.stdout.write(`${lines.join('\n')}\n`);
+  process.exit(ok ? 0 : 1);
+}
+
+main();

package/examples/extra/euler-identity.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Minimal exact-arithmetic witness for Euler's identity.
+ * Using an exact representation keeps the check section purely logical instead of approximate.
+ */
+
+function add(a, b) {
+  return { re: a.re + b.re, im: a.im + b.im };
+}
+
+// Build the exact witness and print the three ARC sections.
+function main() {
+  const expIpi = { re: -1, im: 0 };
+  const one = { re: 1, im: 0 };
+  const result = add(expIpi, one);
+  const modulusSq = expIpi.re * expIpi.re + expIpi.im * expIpi.im;
+  const identityOk = result.re === 0 && result.im === 0;
+  const unitCircleOk = modulusSq === 1;
+  const ok = identityOk && unitCircleOk;
+
+  const lines = [];
+  lines.push('=== Answer ===');
+  lines.push("Euler's identity holds exactly in this exact-arithmetic model: exp(i*pi) + 1 = 0.");
+  lines.push('');
+  lines.push('=== Reason Why ===');
+  lines.push('exp(i*pi) is represented as (-1, 0) and adding (1, 0) gives the exact zero complex number.');
+  lines.push(`exp(i*pi)   : (${expIpi.re}, ${expIpi.im})`);
+  lines.push(`exp(i*pi)+1 : (${result.re}, ${result.im})`);
+  lines.push(`|exp(i*pi)|^2: ${modulusSq}`);
+  lines.push('');
+  lines.push('=== Check ===');
+  lines.push(`identity exact: ${identityOk ? 'yes' : 'no'}`);
+  lines.push(`unit circle   : ${unitCircleOk ? 'yes' : 'no'}`);
+
+  process.stdout.write(`${lines.join('\n')}\n`);
+  process.exit(ok ? 0 : 1);
+}
+
+main();

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();