@0xcraft/powershot 1.0.0

package/dist/lang/python-deps.js

@@ -0,0 +1,174 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { decode } from '#app/text.js';
+/**
+ * Python's top-level standard library. A name that is here needs no dependency, and a
+ * name that is missing from here would be reported — so an incomplete list produces
+ * false positives, which is why this is the full 3.12 set rather than a sample.
+ */
+const STDLIB = new Set(('abc aifc argparse array ast asynchat asyncio asyncore atexit audioop base64 bdb binascii bisect builtins bz2 ' +
+    'calendar cgi cgitb chunk cmath cmd code codecs codeop collections colorsys compileall concurrent configparser ' +
+    'contextlib contextvars copy copyreg crypt csv ctypes curses dataclasses datetime dbm decimal difflib dis ' +
+    'distutils doctest email encodings ensurepip enum errno faulthandler fcntl filecmp fileinput fnmatch fractions ' +
+    'ftplib functools gc getopt getpass gettext glob graphlib grp gzip hashlib heapq hmac html http idlelib imaplib ' +
+    'imghdr imp importlib inspect io ipaddress itertools json keyword lib2to3 linecache locale logging lzma ' +
+    'mailbox mailcap marshal math mimetypes mmap modulefinder msilib msvcrt multiprocessing netrc nis nntplib ' +
+    'ntpath numbers operator optparse os ossaudiodev pathlib pdb pickle pickletools pipes pkgutil platform plistlib ' +
+    'poplib posix posixpath pprint profile pstats pty pwd py_compile pyclbr pydoc queue quopri random re readline ' +
+    'reprlib resource rlcompleter runpy sched secrets select selectors shelve shlex shutil signal site smtplib ' +
+    'sndhdr socket socketserver spwd sqlite3 sre_compile sre_constants sre_parse ssl stat statistics string ' +
+    'stringprep struct subprocess sunau symtable sys sysconfig syslog tabnanny tarfile telnetlib tempfile termios ' +
+    'test textwrap threading time timeit tkinter token tokenize tomllib trace traceback tracemalloc tty turtle ' +
+    'types typing unicodedata unittest urllib uu uuid venv warnings wave weakref webbrowser winreg winsound wsgiref ' +
+    'xdrlib xml xmlrpc zipapp zipfile zipimport zlib zoneinfo __future__ _thread').split(' '));
+/**
+ * Import names that differ from the distribution that provides them. Without this a
+ * project depending on PyYAML looks like it forgot `yaml`, which is the kind of
+ * confident wrong answer this tool exists to avoid.
+ */
+const DISTRIBUTION = {
+    yaml: 'pyyaml', cv2: 'opencv-python', PIL: 'pillow', sklearn: 'scikit-learn',
+    bs4: 'beautifulsoup4', dateutil: 'python-dateutil', jwt: 'pyjwt', dotenv: 'python-dotenv',
+    serial: 'pyserial', attr: 'attrs', google: 'protobuf', OpenSSL: 'pyopenssl',
+    pkg_resources: 'setuptools', setuptools: 'setuptools', magic: 'python-magic',
+    psycopg2: 'psycopg2-binary', redis: 'redis', mysql: 'mysql-connector-python',
+    docx: 'python-docx', pptx: 'python-pptx', fitz: 'pymupdf', win32api: 'pywin32',
+};
+/**
+ * The distribution named by one requirement.
+ *
+ * A PEP 508 requirement carries its version and extras inside the quotes —
+ * `sqlalchemy[asyncio]>=2.0.48` — so the name is the leading run of name characters,
+ * not the whole string. Requiring the whole quoted string to be a bare name is what
+ * made 91 declared dependencies look missing on one real repository.
+ */
+function requirementName(entry) {
+    const m = /^\s*([A-Za-z0-9][A-Za-z0-9._-]*)/.exec(entry);
+    return m?.[1];
+}
+/**
+ * Dependency names from a manifest, read section by section rather than by scanning
+ * every quoted string — a pyproject.toml is full of quoted words that are not
+ * packages, and treating them all as declared would hide real findings.
+ */
+function dependencyNames(text, file) {
+    const out = [];
+    if (file.endsWith('.txt')) {
+        for (const line of text.split(/\r?\n/)) {
+            if (line.trimStart().startsWith('#'))
+                continue;
+            const name = requirementName(line);
+            if (name)
+                out.push(normalize(name));
+        }
+        return out;
+    }
+    // PEP 621 and setuptools: `dependencies = [...]`, plus optional-dependency groups.
+    // The array ends at a bracket that starts a line: an extras marker such as
+    // `uvicorn[standard]>=0.42` carries a `]` of its own, and a lazy match to any
+    // bracket stops there, silently dropping every requirement after it.
+    for (const block of text.matchAll(/dependencies\s*=\s*\[([\s\S]*?)^\s*\]/gm)) {
+        for (const entry of (block[1] ?? '').matchAll(/["']([^"']+)["']/g)) {
+            const name = requirementName(entry[1] ?? '');
+            if (name)
+                out.push(normalize(name));
+        }
+    }
+    for (const section of text.split(/^\[/m)) {
+        // Poetry and Pipfile list one package per line: `name = "^1.0"`
+        if (/^(tool\.poetry[a-z.]*dependencies|packages|dev-packages)\]/.test(section)) {
+            for (const line of section.split(/\r?\n/)) {
+                const m = /^\s*([A-Za-z0-9][A-Za-z0-9._-]*)\s*=\s*["'{]/.exec(line);
+                if (m?.[1])
+                    out.push(normalize(m[1]));
+            }
+        }
+        // Optional-dependency and PEP 735 groups nest arrays under a group name, so the
+        // key is `dev` rather than `dependencies` and the packages are inside the array
+        if (/^(project\.optional-dependencies|dependency-groups|tool\.uv)\]/.test(section)) {
+            for (const entry of section.matchAll(/["']([^"']+)["']/g)) {
+                const name = requirementName(entry[1] ?? '');
+                if (name)
+                    out.push(normalize(name));
+            }
+        }
+    }
+    return out;
+}
+/** PyPI treats `-`, `_` and `.` alike, and is case-insensitive. */
+function normalize(name) {
+    return name.toLowerCase().replace(/[-_.]+/g, '-');
+}
+const MANIFESTS = ['requirements.txt', 'pyproject.toml', 'Pipfile', 'setup.py', 'requirements-dev.txt'];
+/**
+ * Declared dependencies visible to one file.
+ *
+ * A Python monorepo declares pydantic in backend/classifications/pyproject.toml and
+ * nowhere else, so reading only the repository root calls every real dependency
+ * phantom — measured at 270 findings on one real repository. Every manifest from the
+ * file's own directory up to the root counts.
+ */
+export function pythonManifest(root, from = root) {
+    const found = [];
+    const names = new Set();
+    const dirs = [];
+    for (let dir = from;; dir = dirname(dir)) {
+        dirs.push(dir);
+        if (dir === root || dirname(dir) === dir)
+            break;
+    }
+    for (const dir of dirs) {
+        for (const file of MANIFESTS) {
+            const path = join(dir, file);
+            if (!existsSync(path))
+                continue;
+            if (!found.includes(file))
+                found.push(file);
+            const text = decode(readFileSync(path));
+            for (const name of dependencyNames(text, file))
+                names.add(name);
+        }
+    }
+    return found.length > 0 ? { names, file: found.join(', ') } : undefined;
+}
+const SKIP_DIRS = new Set([
+    'node_modules', '.git', '.venv', 'venv', 'env', '__pycache__', 'dist', 'build',
+    '.mypy_cache', '.pytest_cache', '.tox', 'site-packages', 'target', '.next',
+]);
+export function localModules(root) {
+    const local = new Set();
+    const walk = (dir, depth) => {
+        if (depth > 6 || local.size > 4000)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        const isPackage = entries.some((e) => e.isFile() && e.name === '__init__.py');
+        for (const entry of entries) {
+            if (entry.name.startsWith('.') || SKIP_DIRS.has(entry.name))
+                continue;
+            if (entry.isDirectory()) {
+                // a package directory is importable by name; so is a plain source folder
+                local.add(entry.name);
+                walk(join(dir, entry.name), depth + 1);
+            }
+            else if (entry.name.endsWith('.py') && (isPackage || depth <= 2)) {
+                local.add(entry.name.slice(0, -3));
+            }
+        }
+    };
+    walk(root, 0);
+    return local;
+}
+export function isPhantom(importName, manifest, local) {
+    const top = importName.split('.')[0] ?? importName;
+    if (STDLIB.has(top) || local.has(top))
+        return false;
+    const candidates = [normalize(top), normalize(DISTRIBUTION[top] ?? top)];
+    return !candidates.some((c) => manifest.names.has(c));
+}
+//# sourceMappingURL=python-deps.js.map

package/dist/lang/ruby-deps.js

@@ -0,0 +1,77 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { decode } from '#app/text.js';
+/** Ruby's standard library and default gems, by the name you require. */
+const STDLIB = new Set(('abbrev base64 benchmark bigdecimal cgi coverage csv date delegate digest drb english erb etc expect fcntl ' +
+    'fiddle fileutils find forwardable getoptlong io ipaddr irb json logger matrix minitest monitor mutex_m net ' +
+    'nkf objspace observer open-uri open3 openssl optparse ostruct pathname pp prettyprint prime pstore psych ' +
+    'racc rake rdoc readline reline resolv rexml rinda ripper rss rubygems securerandom set shellwords singleton ' +
+    'socket stringio strscan syslog tempfile test time timeout tmpdir tsort un uri weakref yaml zlib ' +
+    'English Set').split(' '));
+/**
+ * Requires whose name differs from the gem that provides them. Rails is the reason
+ * this table exists: a Gemfile says `rails`, and the code requires `active_record`.
+ */
+const GEM_FOR = {
+    active_record: 'rails', active_support: 'rails', action_pack: 'rails', action_view: 'rails',
+    action_mailer: 'rails', active_job: 'rails', active_storage: 'rails', action_cable: 'rails',
+    rails_helper: 'rails', sinatra: 'sinatra', sequel: 'sequel', nokogiri: 'nokogiri',
+    httparty: 'httparty', rspec: 'rspec', sidekiq: 'sidekiq', pry: 'pry', puma: 'puma',
+    jwt: 'jwt', redis: 'redis', pg: 'pg', mysql2: 'mysql2', dotenv: 'dotenv',
+};
+function normalize(name) {
+    return name.toLowerCase().replace(/[-_]+/g, '-');
+}
+/** Gems declared in the Gemfile or a gemspec. */
+export function rubyManifest(root) {
+    const names = new Set();
+    const found = [];
+    const files = ['Gemfile', ...(existsSync(root) ? readdirSync(root).filter((f) => f.endsWith('.gemspec')) : [])];
+    for (const file of files) {
+        const path = join(root, file);
+        if (!existsSync(path))
+            continue;
+        found.push(file);
+        const text = decode(readFileSync(path));
+        // `gem "name"` in a Gemfile, `add_dependency "name"` in a gemspec
+        for (const m of text.matchAll(/(?:^\s*gem|add(?:_runtime|_development)?_dependency)\s*[( ]\s*["']([^"']+)["']/gm)) {
+            if (m[1])
+                names.add(normalize(m[1]));
+        }
+    }
+    return found.length > 0 ? { names, file: found.join(', ') } : undefined;
+}
+/** Files this repository provides, so a require of its own code is not a dependency. */
+export function rubyLocal(root) {
+    const local = new Set();
+    for (const dir of ['lib', 'app', '.', 'config']) {
+        const base = join(root, dir);
+        if (!existsSync(base))
+            continue;
+        try {
+            for (const entry of readdirSync(base, { withFileTypes: true })) {
+                if (entry.isDirectory())
+                    local.add(entry.name);
+                else if (entry.name.endsWith('.rb'))
+                    local.add(entry.name.slice(0, -3));
+            }
+        }
+        catch {
+            // unreadable directory contributes nothing
+        }
+    }
+    return local;
+}
+/**
+ * `require "foo/bar"` is provided by the gem `foo`, which holds for nearly every gem.
+ * Reported as `firm`: the require-to-gem relationship is a convention, not a rule, and
+ * a gem can also arrive through a path or git source this cannot see.
+ */
+export function isPhantomGem(required, manifest, local) {
+    const top = required.split('/')[0] ?? required;
+    if (STDLIB.has(top) || local.has(top) || local.has(required))
+        return false;
+    const candidates = [normalize(top), normalize(GEM_FOR[top] ?? top), normalize(top.replace(/_/g, ''))];
+    return !candidates.some((c) => manifest.names.has(c));
+}
+//# sourceMappingURL=ruby-deps.js.map

package/dist/langtest.js

@@ -0,0 +1,248 @@
+/**
+ * Language pack checks, one process per language.
+ *
+ * They cannot share a process: V8 tiers up each wasm grammar in the background, and
+ * eleven of them together drove RSS past 690MB and killed the run. A child per
+ * language costs a second and keeps every pack genuinely covered rather than
+ * shrinking the suite to fit a limit.
+ */
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { PACKS, parse } from './lang/packs.js';
+import { tokensFor } from './verifiers/foreign.js';
+/** each fixture: a handler that discards, one that genuinely handles, one explained */
+const FIXTURES = {
+    python: 'def f():\n    try:\n        a()\n    except Exception:\n        pass\n    try:\n        b()\n    except Exception as e:\n        raise RuntimeError("x") from e\n    try:\n        c()\n    except Exception:\n        pass  # deliberate\n',
+    go: 'package m\nfunc F() error {\n\tif err := a(); err != nil {\n\t}\n\tif err := b(); err != nil {\n\t\treturn err\n\t}\n\tif err := c(); err != nil {\n\t\t// deliberate\n\t}\n\treturn nil\n}\n',
+    java: 'class A {\n  void f() {\n    try { a(); } catch (Exception e) { }\n    try { b(); } catch (Exception e) { throw new RuntimeException(e); }\n    try { c(); } catch (Exception e) { /* deliberate */ }\n  }\n}\n',
+    // `let _ = a()` is Rust's own "on purpose" marker and must NOT be reported; the
+    // empty Err arm is the one with no such marker
+    rust: 'fn f() {\n    let _ = a();\n    match x() { Err(_) => {}, Ok(v) => v };\n    match b() { Err(e) => return Err(e), Ok(v) => v };\n}\n',
+    cpp: 'void f() {\n  try { a(); } catch (...) { }\n  try { b(); } catch (const std::exception& e) { throw; }\n  try { c(); } catch (...) { /* deliberate */ }\n}\n',
+    c: 'int f(int n) {\n  if (n < 0) { return 0; }\n  return n;\n}\n',
+    'c#': 'class A {\n  void F() {\n    try { A(); } catch (Exception e) { }\n    try { B(); } catch (Exception e) { throw; }\n    try { C(); } catch (Exception e) { /* deliberate */ }\n  }\n}\n',
+    php: '<?php\nfunction f() {\n  try { a(); } catch (Exception $e) { }\n  try { b(); } catch (Exception $e) { throw $e; }\n  try { c(); } catch (Exception $e) { /* deliberate */ }\n}\n',
+    kotlin: 'fun f() {\n  try { a() } catch (e: Exception) {}\n  try { b() } catch (e: Exception) { throw e }\n  try { c() } catch (e: Exception) { /* deliberate */ }\n}\n',
+    solidity: 'contract A {\n  function f() public {\n    try a() { } catch { }\n    try b() { } catch { revert("x"); }\n    try c() { } catch { /* deliberate */ }\n  }\n}\n',
+    ruby: 'def f\n  begin\n    a\n  rescue => e\n  end\n  begin\n    b\n  rescue => e\n    raise\n  end\n  begin\n    c\n  rescue => e\n    # deliberate\n  end\nend\n',
+};
+/** the handler in each fixture that genuinely handles, and must never be reported */
+const HANDLED = {
+    python: 'raise RuntimeError', go: 'return err', java: 'throw new RuntimeException',
+    rust: 'return Err(e)', cpp: 'throw;', 'c#': 'throw;', php: 'throw $e',
+    kotlin: 'throw e', ruby: 'raise', solidity: 'revert("x")',
+};
+async function one(name) {
+    const pack = PACKS.find((p) => p.name === name);
+    if (!pack) {
+        console.error('no pack named ' + name);
+        return 1;
+    }
+    let failed = 0;
+    const check = (label, fn) => {
+        try {
+            fn();
+            console.log('  ok   ' + name + ': ' + label);
+        }
+        catch (e) {
+            failed++;
+            console.log('  FAIL ' + name + ': ' + label + '\n       ' + e.message);
+        }
+    };
+    const source = FIXTURES[name];
+    const tree = source === undefined ? undefined : await parse(pack, source);
+    check('has a fixture, so it is never asserted against another language', () => {
+        assert.ok(source !== undefined, 'no fixture written');
+    });
+    check('the grammar loads and parses', () => {
+        assert.ok(tree, 'failed to parse — grammar missing or ABI mismatch');
+    });
+    check('declares the node names the generic checks need', () => {
+        for (const key of ['identifier', 'comment', 'ifStatement', 'bail', 'declaration', 'block']) {
+            assert.ok(pack.nodes[key].length > 0, 'no ' + key);
+        }
+    });
+    const hits = tree ? pack.swallowedError?.(tree.rootNode) ?? [] : [];
+    if (name === 'c') {
+        check('does not advertise an exception oracle the language cannot supply', () => {
+            assert.equal(pack.swallowedError, undefined);
+        });
+    }
+    else {
+        check('finds the idiom that discards a failure', () => {
+            assert.ok(hits.length >= 1, 'found none');
+        });
+        check('stays silent where a comment states the intent', () => {
+            assert.equal(hits.some((h) => /deliberate/.test(h.node.text)), false, 'reported an explained handler');
+        });
+        check('leaves a properly handled error alone', () => {
+            assert.equal(hits.some((h) => h.node.text.includes(HANDLED[name])), false, 'reported a real handler');
+        });
+    }
+    return failed;
+}
+/** Signature comparison is Python-only for now, and is what decides a contract break. */
+async function pythonSignatures() {
+    const pack = PACKS.find((p) => p.name === 'python');
+    let failed = 0;
+    const check = (label, fn) => {
+        try {
+            fn();
+            console.log('  ok   python signatures: ' + label);
+        }
+        catch (e) {
+            failed++;
+            console.log('  FAIL python signatures: ' + label + '\n       ' + e.message);
+        }
+    };
+    const of = async (src) => {
+        const tree = await parse(pack, src);
+        return pack.signatures(tree.rootNode);
+    };
+    const one = await of('def send(to: str) -> bool:\n    return True\n');
+    const two = await of('def send(to: str, subject: str) -> bool:\n    return True\n');
+    const defaulted = await of('def send(to: str, subject: str = "hi") -> bool:\n    return True\n');
+    const splat = await of('def send(to: str, *args, **kwargs) -> bool:\n    return True\n');
+    const method = await of('class A:\n    def send(self, to: str) -> bool:\n        return True\n');
+    check('counts what a caller must supply', () => {
+        assert.equal(one.get('send').required, 1);
+        assert.equal(two.get('send').required, 2);
+    });
+    check('a default does not demand anything of a caller', () => {
+        assert.equal(defaulted.get('send').required, 1);
+    });
+    check('*args and **kwargs demand nothing', () => {
+        assert.equal(splat.get('send').required, 1);
+    });
+    check('self is bound, not passed', () => {
+        assert.equal(method.get('send').required, 1);
+    });
+    return failed;
+}
+/** Test and docstring conventions are per-language data; these are Python's. */
+async function pythonConventions() {
+    const pack = PACKS.find((p) => p.name === 'python');
+    let failed = 0;
+    const check = (label, fn) => {
+        try {
+            fn();
+            console.log('  ok   python conventions: ' + label);
+        }
+        catch (e) {
+            failed++;
+            console.log('  FAIL python conventions: ' + label + '\n       ' + e.message);
+        }
+    };
+    const tests = async (src) => pack.tests((await parse(pack, src)).rootNode);
+    const docs = async (src) => pack.documentedParams((await parse(pack, src)).rootNode);
+    const Q = '"' + '"' + '"';
+    const bare = await tests('def test_a():\n    do_work()\n');
+    const asserted = await tests('def test_a():\n    assert do_work() == 1\n');
+    const unittest = await tests('class T:\n    def test_a(self):\n        self.assertEqual(do_work(), 1)\n');
+    const raises = await tests('def test_a():\n    with pytest.raises(ValueError):\n        do_work()\n');
+    const placeholder = await tests('def test_a():\n    pass\n');
+    check('a test that runs code and proves nothing is caught', () => {
+        assert.equal(bare[0].provesNothing, true);
+    });
+    check('a plain assert counts as proof', () => {
+        assert.equal(asserted[0].provesNothing, false);
+    });
+    check('unittest assertion methods count as proof', () => {
+        assert.equal(unittest[0].provesNothing, false);
+    });
+    check('a raises block counts as proof', () => {
+        assert.equal(raises[0].provesNothing, false);
+    });
+    check('a placeholder body is not a claim that came out empty', () => {
+        assert.equal(placeholder[0].provesNothing, false);
+    });
+    check('an assertion exposes what it asserts about, for drift', () => {
+        assert.equal(asserted[0].assertions[0].subject, 'do_work()');
+        assert.equal(asserted[0].assertions[0].expected, '1');
+        assert.equal(unittest[0].assertions[0].expected, '1');
+    });
+    const google = await docs('def f(a, b):\n    ' + Q + 'Do it.\n\n    Args:\n        a: first\n        c: nope\n    ' + Q + '\n    return a\n');
+    const rest = await docs('def f(a):\n    ' + Q + 'Do it.\n\n    :param a: first\n    :param z: nope\n    ' + Q + '\n    return a\n');
+    const undocumented = await docs('def f(a):\n    return a\n');
+    check('a Google-style Args block is read', () => {
+        assert.deepEqual(google[0].documented.map((d) => d.name), ['a', 'c']);
+        assert.deepEqual(google[0].declared, ['a', 'b']);
+    });
+    check('a reST :param: block is read', () => {
+        assert.deepEqual(rest[0].documented.map((d) => d.name), ['a', 'z']);
+    });
+    check('a function with no docstring makes no claim to contradict', () => {
+        assert.equal(undocumented.length, 0);
+    });
+    return failed;
+}
+/** A change inside a string literal must never read as "formatting only". */
+async function literalsAreVisible() {
+    let failed = 0;
+    const check = (label, fn) => {
+        try {
+            fn();
+            console.log('  ok   literals: ' + label);
+        }
+        catch (e) {
+            failed++;
+            console.log('  FAIL literals: ' + label + '\n       ' + e.message);
+        }
+    };
+    const sample = {
+        rust: (v) => 'fn f() { let x = "' + v + '"; }',
+        go: (v) => 'package m\nvar x = "' + v + '"\n',
+        java: (v) => 'class A { String x = "' + v + '"; }',
+        cpp: (v) => 'auto x = "' + v + '";',
+        python: (v) => 'x = "' + v + '"\n',
+        ruby: (v) => 'x = "' + v + '"\n',
+    };
+    for (const [name, build] of Object.entries(sample)) {
+        const pack = PACKS.find((p) => p.name === name);
+        if (!pack)
+            continue;
+        const a = await parse(pack, build('alpha_e_gguf'));
+        const b = await parse(pack, build('alpha_d_gguf'));
+        check(name + ': a changed string literal is part of the token stream', () => {
+            assert.ok(a && b);
+            assert.notEqual(JSON.stringify(tokensFor(a.rootNode, pack)), JSON.stringify(tokensFor(b.rootNode, pack)), name + ' tokenizes two different strings identically');
+        });
+    }
+    return failed;
+}
+async function main() {
+    const target = process.argv[2];
+    if (target)
+        return one(target);
+    console.log('\nlanguage packs (one process each)');
+    let failed = (await pythonSignatures()) + (await pythonConventions()) + (await literalsAreVisible());
+    for (const pack of PACKS) {
+        try {
+            process.stdout.write(execFileSync(process.execPath, [process.argv[1], pack.name], { encoding: 'utf8' }));
+        }
+        catch (e) {
+            const err = e;
+            process.stdout.write(err.stdout ?? '');
+            // a child killed by the runtime rather than by a failed assertion
+            if (err.status === null || err.signal) {
+                console.log('  FAIL ' + pack.name + ': the process died (' + (err.signal ?? 'no exit code') + ')');
+            }
+            failed++;
+        }
+    }
+    return failed;
+}
+main().then((failed) => {
+    // only the parent summarises; a child reports just its own language
+    if (!process.argv[2]) {
+        if (failed > 0)
+            console.error('\n' + failed + ' language pack(s) failed');
+        else
+            console.log('\nall ' + PACKS.length + ' language packs pass');
+    }
+    // Deliberately not process.exit(): V8 is still compiling the wasm grammar in the
+    // background, and tearing the process down underneath that work crashes it. Setting
+    // the code and letting the loop drain costs nothing and ends cleanly.
+    process.exitCode = failed > 0 ? 1 : 0;
+});
+//# sourceMappingURL=langtest.js.map