statuses 2.0.1: codes

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 statuses.codes in pkg:npm/statuses@2.0.1
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/statuses@2.0.1
Demonstrate these symbols/APIs:
  - statuses.codes

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:d4b94709acc667e3f96dede150e39400596ae467ef8d96266bde2f862f80d1e1","contract":["status.codes is an array of HTTP status code numbers","status.codes contains all standard HTTP status codes across classes 1xx through 5xx","status.codes includes standard codes like 200, 201, 204, 301, 304, 400, 401, 403, 404, 500, and 503","status.codes does not contain invalid or unassigned status codes like 299, 999, or 0","every code in status.codes has a corresponding non-empty message in status.message","status(code) returns the expected status message for each code in status.codes","isValidStatusCode(code) returns true for codes present in status.codes and false otherwise","getStatusCodesByClass(classDigit) returns all status codes belonging to that HTTP class"],"goal":"verify statuses.codes in pkg:npm/statuses@2.0.1","kind":"HOW","packages":["pkg:npm/statuses@2.0.1"],"schemaVersion":1,"symbols":["statuses.codes"]},"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/statuses@2.0.1"],"schemaVersion":1,"subject":"pkg:npm/statuses@2.0.1","symbols":["statuses.codes"],"verifierAdapter":"node-typescript@1"}

{
  "name": "verify-statuses-codes",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "verify-statuses-codes",
      "version": "1.0.0",
      "dependencies": {
        "statuses": "2.0.1"
      }
    },
    "node_modules/statuses": {
      "version": "2.0.1",
      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",
      "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==",
      "license": "MIT",
      "engines": {
        "node": ">= 0.8"
      }
    }
  }
}

{
  "name": "verify-statuses-codes",
  "version": "1.0.0",
  "type": "module",
  "dependencies": {
    "statuses": "2.0.1"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify statuses.codes in pkg:npm/statuses@2.0.1",
  "kind": "HOW",
  "packages": [
    "pkg:npm/statuses@2.0.1"
  ],
  "symbols": [
    "statuses.codes"
  ]
}

import status from 'statuses';

/**
 * Check if a number is a valid HTTP status code registered in statuses.codes.
 *
 * @param {number} code
 * @returns {boolean}
 */
export function isValidStatusCode(code) {
  return typeof code === 'number' && status.codes.includes(code);
}

/**
 * Get all status codes for a specific HTTP status class (1, 2, 3, 4, or 5).
 *
 * @param {number} classDigit - e.g. 2 for 2xx, 4 for 4xx
 * @returns {number[]}
 */
export function getStatusCodesByClass(classDigit) {
  const min = classDigit * 100;
  const max = min + 99;
  return status.codes.filter(code => code >= min && code <= max);
}

/**
 * Get the total number of registered status codes.
 *
 * @returns {number}
 */
export function getStatusCodeCount() {
  return status.codes.length;
}

export default status;

import assert from 'node:assert';
import status, { isValidStatusCode, getStatusCodesByClass, getStatusCodeCount } from '../src/index.mjs';

// 1. status.codes is an array of HTTP status code numbers
assert.strictEqual(Array.isArray(status.codes), true);
assert.strictEqual(typeof getStatusCodeCount(), 'number');
assert.strictEqual(getStatusCodeCount() > 0, true);
assert.strictEqual(status.codes.length, getStatusCodeCount());
assert.strictEqual(status.codes.every(c => typeof c === 'number' && Number.isInteger(c)), true);

// 2. status.codes contains all standard HTTP status codes (1xx through 5xx)
assert.strictEqual(status.codes.every(c => c >= 100 && c < 600), true);
const class1 = getStatusCodesByClass(1);
const class2 = getStatusCodesByClass(2);
const class3 = getStatusCodesByClass(3);
const class4 = getStatusCodesByClass(4);
const class5 = getStatusCodesByClass(5);
assert.strictEqual(class1.length > 0, true);
assert.strictEqual(class2.length > 0, true);
assert.strictEqual(class3.length > 0, true);
assert.strictEqual(class4.length > 0, true);
assert.strictEqual(class5.length > 0, true);
assert.strictEqual(class1.length + class2.length + class3.length + class4.length + class5.length, status.codes.length);

// 3. status.codes includes standard codes like 200, 201, 204, 301, 304, 400, 401, 403, 404, 500, 503
const standardCodes = [200, 201, 204, 301, 304, 400, 401, 403, 404, 500, 503];
for (const code of standardCodes) {
  assert.strictEqual(status.codes.includes(code), true);
  assert.strictEqual(isValidStatusCode(code), true);
}

// 4. status.codes does not contain invalid or unassigned codes like 299, 999, or 0
const invalidCodes = [0, 99, 299, 600, 999, -1];
for (const code of invalidCodes) {
  assert.strictEqual(status.codes.includes(code), false);
  assert.strictEqual(isValidStatusCode(code), false);
}
assert.strictEqual(isValidStatusCode('200'), false);
assert.strictEqual(isValidStatusCode(null), false);
assert.strictEqual(isValidStatusCode(undefined), false);

// 5. every code in status.codes has a corresponding non-empty message in status.message
for (const code of status.codes) {
  const msg = status.message[code];
  assert.strictEqual(typeof msg, 'string');
  assert.strictEqual(msg.length > 0, true);
}

// 6. status(code) returns the expected status message for each code in status.codes
assert.strictEqual(status(200), 'OK');
assert.strictEqual(status(201), 'Created');
assert.strictEqual(status(204), 'No Content');
assert.strictEqual(status(301), 'Moved Permanently');
assert.strictEqual(status(304), 'Not Modified');
assert.strictEqual(status(400), 'Bad Request');
assert.strictEqual(status(401), 'Unauthorized');
assert.strictEqual(status(403), 'Forbidden');
assert.strictEqual(status(404), 'Not Found');
assert.strictEqual(status(500), 'Internal Server Error');
assert.strictEqual(status(503), 'Service Unavailable');

for (const code of status.codes) {
  assert.strictEqual(status(code), status.message[code]);
}

// 7. isValidStatusCode(code) returns true for codes present in status.codes and false otherwise
assert.strictEqual(isValidStatusCode(200), true);
assert.strictEqual(isValidStatusCode(404), true);
assert.strictEqual(isValidStatusCode(500), true);
assert.strictEqual(isValidStatusCode(299), false);
assert.strictEqual(isValidStatusCode(777), false);

// 8. getStatusCodesByClass(classDigit) returns all status codes belonging to that HTTP class
const class2Codes = getStatusCodesByClass(2);
assert.strictEqual(class2Codes.includes(200), true);
assert.strictEqual(class2Codes.includes(201), true);
assert.strictEqual(class2Codes.every(c => c >= 200 && c <= 299), true);
assert.strictEqual(class2Codes.includes(404), false);

const class4Codes = getStatusCodesByClass(4);
assert.strictEqual(class4Codes.includes(400), true);
assert.strictEqual(class4Codes.includes(404), true);
assert.strictEqual(class4Codes.every(c => c >= 400 && c <= 499), true);
assert.strictEqual(class4Codes.includes(200), false);

console.log('Contract test passed.');