pvtsutils 1.3.6: BufferSourceConverter, Convert

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/pvtsutils@1.3.6
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/pvtsutils@1.3.6
Demonstrate these symbols/APIs:
  - BufferSourceConverter
  - Convert

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:8645787678ac98a9ed0309e515dd986cb7706cf8e54fbdfdb213e545feb72392","contract":["BufferSourceConverter converts ArrayBuffer and ArrayBufferView to ArrayBuffer and Uint8Array","BufferSourceConverter concatenates multiple buffer sources into a contiguous ArrayBuffer","BufferSourceConverter isEqual compares buffer sources for exact byte equality","Convert ToHex and FromHex transform byte buffers to and from hexadecimal strings","Convert ToBase64 and FromBase64 transform byte buffers to and from Base64 strings","Convert ToUtf8String and FromUtf8String transform byte buffers to and from UTF-8 strings"],"goal":"verify pkg:npm/pvtsutils@1.3.6","kind":"HOW","packages":["pkg:npm/pvtsutils@1.3.6"],"schemaVersion":1,"symbols":["BufferSourceConverter","Convert"]},"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/pvtsutils@1.3.6"],"schemaVersion":1,"subject":"pkg:npm/pvtsutils@1.3.6","symbols":["BufferSourceConverter","Convert"],"verifierAdapter":"node-typescript@1"}

{
  "name": "sample-pvtsutils",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-pvtsutils",
      "version": "1.0.0",
      "dependencies": {
        "pvtsutils": "1.3.6"
      }
    },
    "node_modules/pvtsutils": {
      "version": "1.3.6",
      "resolved": "https://registry.npmjs.org/pvtsutils/-/pvtsutils-1.3.6.tgz",
      "integrity": "sha512-PLgQXQ6H2FWCaeRak8vvk1GW462lMxB5s3Jm673N82zI4vqtVUPuZdffdZbPDFRoU8kAhItWFtPCWiPpp4/EDg==",
      "license": "MIT",
      "dependencies": {
        "tslib": "^2.8.1"
      }
    },
    "node_modules/tslib": {
      "version": "2.8.1",
      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
      "license": "0BSD"
    }
  }
}

{
  "name": "sample-pvtsutils",
  "version": "1.0.0",
  "private": true,
  "description": "Clean-room verification of pvtsutils buffer conversion and encoding utilities",
  "type": "module",
  "main": "src/index.js",
  "dependencies": {
    "pvtsutils": "1.3.6"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:npm/pvtsutils@1.3.6",
  "kind": "HOW",
  "packages": [
    "pkg:npm/pvtsutils@1.3.6"
  ],
  "symbols": [
    "BufferSourceConverter",
    "Convert"
  ]
}

import { BufferSourceConverter, Convert, isEqual } from 'pvtsutils';

/**
 * Convert a BufferSource (ArrayBuffer or ArrayBufferView) to an ArrayBuffer.
 * @param {ArrayBuffer|ArrayBufferView} source
 * @returns {ArrayBuffer}
 */
export function toArrayBuffer(source) {
  return BufferSourceConverter.toArrayBuffer(source);
}

/**
 * Convert a BufferSource to a Uint8Array.
 * @param {ArrayBuffer|ArrayBufferView} source
 * @returns {Uint8Array}
 */
export function toUint8Array(source) {
  return BufferSourceConverter.toUint8Array(source);
}

/**
 * Concatenate multiple buffer sources into a single ArrayBuffer.
 * @param {...(ArrayBuffer|ArrayBufferView)} buffers
 * @returns {ArrayBuffer}
 */
export function concatBuffers(...buffers) {
  return BufferSourceConverter.concat(...buffers);
}

/**
 * Compare two BufferSources for byte equality.
 * @param {ArrayBuffer|ArrayBufferView} a
 * @param {ArrayBuffer|ArrayBufferView} b
 * @returns {boolean}
 */
export function areBuffersEqual(a, b) {
  return BufferSourceConverter.isEqual(a, b);
}

/**
 * Encode a buffer to a hexadecimal string.
 * @param {ArrayBuffer|ArrayBufferView} buffer
 * @returns {string}
 */
export function toHexString(buffer) {
  return Convert.ToHex(buffer);
}

/**
 * Decode a hexadecimal string into an ArrayBuffer.
 * @param {string} hex
 * @returns {ArrayBuffer}
 */
export function fromHexString(hex) {
  return Convert.FromHex(hex);
}

/**
 * Encode a buffer to a Base64 string.
 * @param {ArrayBuffer|ArrayBufferView} buffer
 * @returns {string}
 */
export function toBase64String(buffer) {
  return Convert.ToBase64(buffer);
}

/**
 * Decode a Base64 string into an ArrayBuffer.
 * @param {string} base64
 * @returns {ArrayBuffer}
 */
export function fromBase64String(base64) {
  return Convert.FromBase64(base64);
}

/**
 * Convert a UTF-8 string to an ArrayBuffer.
 * @param {string} text
 * @returns {ArrayBuffer}
 */
export function utf8ToBuffer(text) {
  return Convert.FromUtf8String(text);
}

/**
 * Convert an ArrayBuffer or ArrayBufferView to a UTF-8 string.
 * @param {ArrayBuffer|ArrayBufferView} buffer
 * @returns {string}
 */
export function bufferToUtf8(buffer) {
  return Convert.ToUtf8String(buffer);
}

export { BufferSourceConverter, Convert, isEqual };

import assert from 'node:assert';
import {
  BufferSourceConverter,
  Convert,
  toArrayBuffer,
  toUint8Array,
  concatBuffers,
  areBuffersEqual,
  toHexString,
  fromHexString,
  toBase64String,
  fromBase64String,
  utf8ToBuffer,
  bufferToUtf8,
} from '../src/index.js';

// 1. BufferSourceConverter type checks and conversions
const u8 = new Uint8Array([10, 20, 30, 40]);
assert.strictEqual(BufferSourceConverter.isBufferSource(u8), true);
assert.strictEqual(BufferSourceConverter.isBufferSource(u8.buffer), true);
assert.strictEqual(BufferSourceConverter.isBufferSource('not-a-buffer'), false);
assert.strictEqual(BufferSourceConverter.isArrayBuffer(u8.buffer), true);
assert.strictEqual(BufferSourceConverter.isArrayBuffer(u8), false);
assert.strictEqual(BufferSourceConverter.isArrayBufferView(u8), true);

const convertedAb = toArrayBuffer(u8);
assert.strictEqual(convertedAb instanceof ArrayBuffer, true);
assert.strictEqual(convertedAb.byteLength, 4);

const convertedU8 = toUint8Array(convertedAb);
assert.strictEqual(convertedU8 instanceof Uint8Array, true);
assert.strictEqual(convertedU8.length, 4);
assert.strictEqual(convertedU8[0], 10);
assert.strictEqual(convertedU8[3], 40);

// 2. BufferSourceConverter concatenation
const part1 = new Uint8Array([1, 2]);
const part2 = new Uint8Array([3, 4, 5]);
const part3 = new Uint8Array([6]);
const joined = concatBuffers(part1, part2, part3);
assert.strictEqual(joined instanceof ArrayBuffer, true);
assert.strictEqual(joined.byteLength, 6);
assert.deepStrictEqual(Array.from(new Uint8Array(joined)), [1, 2, 3, 4, 5, 6]);

// 3. BufferSourceConverter equality
const bufA = new Uint8Array([1, 2, 3]);
const bufB = new Uint8Array([1, 2, 3]);
const bufC = new Uint8Array([1, 2, 4]);
assert.strictEqual(areBuffersEqual(bufA, bufB), true);
assert.strictEqual(areBuffersEqual(bufA, bufC), false);
assert.strictEqual(areBuffersEqual(bufA.buffer, bufB), true);

// 4. Convert ToHex and FromHex
const hexTestBuf = new Uint8Array([0xde, 0xad, 0xbe, 0xef]);
const hexStr = toHexString(hexTestBuf);
assert.strictEqual(hexStr.toLowerCase(), 'deadbeef');
assert.strictEqual(Convert.isHex(hexStr), true);
assert.strictEqual(Convert.isHex('not-hex!'), false);

const fromHexAb = fromHexString('deadbeef');
assert.strictEqual(fromHexAb instanceof ArrayBuffer, true);
assert.deepStrictEqual(Array.from(new Uint8Array(fromHexAb)), [0xde, 0xad, 0xbe, 0xef]);

// 5. Convert ToBase64 and FromBase64
const rawBytes = new Uint8Array([72, 101, 108, 108, 111]); // "Hello"
const b64Str = toBase64String(rawBytes);
assert.strictEqual(b64Str, 'SGVsbG8=');
assert.strictEqual(Convert.isBase64(b64Str), true);

const decodedB64Ab = fromBase64String('SGVsbG8=');
assert.strictEqual(decodedB64Ab instanceof ArrayBuffer, true);
assert.deepStrictEqual(Array.from(new Uint8Array(decodedB64Ab)), [72, 101, 108, 108, 111]);

// 6. Convert ToUtf8String and FromUtf8String
const sampleText = 'CodeSampleX pvtsutils verification';
const utf8Buf = utf8ToBuffer(sampleText);
assert.strictEqual(utf8Buf instanceof ArrayBuffer, true);

const decodedText = bufferToUtf8(utf8Buf);
assert.strictEqual(decodedText, sampleText);

console.log('All pvtsutils contract assertions passed.');