bare-bundle 1.10.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-bundle@1.10.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/bare-bundle@1.10.0
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:2d9226a335f2fe18e893ca245b273ee19dbf2c994e9af72e75ca61fefaf1b7b2","constraints":{"executionContext":"node"},"contract":["Bundle.prototype[Symbol.iterator] yields [path, buffer, mode] tuples for each file in the bundle","Bundle.prototype[Symbol.iterator] yields empty sequence when bundle contains no files","Bundle.prototype.files exposes MemoryFile instances providing read, size, and mode accessors","Bundle.prototype.toBuffer supports shared option allocating a SharedArrayBuffer backing","Bundle.from returns the same Bundle instance when passed an existing Bundle","Bundle property setters enforce type checking throwing TypeError on invalid input types"],"goal":"verify pkg:npm/bare-bundle@1.10.0","kind":"HOW","packages":["pkg:npm/bare-bundle@1.10.0"],"schemaVersion":1},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","executionContext":"node","language":"javascript","libc":"glibc","libcVersion":"2.39","moduleSystem":"esm","os":"linux","osVersionBucket":"24","packageManager":"npm","packageManagerVersion":"10.9.8","runtime":"node","runtimeVersion":"22.23.2","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/bare-bundle@1.10.0"],"schemaVersion":1,"subject":"pkg:npm/bare-bundle@1.10.0","verifierAdapter":"node-typescript@1"}

import Bundle from 'bare-bundle';

/**
 * Creates a bundle and populates it with files.
 * @param {Array<{path: string, content: string|Buffer, options?: object}>} files
 * @returns {Bundle}
 */
export function createBundle(files = []) {
  const bundle = new Bundle();
  for (const file of files) {
    bundle.write(file.path, file.content, file.options);
  }
  return bundle;
}

/**
 * Collects all entries from a bundle using its iterator.
 * @param {Bundle} bundle
 * @returns {Array<[string, Buffer, number]>}
 */
export function iterateBundle(bundle) {
  return [...bundle];
}

/**
 * Retrieves file records from a bundle.
 * @param {Bundle} bundle
 * @returns {Record<string, object>}
 */
export function getBundleFiles(bundle) {
  return bundle.files;
}

export default Bundle;
export { Bundle };

{
  "name": "sample-bare-bundle",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-bare-bundle",
      "version": "1.0.0",
      "license": "MIT-0",
      "dependencies": {
        "bare-bundle": "1.10.0"
      }
    },
    "node_modules/bare-bundle": {
      "version": "1.10.0",
      "resolved": "https://registry.npmjs.org/bare-bundle/-/bare-bundle-1.10.0.tgz",
      "integrity": "sha512-4LVlnJAHr00Hh6Vu6ZUJS38rcEtJT3b3vChXSsBsJ2mk1TN0lQ+gzd+Dw5L0aV7uqDZv84smuwW+O02X7PfDlw==",
      "license": "Apache-2.0",
      "peerDependencies": {
        "bare-buffer": "*",
        "bare-url": "*"
      },
      "peerDependenciesMeta": {
        "bare-buffer": {
          "optional": true
        },
        "bare-url": {
          "optional": true
        }
      }
    }
  }
}

{
  "name": "sample-bare-bundle",
  "version": "1.0.0",
  "type": "module",
  "private": true,
  "license": "MIT-0",
  "scripts": {
    "test": "node test/contract.mjs"
  },
  "dependencies": {
    "bare-bundle": "1.10.0"
  }
}

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

import assert from 'node:assert/strict';
import Bundle, { createBundle, iterateBundle, getBundleFiles } from '../index.js';

// 1. Bundle.prototype[Symbol.iterator] yields [path, buffer, mode] tuples for each file in the bundle
{
  const bundle = createBundle([
    { path: '/app.js', content: 'console.log("app");', options: { mode: 0o755 } },
    { path: '/config.json', content: '{"active":true}', options: { mode: 0o644 } }
  ]);

  const entries = iterateBundle(bundle);
  assert.equal(entries.length, 2);

  const [first, second] = entries;
  assert.equal(first[0], '/app.js');
  assert.equal(Buffer.isBuffer(first[1]), true);
  assert.equal(first[1].toString('utf8'), 'console.log("app");');
  assert.equal(first[2], 0o755);

  assert.equal(second[0], '/config.json');
  assert.equal(Buffer.isBuffer(second[1]), true);
  assert.equal(second[1].toString('utf8'), '{"active":true}');
  assert.equal(second[2], 0o644);
}

// 2. Bundle.prototype[Symbol.iterator] yields empty sequence when bundle contains no files
{
  const bundle = new Bundle();
  const entries = iterateBundle(bundle);
  assert.deepEqual(entries, []);
}

// 3. Bundle.prototype.files exposes MemoryFile instances providing read, size, and mode accessors
{
  const bundle = createBundle([
    { path: '/data.txt', content: 'bundle content', options: { mode: 0o600 } }
  ]);

  const files = getBundleFiles(bundle);
  assert.ok(files['/data.txt']);
  assert.equal(typeof files['/data.txt'].read, 'function');
  assert.equal(typeof files['/data.txt'].size, 'function');
  assert.equal(typeof files['/data.txt'].mode, 'function');
  assert.equal(files['/data.txt'].size(), 14);
  assert.equal(files['/data.txt'].mode(), 0o600);
  assert.deepEqual(files['/data.txt'].read(), Buffer.from('bundle content'));
}

// 4. Bundle.prototype.toBuffer supports shared option allocating a SharedArrayBuffer backing
{
  const bundle = createBundle([
    { path: '/shared.txt', content: 'shared data' }
  ]);

  const buf = bundle.toBuffer({ shared: true });
  assert.equal(Buffer.isBuffer(buf), true);
  assert.equal(buf.buffer instanceof SharedArrayBuffer, true);
  assert.ok(buf.byteLength > 0);
}

// 5. Bundle.from returns the same Bundle instance when passed an existing Bundle
{
  const bundle = new Bundle();
  bundle.write('/main.js', 'console.log(1);');
  const result = Bundle.from(bundle);
  assert.equal(result, bundle);
}

// 6. Bundle property setters enforce type checking throwing TypeError on invalid input types
{
  const bundle = new Bundle();
  assert.throws(() => { bundle.id = 123; }, TypeError);
  assert.throws(() => { bundle.main = 123; }, TypeError);
  assert.throws(() => { bundle.imports = 123; }, TypeError);
  assert.throws(() => { bundle.resolutions = 123; }, TypeError);
  assert.throws(() => { bundle.addons = 123; }, TypeError);
  assert.throws(() => { bundle.assets = 123; }, TypeError);
  assert.throws(() => { bundle.write(123, 'data'); }, TypeError);
}

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