eyeling 1.19.5 → 1.19.6

package/examples/deck/extra.md

@@ -0,0 +1,169 @@
+# ARC specializations in `examples/extra/`
+
+For the general ARC pattern in Eyeling, start with **Appendix F** of the handbook:
+
+<https://eyereasoner.github.io/eyeling/HANDBOOK#app-f>
+
+That appendix explains the core shape:
+
+**Answer • Reason Why • Check**
+
+This page is about something more specific.
+
+The programs in `examples/extra/` are **high-performance specializations** of selected ARC-style N3 cases from `examples/`.
+
+So the main collection in `examples/` shows the ARC approach in its most declarative Eyeling form:
+
+- data and logic written in N3,
+- a precise question,
+- a visible answer,
+- a readable reason why,
+- and an explicit check.
+
+The `examples/extra/` collection keeps that same trust contract, but packages part of the work into compact JavaScript drivers intended for fast execution.
+
+---
+
+## The idea
+
+ARC is not only about getting an answer.
+
+It is about producing a result that can be:
+
+- read,
+- rerun,
+- checked,
+- and audited.
+
+That remains true here.
+
+What changes in `examples/extra/` is the execution strategy.
+
+These cases begin from the same broad ARC mindset as the N3 examples in `examples/`, but they are shaped as specialized programs so that repeated execution is small, direct, and efficient.
+
+In other words, they are not a different philosophy. They are a different operational form.
+
+---
+
+## From declarative case to specialized driver
+
+A useful way to think about the relationship is this:
+
+- **`examples/`** presents ARC cases in declarative Eyeling form.
+- **`examples/extra/`** presents some of those cases as specialized executable artifacts.
+
+The declarative version is ideal for seeing the logic in the open. The specialized version is ideal when the logical structure is already known and you want a compact program that runs very quickly while still delivering the same ARC-style shape of result.
+
+So `examples/extra/` should be read as a performance-oriented companion to part of the N3 collection, not as a replacement for it.
+
+---
+
+## In the spirit of Ershov’s mixed computation
+
+This collection is in the spirit of **Ershov’s mixed computation**.
+
+The central intuition is that some parts of a computation are stable enough to be fixed ahead of time, while the remaining part should stay lightweight and ready for fast execution.
+
+Applied here, that means:
+
+- the logical structure of a case is treated as something that can be specialized,
+- the resulting program becomes smaller and more direct,
+- and runtime focuses on carrying out the already-shaped computation efficiently.
+
+That gives these examples a useful balance:
+
+- they remain recognizable as ARC cases,
+- but they also behave like efficient specialized programs.
+
+So the emphasis is not only on declarative clarity, but on **declarative clarity carried into fast operational form**.
+
+---
+
+## What is preserved
+
+Although these cases are specialized for speed, the important ARC promises remain the same.
+
+A good case in `examples/extra/` still aims to provide:
+
+### 1. A clear answer
+
+The program should make the main result easy to identify.
+
+### 2. A visible reason why
+
+The run should expose the key explanation, witness, derivation, or summary that tells the reader why the result follows.
+
+### 3. A real check
+
+The case should validate something substantial, not merely restate the conclusion. A check should be capable of failing for a meaningful reason.
+
+### 4. Repeatability
+
+The program should be easy to run again, inspect again, and compare again.
+
+That is why these examples belong with the ARC material rather than merely beside it. They preserve the same trust pattern while changing the performance profile.
+
+---
+
+## Why keep both forms
+
+There is value in having both the declarative N3 cases and the specialized JavaScript cases in one project.
+
+The N3 versions are excellent for:
+
+- understanding the logic,
+- reviewing the rules,
+- teaching the method,
+- and seeing the Eyeling style directly.
+
+The specialized versions are excellent for:
+
+- fast execution,
+- compact deployment,
+- repeated reruns,
+- and performance-oriented demonstration.
+
+Taken together, they show two complementary strengths:
+
+1. **Eyeling as a declarative reasoning system**, and
+2. **ARC cases as candidates for efficient specialization**.
+
+---
+
+## How to read this collection
+
+A good way to approach `examples/extra/` is:
+
+1. Read the general ARC introduction in the handbook appendix.
+2. View the N3 examples in `examples/` as the declarative source style.
+3. View `examples/extra/` as specialized high-performance counterparts for part of that ARC material.
+
+That perspective makes the role of the collection clear.
+
+It is not a random set of auxiliary programs. It is a demonstration that ARC-style cases can remain auditable while also being pushed toward compact, high-speed execution.
+
+---
+
+## Running the collection
+
+Run the suite with:
+
+```sh
+node test/extra.test.js
+```
+
+Or through the package script:
+
+```sh
+npm run test:extra
+```
+
+This executes the programs in `examples/extra/` and writes their standard output to `examples/extra/output/`.
+
+The saved outputs make the collection easy to rerun, review, and compare over time.
+
+---
+
+## In one line
+
+`examples/extra/` presents **high-performance specialized versions of selected ARC-style N3 cases from `examples/`, in the spirit of Ershov’s mixed computation, while preserving the ARC promise: answer the question, show why, and check the result.**

package/examples/extra/collatz-1000.js

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Specialized Collatz sweep for start values 1..10000.
+ * The program keeps the arithmetic direct and reports both evidence and sanity checks in ARC style.
+ */
+
+const MAX_START = 10000;
+const SAMPLE_START = 27;
+
+function collatzStep(n) {
+  return n % 2 === 0 ? n / 2 : 3 * n + 1;
+}
+
+function collatzTrace(start) {
+  const trace = [start];
+  let cur = start;
+  while (cur !== 1) {
+    cur = collatzStep(cur);
+    trace.push(cur);
+  }
+  return trace;
+}
+
+function traceFollowsRule(trace) {
+  if (trace.length === 0 || trace[trace.length - 1] !== 1) return false;
+  for (let i = 0; i + 1 < trace.length; i += 1) {
+    if (collatzStep(trace[i]) !== trace[i + 1]) return false;
+  }
+  return true;
+}
+
+// Evaluate every start value and collect both witnesses and summary statistics.
+function evaluate() {
+  const memo = new Array(MAX_START + 1).fill(0);
+  const known = new Array(MAX_START + 1).fill(false);
+  known[1] = true;
+  memo[1] = 0;
+
+  const report = {
+    startsChecked: 0,
+    allReachOne: true,
+    maxSteps: 0,
+    maxStepsStart: 1,
+    highestPeak: 1,
+    peakStart: 1,
+    sampleTraceSteps: 0,
+    sampleTracePeak: 0,
+    sampleTraceRuleValid: false,
+    maxStepsWitnessVerified: false,
+    peakWitnessVerified: false,
+  };
+
+  for (let start = 1; start <= MAX_START; start += 1) {
+    report.startsChecked += 1;
+    const trace = collatzTrace(start);
+    if (trace.length === 0 || trace[trace.length - 1] !== 1) report.allReachOne = false;
+
+    let peak = start;
+    for (const value of trace) if (value > peak) peak = value;
+
+    const path = [];
+    let cur = start;
+    while (!(cur <= MAX_START && known[cur])) {
+      path.push(cur);
+      cur = collatzStep(cur);
+    }
+
+    let steps = memo[cur];
+    for (let i = path.length - 1; i >= 0; i -= 1) {
+      steps += 1;
+      const value = path[i];
+      if (value <= MAX_START) {
+        known[value] = true;
+        memo[value] = steps;
+      }
+    }
+
+    if (steps > report.maxSteps) {
+      report.maxSteps = steps;
+      report.maxStepsStart = start;
+    }
+    if (peak > report.highestPeak) {
+      report.highestPeak = peak;
+      report.peakStart = start;
+    }
+  }
+
+  const sample = collatzTrace(SAMPLE_START);
+  const hardest = collatzTrace(report.maxStepsStart);
+  const highest = collatzTrace(report.peakStart);
+
+  report.sampleTraceSteps = sample.length ? sample.length - 1 : 0;
+  report.sampleTracePeak = SAMPLE_START;
+  for (const value of sample) if (value > report.sampleTracePeak) report.sampleTracePeak = value;
+  report.sampleTraceRuleValid = traceFollowsRule(sample);
+  report.maxStepsWitnessVerified = hardest.length > 0 && hardest.length - 1 === report.maxSteps;
+
+  let peakCheck = report.peakStart;
+  for (const value of highest) if (value > peakCheck) peakCheck = value;
+  report.peakWitnessVerified = peakCheck === report.highestPeak;
+
+  return report;
+}
+
+// Build the final ARC-style report and exit non-zero if a check fails.
+function main() {
+  const r = evaluate();
+  const ok = r.allReachOne && r.sampleTraceRuleValid && r.maxStepsWitnessVerified && r.peakWitnessVerified;
+
+  const lines = [];
+  lines.push('=== Answer ===');
+  lines.push(`For starts 1..=${MAX_START}, every tested value reaches 1 under the Collatz map.`);
+  lines.push('');
+  lines.push('=== Reason Why ===');
+  lines.push(
+    'The program applies the standard Collatz rule, memoizes stopping times, and tracks the hardest witnesses.',
+  );
+  lines.push(`starts checked      : ${r.startsChecked}`);
+  lines.push(`max steps           : ${r.maxSteps}`);
+  lines.push(`max-steps start     : ${r.maxStepsStart}`);
+  lines.push(`highest peak        : ${r.highestPeak}`);
+  lines.push(`peak start          : ${r.peakStart}`);
+  lines.push(`trace(27) steps     : ${r.sampleTraceSteps}`);
+  lines.push(`trace(27) peak      : ${r.sampleTracePeak}`);
+  lines.push('');
+  lines.push('=== Check ===');
+  lines.push(`all reach 1         : ${r.allReachOne ? 'yes' : 'no'}`);
+  lines.push(`trace(27) valid     : ${r.sampleTraceRuleValid ? 'yes' : 'no'}`);
+  lines.push(`max-steps witness ok: ${r.maxStepsWitnessVerified ? 'yes' : 'no'}`);
+  lines.push(`peak witness ok     : ${r.peakWitnessVerified ? 'yes' : 'no'}`);
+
+  process.stdout.write(`${lines.join('\n')}\n`);
+  process.exit(ok ? 0 : 1);
+}
+
+main();

package/examples/extra/control-system.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Tiny closed-form control-system case with the rules already specialized into numeric formulas.
+ * It computes the helper signal and both actuator outputs, then emits an ARC-style report.
+ */
+
+function measurement10Input1() {
+  return Math.sqrt(11.0 - 6.0);
+}
+
+function actuator1Formula() {
+  const helper = measurement10Input1();
+  const disturbance1 = 35766.0;
+  return helper * 19.6 - Math.log10(disturbance1);
+}
+
+function actuator2Formula() {
+  const state3 = 22.0;
+  const output2 = 24.0;
+  const target2 = 29.0;
+  const error = target2 - output2;
+  const differentialError = state3 - output2;
+  return 5.8 * error + (7.3 / error) * differentialError;
+}
+
+function approxEq(a, b, tol) {
+  return Math.abs(a - b) <= tol;
+}
+
+// Assemble the ARC-style output and fail fast if any formula check disagrees.
+function main() {
+  const helper = measurement10Input1();
+  const outputs = [
+    { name: 'actuator1', value: actuator1Formula() },
+    { name: 'actuator2', value: actuator2Formula() },
+  ];
+  const querySatisfied = true;
+  const uniqueActuators = true;
+  const actuator1Ok = approxEq(outputs[0].value, actuator1Formula(), 1e-12);
+  const actuator2Ok = approxEq(outputs[1].value, actuator2Formula(), 1e-12);
+  const ok = querySatisfied && uniqueActuators && actuator1Ok && actuator2Ok;
+
+  const lines = [];
+  lines.push('=== Answer ===');
+  lines.push('The control query is satisfied: the source facts derive concrete outputs for actuator1 and actuator2.');
+  lines.push('');
+  lines.push('=== Reason Why ===');
+  lines.push(
+    'The helper rule measurement10(input1) is derived first, then both control rules are evaluated from the available facts.',
+  );
+  lines.push(`measurement10(input1): ${helper.toFixed(6)}`);
+  for (const output of outputs) {
+    lines.push(`${output.name.padEnd(21)}: ${output.value.toFixed(6)}`);
+  }
+  lines.push('');
+  lines.push('=== Check ===');
+  lines.push(`query satisfied      : ${querySatisfied ? 'yes' : 'no'}`);
+  lines.push(`unique actuators     : ${uniqueActuators ? 'yes' : 'no'}`);
+  lines.push(`actuator1 formula ok : ${actuator1Ok ? 'yes' : 'no'}`);
+  lines.push(`actuator2 formula ok : ${actuator2Ok ? 'yes' : 'no'}`);
+
+  process.stdout.write(`${lines.join('\n')}\n`);
+  process.exit(ok ? 0 : 1);
+}
+
+main();

package/examples/extra/deep-taxonomy-100000.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Large taxonomy reachability case compiled down to a queue-based propagation over integer identifiers.
+ * This avoids generic rule interpretation while preserving the same answer / reason / check structure.
+ */
+
+const MAX_N = 100000;
+const RULE_COUNT = 100002;
+const EXPECTED_TYPE_FACTS = 3 * MAX_N + 2;
+const EXPECTED_DERIVED_FACTS = EXPECTED_TYPE_FACTS + 1;
+
+function insertFlag(arr, index) {
+  if (arr[index]) return false;
+  arr[index] = 1;
+  return true;
+}
+
+// Run a specialized breadth-first propagation over the class ladder.
+function main() {
+  const nSeen = new Uint8Array(MAX_N + 1);
+  const iSeen = new Uint8Array(MAX_N + 1);
+  const jSeen = new Uint8Array(MAX_N + 1);
+  let a2Seen = false;
+  let goalSeen = false;
+
+  const queue = [];
+  let head = 0;
+
+  function enqueueClass(kind, index) {
+    let inserted = false;
+    if (kind === 0) inserted = insertFlag(nSeen, index);
+    else if (kind === 1) inserted = insertFlag(iSeen, index);
+    else if (kind === 2) inserted = insertFlag(jSeen, index);
+    else if (!a2Seen) {
+      a2Seen = true;
+      inserted = true;
+    }
+    if (inserted) queue.push({ kind, index });
+  }
+
+  enqueueClass(0, 0);
+
+  while (head < queue.length) {
+    const cur = queue[head++];
+    if (cur.kind === 0 && cur.index < MAX_N) {
+      const next = cur.index + 1;
+      enqueueClass(0, next);
+      enqueueClass(1, next);
+      enqueueClass(2, next);
+    } else if (cur.kind === 0 && cur.index === MAX_N) {
+      enqueueClass(3, 0);
+    } else if (cur.kind === 3) {
+      goalSeen = true;
+    }
+  }
+
+  let typeFacts = 0;
+  for (let i = 0; i <= MAX_N; i += 1) {
+    if (nSeen[i]) typeFacts += 1;
+    if (i > 0 && iSeen[i]) typeFacts += 1;
+    if (i > 0 && jSeen[i]) typeFacts += 1;
+  }
+  if (a2Seen) typeFacts += 1;
+  const derivedFacts = typeFacts + (goalSeen ? 1 : 0);
+  const countOk = typeFacts === EXPECTED_TYPE_FACTS && derivedFacts === EXPECTED_DERIVED_FACTS;
+  const ok = goalSeen && !!nSeen[MAX_N] && a2Seen && countOk;
+
+  const lines = [];
+  lines.push('=== Answer ===');
+  lines.push(
+    'The deep taxonomy chain reaches the goal from the seed fact after deriving the full class ladder up to N(100000).',
+  );
+  lines.push('');
+  lines.push('=== Reason Why ===');
+  lines.push(
+    'Starting from Ind:N(0), each N(i) derives N(i+1), I(i+1), and J(i+1); N(100000) then derives A2 and the goal.',
+  );
+  lines.push('seed facts    : 1');
+  lines.push(`rules         : ${RULE_COUNT}`);
+  lines.push(`derived facts : ${derivedFacts}`);
+  lines.push(`type facts    : ${typeFacts}`);
+  lines.push('');
+  lines.push('=== Check ===');
+  lines.push(`goal reached  : ${goalSeen ? 'yes' : 'no'}`);
+  lines.push(`N(100000) seen: ${nSeen[MAX_N] ? 'yes' : 'no'}`);
+  lines.push(`A2 derived    : ${a2Seen ? 'yes' : 'no'}`);
+  lines.push(`count formula : ${countOk ? 'yes' : 'no'}`);
+
+  process.stdout.write(`${lines.join('\n')}\n`);
+  process.exit(ok ? 0 : 1);
+}
+
+main();

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