es6-error 4.1.1: ExtendableError

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/es6-error@4.1.1
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/es6-error@4.1.1
Demonstrate these symbols/APIs:
  - ExtendableError

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:932131d78f5402fc82fb8004351fd78a2b957d28e5232996d8518a389fbac153","contract":["assert ExtendableError subclasses correctly inherit from Error and ExtendableError","assert ExtendableError automatically sets name property to constructor class name","assert ExtendableError instance captures valid stack trace containing error name and message","assert multi-level subclassing preserves custom properties and prototype chain","assert custom ExtendableError thrown in try-catch block is caught and identifiable via instanceof"],"goal":"verify pkg:npm/es6-error@4.1.1","kind":"HOW","packages":["pkg:npm/es6-error@4.1.1"],"schemaVersion":1,"symbols":["ExtendableError"]},"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/es6-error@4.1.1"],"schemaVersion":1,"subject":"pkg:npm/es6-error@4.1.1","symbols":["ExtendableError"],"verifierAdapter":"node-typescript@1"}

import ExtendableError from 'es6-error';

/**
 * Custom error subclass extending ExtendableError.
 */
export class CustomError extends ExtendableError {
  constructor(message = 'Default error message') {
    super(message);
  }
}

/**
 * HTTP error subclass with status code.
 */
export class HttpError extends ExtendableError {
  constructor(status, message) {
    super(message);
    this.status = status;
  }
}

/**
 * Specific NotFound error subclass extending HttpError.
 */
export class NotFoundError extends HttpError {
  constructor(message = 'Resource not found') {
    super(404, message);
  }
}

export { ExtendableError };
export default ExtendableError;

{
  "name": "sample-es6-error-verify",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-es6-error-verify",
      "version": "1.0.0",
      "dependencies": {
        "es6-error": "4.1.1"
      }
    },
    "node_modules/es6-error": {
      "version": "4.1.1",
      "resolved": "https://registry.npmjs.org/es6-error/-/es6-error-4.1.1.tgz",
      "integrity": "sha512-Um/+FxMr9CISWh0bi5Zv0iOD+4cFh5qLeks1qhAopKVAJw3drgKbKySikp7wGhDL0HPeaja0P5ULZrxLkniUVg==",
      "license": "MIT"
    }
  }
}

{
  "name": "sample-es6-error-verify",
  "version": "1.0.0",
  "private": true,
  "type": "module",
  "dependencies": {
    "es6-error": "4.1.1"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:npm/es6-error@4.1.1",
  "kind": "HOW",
  "packages": [
    "pkg:npm/es6-error@4.1.1"
  ],
  "symbols": [
    "ExtendableError"
  ]
}

import assert from 'node:assert/strict';
import ExtendableError, { CustomError, HttpError, NotFoundError } from '../index.mjs';

// 1. assert ExtendableError subclasses correctly inherit from Error and ExtendableError
{
  const err = new CustomError('Something failed');
  assert.ok(err instanceof Error);
  assert.ok(err instanceof ExtendableError);
  assert.ok(err instanceof CustomError);
  assert.strictEqual(err.message, 'Something failed');

  const defaultErr = new CustomError();
  assert.strictEqual(defaultErr.message, 'Default error message');
}

// 2. assert ExtendableError automatically sets name property to constructor class name
{
  const customErr = new CustomError('test error');
  assert.strictEqual(customErr.name, 'CustomError');

  const directErr = new ExtendableError('base error');
  assert.strictEqual(directErr.name, 'ExtendableError');
  assert.strictEqual(directErr.message, 'base error');
  assert.strictEqual(String(directErr), 'ExtendableError: base error');
  assert.strictEqual(String(customErr), 'CustomError: test error');
}

// 3. assert ExtendableError instance captures valid stack trace containing error name and message
{
  const err = new CustomError('stack trace test');
  assert.ok(typeof err.stack === 'string');
  assert.ok(err.stack.includes('CustomError: stack trace test'));
}

// 4. assert multi-level subclassing preserves custom properties and prototype chain
{
  const notFound = new NotFoundError('User not found');
  assert.ok(notFound instanceof NotFoundError);
  assert.ok(notFound instanceof HttpError);
  assert.ok(notFound instanceof ExtendableError);
  assert.ok(notFound instanceof Error);
  assert.strictEqual(notFound.status, 404);
  assert.strictEqual(notFound.message, 'User not found');
  assert.strictEqual(notFound.name, 'NotFoundError');

  const serverError = new HttpError(500, 'Internal Server Error');
  assert.strictEqual(serverError.status, 500);
  assert.strictEqual(serverError.name, 'HttpError');
}

// 5. assert custom ExtendableError thrown in try-catch block is caught and identifiable via instanceof
{
  let caught = null;
  try {
    throw new NotFoundError('Item missing');
  } catch (e) {
    caught = e;
  }

  assert.ok(caught !== null);
  assert.ok(caught instanceof NotFoundError);
  assert.ok(caught instanceof ExtendableError);
  assert.strictEqual(caught.status, 404);
  assert.strictEqual(caught.message, 'Item missing');
}

console.log('All contracts passed successfully.');