bare-assert 1.2.0

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify pkg:npm/bare-assert@1.2.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/bare-assert@1.2.0

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:c0f204285a753c919d99d9546289671939940dfdac545abb82ae40cd33c2cd6b","contract":["package manifest specifies bare-assert 1.2.0 with exports for root and package subpaths and TypeScript definitions","TypeScript definitions declare function assert, ok, equal, notEqual, strictEqual, notStrictEqual and class AssertionError","assert evaluates truthy values without throwing and throws AssertionError on falsy values","ok and notOk assert truthiness and falsiness throwing AssertionError on failure","equal and notEqual enforce loose equality semantics and handle NaN comparisons","strictEqual and notStrictEqual enforce Object.is strict equality semantics","fail throws AssertionError with explicit operator fail and customizable error message","AssertionError instances provide name, message, actual, expected, and operator properties"],"goal":"verify pkg:npm/bare-assert@1.2.0","kind":"HOW","packages":["pkg:npm/bare-assert@1.2.0"],"schemaVersion":1},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"npm","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/bare-assert@1.2.0"],"schemaVersion":1,"subject":"pkg:npm/bare-assert@1.2.0","verifierAdapter":"node-typescript@1"}

{
  "name": "sample-bare-assert",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-bare-assert",
      "version": "1.0.0",
      "license": "MIT-0",
      "dependencies": {
        "bare-assert": "1.2.0"
      }
    },
    "node_modules/b4a": {
      "version": "1.8.1",
      "resolved": "https://registry.npmjs.org/b4a/-/b4a-1.8.1.tgz",
      "integrity": "sha512-aiqre1Nr0B/6DgE2N5vwTc+2/oQZ4Wh1t4NznYY4E00y8LCt6NqdRv81so00oo27D8MVKTpUa/MwUUtBLXCoDw==",
      "license": "Apache-2.0",
      "peerDependencies": {
        "react-native-b4a": "*"
      },
      "peerDependenciesMeta": {
        "react-native-b4a": {
          "optional": true
        }
      }
    },
    "node_modules/bare-ansi-escapes": {
      "version": "2.2.3",
      "resolved": "https://registry.npmjs.org/bare-ansi-escapes/-/bare-ansi-escapes-2.2.3.tgz",
      "integrity": "sha512-02ES4/E2RbrtZSnHJ9LntBhYkLA6lPpSEeP8iqS3MccBIVhVBlEmruF1I7HZqx5Q8aiTeYfQVeqmrU9YO2yYoQ==",
      "license": "Apache-2.0",
      "dependencies": {
        "bare-stream": "^2.6.5"
      },
      "peerDependencies": {
        "bare-buffer": "*"
      },
      "peerDependenciesMeta": {
        "bare-buffer": {
          "optional": true
        }
      }
    },
    "node_modules/bare-assert": {
      "version": "1.2.0",
      "resolved": "https://registry.npmjs.org/bare-assert/-/bare-assert-1.2.0.tgz",
      "integrity": "sha512-c6uvgvTJBspTDxtVnPgrBKmLgcpW3Fp72NVKDLg6oT4QjQbhGtvrkHMhGYMK1sh4vjBHOBmuUalyt9hSzV37fQ==",
      "license": "Apache-2.0",
      "dependencies": {
        "bare-inspect": "^3.1.2"
      }
    },
    "node_modules/bare-events": {
      "version": "2.9.2",
      "resolved": "https://registry.npmjs.org/bare-events/-/bare-events-2.9.2.tgz",
      "integrity": "sha512-AIPKioV7/Y/8KfZ3AAhjPJxLLbY49S64Ym5DakZlUg75qQiTgUq9hEJoEwa4eUezPUlXRy/i5NpsKvo9jgKmoA==",
      "license": "Apache-2.0",
      "peerDependencies": {
        "bare-abort-controller": "*"
      },
      "peerDependenciesMeta": {
        "bare-abort-controller": {
          "optional": true
        }
      }
    },
    "node_modules/bare-inspect": {
      "version": "3.1.10",
      "resolved": "https://registry.npmjs.org/bare-inspect/-/bare-inspect-3.1.10.tgz",
      "integrity": "sha512-Qu01XZNTIT2/bS9k7c6A3OXuAzBnWwDCejGri76BUltdFqVe6Et/IxVOSSbcDpreSSWwqQ5pAu/bxFE6hPDWRQ==",
      "license": "Apache-2.0",
      "dependencies": {
        "bare-ansi-escapes": "^2.1.0",
        "bare-type": "^1.0.0"
      },
      "engines": {
        "bare": ">=1.18.0"
      }
    },
    "node_modules/bare-stream": {
      "version": "2.13.4",
      "resolved": "https://registry.npmjs.org/bare-stream/-/bare-stream-2.13.4.tgz",
      "integrity": "sha512-PcrQ8lVLbiJscNm1Kez+Yp4Gy4AHGcN1lzwjvf5NybWen7VvEgUfyfnXYJ2zNqWnzOfCb1Abq6lH8ti0syQszA==",
      "license": "Apache-2.0",
      "dependencies": {
        "b4a": "^1.8.1",
        "streamx": "^2.25.0",
        "teex": "^1.0.1"
      },
      "peerDependencies": {
        "bare-abort-controller": "*",
        "bare-buffer": "*",
        "bare-events": "*"
      },
      "peerDependenciesMeta": {
        "bare-abort-controller": {
          "optional": true
        },
        "bare-buffer": {
          "optional": true
        },
        "bare-events": {
          "optional": true
        }
      }
    },
    "node_modules/bare-type": {
      "version": "1.1.1",
      "resolved": "https://registry.npmjs.org/bare-type/-/bare-type-1.1.1.tgz",
      "integrity": "sha512-5HwbjDbnYr+Lwu5I59IqwOFcRcVo4jxo408t42gKhKnikw0ojwyPXPlx58AQP4dR2VvGw57ppX/qxYCn60Wujw==",
      "license": "Apache-2.0",
      "engines": {
        "bare": ">=1.2.0"
      }
    },
    "node_modules/events-universal": {
      "version": "1.0.1",
      "resolved": "https://registry.npmjs.org/events-universal/-/events-universal-1.0.1.tgz",
      "integrity": "sha512-LUd5euvbMLpwOF8m6ivPCbhQeSiYVNb8Vs0fQ8QjXo0JTkEHpz8pxdQf0gStltaPpw0Cca8b39KxvK9cfKRiAw==",
      "license": "Apache-2.0",
      "dependencies": {
        "bare-events": "^2.7.0"
      }
    },
    "node_modules/fast-fifo": {
      "version": "1.3.2",
      "resolved": "https://registry.npmjs.org/fast-fifo/-/fast-fifo-1.3.2.tgz",
      "integrity": "sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ==",
      "license": "MIT"
    },
    "node_modules/streamx": {
      "version": "2.28.1",
      "resolved": "https://registry.npmjs.org/streamx/-/streamx-2.28.1.tgz",
      "integrity": "sha512-zEzXb0s5Cds7tqMH6rhZ05lcJydCWiQPEwiNngVqzsxCc962vLY4Uw+mW7od8kDH258k2Uz/JrOkdIAAhSh9VA==",
      "license": "MIT",
      "dependencies": {
        "events-universal": "^1.0.0",
        "fast-fifo": "^1.3.2",
        "text-decoder": "^1.1.0"
      }
    },
    "node_modules/teex": {
      "version": "1.0.1",
      "resolved": "https://registry.npmjs.org/teex/-/teex-1.0.1.tgz",
      "integrity": "sha512-eYE6iEI62Ni1H8oIa7KlDU6uQBtqr4Eajni3wX7rpfXD8ysFx8z0+dri+KWEPWpBsxXfxu58x/0jvTVT1ekOSg==",
      "license": "MIT",
      "dependencies": {
        "streamx": "^2.12.5"
      }
    },
    "node_modules/text-decoder": {
      "version": "1.2.7",
      "resolved": "https://registry.npmjs.org/text-decoder/-/text-decoder-1.2.7.tgz",
      "integrity": "sha512-vlLytXkeP4xvEq2otHeJfSQIRyWxo/oZGEbXrtEEF9Hnmrdly59sUbzZ/QgyWuLYHctCHxFF4tRQZNQ9k60ExQ==",
      "license": "Apache-2.0",
      "dependencies": {
        "b4a": "^1.6.4"
      }
    }
  }
}

{
  "name": "sample-bare-assert",
  "version": "1.0.0",
  "private": true,
  "type": "module",
  "license": "MIT-0",
  "dependencies": {
    "bare-assert": "1.2.0"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:npm/bare-assert@1.2.0",
  "kind": "HOW",
  "packages": [
    "pkg:npm/bare-assert@1.2.0"
  ]
}

import assert from 'node:assert/strict';
import { createRequire } from 'node:module';
import fs from 'node:fs';
import path from 'node:path';

const require = createRequire(import.meta.url);

// 1. Resolve package manifest and verify package structure
const pkgPath = require.resolve('bare-assert/package');
const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));

assert.equal(pkg.name, 'bare-assert', 'Package name must be bare-assert');
assert.equal(pkg.version, '1.2.0', 'Package version must be 1.2.0');
assert.equal(pkg.exports['.'].types, './index.d.ts', 'Root export must specify types');
assert.equal(pkg.exports['.'].default, './index.js', 'Root export must specify default');
assert.equal(pkg.exports['./package'], './package.json', 'Package export must specify package.json');

const pkgDir = path.dirname(pkgPath);
const indexDtsPath = path.join(pkgDir, 'index.d.ts');
const indexJsPath = path.join(pkgDir, 'index.js');

// 2. Verify type declarations in index.d.ts
assert.ok(fs.existsSync(indexDtsPath), 'index.d.ts must exist');
const indexDts = fs.readFileSync(indexDtsPath, 'utf8');
assert.match(indexDts, /declare\s+function\s+assert/, 'index.d.ts must declare function assert');
assert.match(indexDts, /export\s+function\s+ok/, 'index.d.ts must export ok');
assert.match(indexDts, /export\s+function\s+equal/, 'index.d.ts must export equal');
assert.match(indexDts, /export\s+function\s+notEqual/, 'index.d.ts must export notEqual');
assert.match(indexDts, /export\s+function\s+strictEqual/, 'index.d.ts must export strictEqual');
assert.match(indexDts, /export\s+function\s+notStrictEqual/, 'index.d.ts must export notStrictEqual');
assert.match(indexDts, /export\s+class\s+AssertionError/, 'index.d.ts must export AssertionError');
assert.match(indexDts, /export\s+=\s+assert/, 'index.d.ts must export assert as root');

// 3. Set up bare-inspect mock in require cache for portable execution
const inspectPath = require.resolve('bare-inspect');
require.cache[inspectPath] = {
  id: inspectPath,
  filename: inspectPath,
  loaded: true,
  exports: (v) => (typeof v === 'string' ? JSON.stringify(v) : String(v))
};

const bareAssert = require('bare-assert');
assert.equal(typeof bareAssert, 'function', 'bareAssert should be a function');
assert.equal(typeof bareAssert.ok, 'function', 'bareAssert.ok should be a function');
assert.equal(typeof bareAssert.notOk, 'function', 'bareAssert.notOk should be a function');
assert.equal(typeof bareAssert.equal, 'function', 'bareAssert.equal should be a function');
assert.equal(typeof bareAssert.notEqual, 'function', 'bareAssert.notEqual should be a function');
assert.equal(typeof bareAssert.strictEqual, 'function', 'bareAssert.strictEqual should be a function');
assert.equal(typeof bareAssert.notStrictEqual, 'function', 'bareAssert.notStrictEqual should be a function');
assert.equal(typeof bareAssert.fail, 'function', 'bareAssert.fail should be a function');
assert.equal(typeof bareAssert.AssertionError, 'function', 'bareAssert.AssertionError should be a constructor');

// 4. Test assert() truthy and falsy evaluation
assert.doesNotThrow(() => bareAssert(true), 'bareAssert(true) must not throw');
assert.doesNotThrow(() => bareAssert('hello'), 'bareAssert(non-empty string) must not throw');
assert.doesNotThrow(() => bareAssert(123), 'bareAssert(non-zero number) must not throw');
assert.throws(
  () => bareAssert(false, 'custom falsy msg'),
  (err) => {
    assert.equal(err.name, 'AssertionError');
    assert.equal(err.message, 'custom falsy msg');
    assert.equal(err.actual, false);
    assert.equal(err.expected, true);
    assert.equal(err.operator, '==');
    return true;
  },
  'bareAssert(false) must throw AssertionError'
);

// 5. Test assert.ok() and assert.notOk()
assert.doesNotThrow(() => bareAssert.ok(1), 'bareAssert.ok(1) must not throw');
assert.throws(
  () => bareAssert.ok(0),
  (err) => {
    assert.equal(err.name, 'AssertionError');
    assert.equal(err.actual, 0);
    assert.equal(err.expected, true);
    assert.equal(err.operator, '==');
    return true;
  }
);
assert.doesNotThrow(() => bareAssert.notOk(0), 'bareAssert.notOk(0) must not throw');
assert.doesNotThrow(() => bareAssert.notOk(null), 'bareAssert.notOk(null) must not throw');
assert.doesNotThrow(() => bareAssert.notOk(undefined), 'bareAssert.notOk(undefined) must not throw');
assert.throws(
  () => bareAssert.notOk(true),
  (err) => {
    assert.equal(err.name, 'AssertionError');
    assert.equal(err.actual, true);
    assert.equal(err.expected, false);
    assert.equal(err.operator, '==');
    return true;
  }
);

// 6. Test assert.equal() and assert.notEqual() (loose equality)
assert.doesNotThrow(() => bareAssert.equal('42', 42), 'equal("42", 42) must not throw');
assert.doesNotThrow(() => bareAssert.equal(NaN, NaN), 'equal(NaN, NaN) must not throw');
assert.throws(
  () => bareAssert.equal(1, 2),
  (err) => {
    assert.equal(err.name, 'AssertionError');
    assert.equal(err.actual, 1);
    assert.equal(err.expected, 2);
    assert.equal(err.operator, '==');
    return true;
  }
);
assert.doesNotThrow(() => bareAssert.notEqual(1, 2), 'notEqual(1, 2) must not throw');
assert.throws(
  () => bareAssert.notEqual(1, '1'),
  (err) => {
    assert.equal(err.name, 'AssertionError');
    assert.equal(err.actual, 1);
    assert.equal(err.expected, '1');
    assert.equal(err.operator, '!=');
    return true;
  }
);

// 7. Test assert.strictEqual() and assert.notStrictEqual() (Object.is equality)
assert.doesNotThrow(() => bareAssert.strictEqual('test', 'test'), 'strictEqual("test", "test") must not throw');
assert.doesNotThrow(() => bareAssert.strictEqual(NaN, NaN), 'strictEqual(NaN, NaN) must not throw');
assert.throws(
  () => bareAssert.strictEqual(0, -0),
  (err) => {
    assert.equal(err.name, 'AssertionError');
    assert.equal(err.operator, 'strictEqual');
    return true;
  }
);
assert.throws(
  () => bareAssert.strictEqual('1', 1),
  (err) => {
    assert.equal(err.name, 'AssertionError');
    assert.equal(err.operator, 'strictEqual');
    return true;
  }
);
assert.doesNotThrow(() => bareAssert.notStrictEqual('1', 1), 'notStrictEqual("1", 1) must not throw');
assert.throws(
  () => bareAssert.notStrictEqual(42, 42),
  (err) => {
    assert.equal(err.name, 'AssertionError');
    assert.equal(err.operator, 'notStrictEqual');
    return true;
  }
);

// 8. Test assert.fail() and Error throwing
assert.throws(
  () => bareAssert.fail('explicit failure'),
  (err) => {
    assert.equal(err.name, 'AssertionError');
    assert.equal(err.message, 'explicit failure');
    assert.equal(err.operator, 'fail');
    return true;
  }
);
assert.throws(
  () => bareAssert.fail(),
  (err) => {
    assert.equal(err.name, 'AssertionError');
    assert.equal(err.message, 'Failed');
    assert.equal(err.operator, 'fail');
    return true;
  }
);

// 9. Test AssertionError properties and custom Error pass-through
const customErr = new Error('nested error');
assert.throws(
  () => bareAssert(false, customErr),
  (err) => {
    assert.equal(err, customErr);
    return true;
  }
);

console.log('Contract tests passed successfully.');