minizlib 3.1.0: Deflate

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 minizlib.Deflate in pkg:npm/minizlib@3.1.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/minizlib@3.1.0
Demonstrate these symbols/APIs:
  - minizlib.Deflate

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:6fbcfbe24bbeceb7fa3822b27d0d219059e7f170bcae6bb5f40068b605b4cb9e","contract":["Deflate is exported as a constructor and creates stream instances","Deflate compresses string and Buffer payloads that Inflate restores accurately","Deflate accepts compression parameters such as level and strategy","Deflate supports streaming compression with multiple sequential writes","Deflate compresses empty buffer input into valid decodable deflate format","Deflate produces output directly verifiable by Node.js built-in zlib inflate decompressor","Deflate pipes compressed streams directly to consumer streams","Deflate flushes intermediate compressed blocks when flush is called with Z_SYNC_FLUSH"],"goal":"verify minizlib.Deflate in pkg:npm/minizlib@3.1.0","kind":"HOW","packages":["pkg:npm/minizlib@3.1.0"],"schemaVersion":1,"symbols":["minizlib.Deflate"]},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","executionContext":"node","language":"javascript","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"npm","packageManagerVersion":"10.9.8","runtime":"node","runtimeVersion":"22.23.2","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/minizlib@3.1.0"],"schemaVersion":1,"subject":"pkg:npm/minizlib@3.1.0","symbols":["minizlib.Deflate"],"verifierAdapter":"node-typescript@1"}

{
  "name": "sample-minizlib-deflate",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-minizlib-deflate",
      "version": "1.0.0",
      "dependencies": {
        "minizlib": "3.1.0"
      }
    },
    "node_modules/minipass": {
      "version": "7.1.3",
      "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz",
      "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==",
      "license": "BlueOak-1.0.0",
      "engines": {
        "node": ">=16 || 14 >=14.17"
      }
    },
    "node_modules/minizlib": {
      "version": "3.1.0",
      "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-3.1.0.tgz",
      "integrity": "sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw==",
      "license": "MIT",
      "dependencies": {
        "minipass": "^7.1.2"
      },
      "engines": {
        "node": ">= 18"
      }
    }
  }
}

{
  "name": "sample-minizlib-deflate",
  "version": "1.0.0",
  "private": true,
  "type": "module",
  "dependencies": {
    "minizlib": "3.1.0"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify minizlib.Deflate in pkg:npm/minizlib@3.1.0",
  "kind": "HOW",
  "packages": [
    "pkg:npm/minizlib@3.1.0"
  ],
  "symbols": [
    "minizlib.Deflate"
  ]
}

import assert from 'node:assert/strict';
import { createRequire } from 'node:module';
import zlib from 'node:zlib';

const require = createRequire(import.meta.url);
const { Deflate, Inflate, constants } = require('minizlib');

// 1. Deflate is exported as a constructor and creates stream instances
{
  assert.strictEqual(typeof Deflate, 'function', 'Deflate should be a constructor function');
  const instance = new Deflate();
  assert.ok(instance instanceof Deflate, 'Instance should be of type Deflate');
  assert.strictEqual(typeof instance.write, 'function', 'Instance should implement write method');
  assert.strictEqual(typeof instance.read, 'function', 'Instance should implement read method');
  assert.strictEqual(typeof instance.pipe, 'function', 'Instance should implement pipe method');
}

// 2. Deflate compresses string and Buffer payloads that Inflate restores accurately
{
  const testPayload = Buffer.from('Standard payload for Deflate compression and decompression verification.');
  const compressor = new Deflate();
  compressor.end(testPayload);
  const compressed = compressor.read();

  assert.ok(Buffer.isBuffer(compressed), 'Compressor output must be a Buffer');
  assert.ok(compressed.length > 0, 'Compressed output must not be empty');

  const decompressor = new Inflate();
  decompressor.end(compressed);
  const decompressed = decompressor.read();

  assert.ok(Buffer.isBuffer(decompressed), 'Decompressor output must be a Buffer');
  assert.deepStrictEqual(decompressed, testPayload, 'Decompressed payload must match original buffer');
}

// 3. Deflate accepts compression parameters such as level and strategy
{
  const input = Buffer.from('Compression level parameter test with repeated phrases. '.repeat(30));

  const fastCompressor = new Deflate({
    level: constants.Z_BEST_SPEED,
  });
  fastCompressor.end(input);
  const fastCompressed = fastCompressor.read();

  const bestCompressor = new Deflate({
    level: constants.Z_BEST_COMPRESSION,
  });
  bestCompressor.end(input);
  const bestCompressed = bestCompressor.read();

  assert.ok(bestCompressed.length <= fastCompressed.length, 'Higher compression level should produce equal or smaller size');

  const decompressor = new Inflate();
  decompressor.end(bestCompressed);
  assert.deepStrictEqual(decompressor.read(), input, 'Payload compressed with max level must decompress correctly');
}

// 4. Deflate supports streaming compression with multiple sequential writes
{
  const part1 = Buffer.from('Sequential chunk 1. ');
  const part2 = Buffer.from('Sequential chunk 2. ');
  const part3 = Buffer.from('Sequential chunk 3.');
  const full = Buffer.concat([part1, part2, part3]);

  const compressor = new Deflate();
  compressor.write(part1);
  compressor.write(part2);
  compressor.end(part3);
  const compressed = compressor.read();

  const decompressor = new Inflate();
  decompressor.end(compressed);
  assert.deepStrictEqual(decompressor.read(), full, 'Chunked streaming compression must reconstruct combined payload');
}

// 5. Deflate compresses empty buffer input into valid decodable deflate format
{
  const empty = Buffer.alloc(0);
  const compressor = new Deflate();
  compressor.end(empty);
  const compressed = compressor.read();

  assert.ok(Buffer.isBuffer(compressed), 'Compressed output of empty input must be a Buffer');

  const decompressor = new Inflate();
  decompressor.end(compressed);
  const decompressed = decompressor.read() ?? Buffer.alloc(0);

  assert.deepStrictEqual(decompressed, empty, 'Decompressed empty payload must match empty buffer');
}

// 6. Deflate produces output directly verifiable by Node.js built-in zlib inflate decompressor
{
  const sampleText = 'Interoperability verification with Node built-in zlib inflate decompressor';
  const compressor = new Deflate();
  compressor.end(Buffer.from(sampleText));
  const compressed = compressor.read();

  const nativeResult = zlib.inflateSync(compressed);
  assert.strictEqual(nativeResult.toString('utf8'), sampleText, 'Node zlib inflateSync must decode minizlib compressed data');
}

// 7. Deflate pipes compressed streams directly to consumer streams
{
  const data = Buffer.from('Direct stream piping verification between Deflate and Inflate components.');
  const compressor = new Deflate();
  const decompressor = new Inflate();
  const chunks = [];
  decompressor.on('data', chunk => chunks.push(chunk));

  compressor.pipe(decompressor);
  compressor.end(data);

  const result = Buffer.concat(chunks);
  assert.deepStrictEqual(result, data, 'Piped stream must pass and decompress data correctly');
}

// 8. Deflate flushes intermediate compressed blocks when flush is called with Z_SYNC_FLUSH
{
  const compressor = new Deflate();
  const decompressor = new Inflate();

  compressor.write(Buffer.from('Intermediate chunk before sync flush. '));
  compressor.flush(constants.Z_SYNC_FLUSH);
  const flushedChunk = compressor.read();

  assert.ok(Buffer.isBuffer(flushedChunk), 'Flushed output must be a Buffer');
  assert.ok(flushedChunk.length > 0, 'Flushed output must not be empty');

  decompressor.write(flushedChunk);
  const partialDecompressed = decompressor.read();
  assert.strictEqual(
    partialDecompressed.toString('utf8'),
    'Intermediate chunk before sync flush. ',
    'Flushed intermediate chunk must be decompressible before stream end'
  );

  compressor.end(Buffer.from('Final trailing chunk.'));
  const remainingChunk = compressor.read();
  decompressor.end(remainingChunk);
  const finalDecompressed = decompressor.read();
  assert.strictEqual(
    finalDecompressed.toString('utf8'),
    'Final trailing chunk.',
    'Trailing chunk must decompress cleanly after prior sync flush'
  );
}

console.log('All minizlib.Deflate contract tests passed successfully.');