loupe 3.2.1

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/loupe@3.2.1
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/loupe@3.2.1
Constraints:
  - executionContext: node
Required runtime conditions:
  - ecosystem: npm
  - language: javascript
  - moduleSystem: cjs
  - packageManager: npm@10.9.8
  - runtime: node@22.23.2

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:dea0e9a523f2f82912fa71142dbd3686ae5c27cc30a8d897028dab8dd5b435fa","constraints":{"executionContext":"node"},"contract":["inspect formats primitive values including strings, numbers, booleans, null, undefined, BigInt, and Symbols","inspect formats structured objects, arrays, Sets, and Maps","inspect detects circular references and formats them with [Circular] placeholder","inspect formats RegExp patterns and Error objects","custom symbol enables user-defined custom inspection methods on objects","registerConstructor registers custom inspector functions for specific class constructors","registerStringTag registers custom inspector functions matching Symbol.toStringTag values","inspect supports configuration options such as truncate length and ANSI color formatting"],"goal":"verify pkg:npm/loupe@3.2.1","kind":"HOW","packages":["pkg:npm/loupe@3.2.1"],"schemaVersion":1},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","executionContext":"node","language":"javascript","libc":"glibc","libcVersion":"2.39","moduleSystem":"cjs","os":"linux","osVersionBucket":"24","packageManager":"npm","packageManagerVersion":"10.9.8","runtime":"node","runtimeVersion":"22.23.2","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/loupe@3.2.1"],"schemaVersion":1,"subject":"pkg:npm/loupe@3.2.1","verifierAdapter":"node-typescript@1"}

{
  "name": "sample-loupe",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-loupe",
      "version": "1.0.0",
      "dependencies": {
        "loupe": "3.2.1"
      }
    },
    "node_modules/loupe": {
      "version": "3.2.1",
      "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.2.1.tgz",
      "integrity": "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==",
      "license": "MIT"
    }
  }
}

{
  "name": "sample-loupe",
  "version": "1.0.0",
  "private": true,
  "description": "Clean-room verification of loupe value inspection and custom inspector registration",
  "type": "module",
  "main": "src/index.js",
  "dependencies": {
    "loupe": "3.2.1"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:npm/loupe@3.2.1",
  "kind": "HOW",
  "packages": [
    "pkg:npm/loupe@3.2.1"
  ],
  "constraints": {
    "executionContext": "node"
  },
  "runtimeConditions": {
    "ecosystem": "npm",
    "language": "javascript",
    "moduleSystem": "cjs",
    "packageManager": "npm@10.9.8",
    "runtime": "node@22.23.2"
  }
}

import { inspect, registerConstructor, registerStringTag, custom } from 'loupe';

/**
 * Formats a value using loupe inspector.
 *
 * @param {*} value - Value to inspect.
 * @param {object} [options] - Formatting options.
 * @returns {string} Formatted string representation.
 */
export function inspectValue(value, options) {
  return inspect(value, options);
}

/**
 * Registers a custom inspector function for instances of a constructor.
 *
 * @param {Function} constructor - Target constructor function or class.
 * @param {Function} inspector - Custom inspector handler.
 * @returns {boolean} True if successfully registered.
 */
export function addConstructorInspector(constructor, inspector) {
  return registerConstructor(constructor, inspector);
}

/**
 * Registers a custom inspector function for objects with a specific Symbol.toStringTag.
 *
 * @param {string} stringTag - Target string tag value.
 * @param {Function} inspector - Custom inspector handler.
 * @returns {boolean} True if successfully registered.
 */
export function addStringTagInspector(stringTag, inspector) {
  return registerStringTag(stringTag, inspector);
}

export { inspect, registerConstructor, registerStringTag, custom };

import assert from 'node:assert';
import {
  inspectValue,
  addConstructorInspector,
  addStringTagInspector,
  inspect,
  registerConstructor,
  registerStringTag,
  custom,
} from '../src/index.js';

// 1. Function exports verification
assert.strictEqual(typeof inspect, 'function', 'inspect should be a function');
assert.strictEqual(typeof registerConstructor, 'function', 'registerConstructor should be a function');
assert.strictEqual(typeof registerStringTag, 'function', 'registerStringTag should be a function');
assert.strictEqual(typeof inspectValue, 'function', 'inspectValue helper should be a function');
assert.strictEqual(typeof addConstructorInspector, 'function', 'addConstructorInspector helper should be a function');
assert.strictEqual(typeof addStringTagInspector, 'function', 'addStringTagInspector helper should be a function');
assert.ok(custom !== undefined, 'custom symbol should be exported');

// 2. inspect formats primitive values
assert.strictEqual(inspect('hello'), "'hello'");
assert.strictEqual(inspectValue(123), '123');
assert.strictEqual(inspectValue(true), 'true');
assert.strictEqual(inspectValue(false), 'false');
assert.strictEqual(inspectValue(null), 'null');
assert.strictEqual(inspectValue(undefined), 'undefined');
assert.strictEqual(inspectValue(10n), '10n');
assert.strictEqual(inspectValue(Symbol('test')), 'Symbol(test)');

// 3. inspect formats structured objects, arrays, Sets, and Maps
assert.strictEqual(inspectValue([1, 2, 3]), '[ 1, 2, 3 ]');
assert.strictEqual(inspectValue({ name: 'sample', count: 10 }), "{ name: 'sample', count: 10 }");
assert.strictEqual(inspectValue(new Set([1, 2])), 'Set{ 1, 2 }');
assert.strictEqual(inspectValue(new Map([['key', 'val']])), "Map{ 'key' => 'val' }");

// 4. inspect detects circular references and formats them with [Circular] placeholder
const circularObj = {};
circularObj.self = circularObj;
assert.strictEqual(inspectValue(circularObj), '{ self: [Circular] }');

// 5. inspect formats RegExp patterns and Error objects
assert.strictEqual(inspectValue(/pattern/gi), '/pattern/gi');
const err = new Error('verification error');
assert.ok(inspectValue(err).includes('Error: verification error'));

// 6. custom symbol enables user-defined custom inspection methods on objects
const customInspectable = {
  [custom]() {
    return '<CustomOutput>';
  },
};
assert.strictEqual(inspectValue(customInspectable), '<CustomOutput>');

// 7. registerConstructor registers custom inspector functions for specific class constructors
class SampleModel {
  constructor(id) {
    this.id = id;
  }
}
const regCtor = addConstructorInspector(SampleModel, (val) => `SampleModel(${val.id})`);
assert.strictEqual(regCtor, true);
assert.strictEqual(inspectValue(new SampleModel(42)), 'SampleModel(42)');
const regCtorDup = addConstructorInspector(SampleModel, () => 'Dup');
assert.strictEqual(regCtorDup, false);

// 8. registerStringTag registers custom inspector functions matching Symbol.toStringTag values
const taggedObj = {
  [Symbol.toStringTag]: 'SampleTag',
  value: 100,
};
const regTag = addStringTagInspector('SampleTag', (val) => `SampleTag:${val.value}`);
assert.strictEqual(regTag, true);
assert.strictEqual(inspectValue(taggedObj), 'SampleTag:100');
const regTagDup = addStringTagInspector('SampleTag', () => 'Dup');
assert.strictEqual(regTagDup, false);

// 9. inspect supports configuration options such as truncate length and ANSI color formatting
const longArray = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const truncated = inspectValue(longArray, { truncate: 15 });
assert.ok(truncated.includes('…'), 'truncate option should append ellipsis truncator');

const colorized = inspectValue('colored-text', { colors: true });
assert.ok(colorized.includes('\u001b['), 'colors option should include ANSI escape codes');

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