fflate 0.8.3: zlibSync

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 fflate.zlibSync in pkg:npm/fflate@0.8.3
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/fflate@0.8.3
Demonstrate these symbols/APIs:
  - fflate.zlibSync

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:6f7987f53b1d7a06a9ba025a3e24cc1595c0660853f84527f7cce6ada467d36b","contract":["fflate.zlibSync is exported as a function","fflate.zlibSync compresses a Uint8Array into valid zlib data decompressible by unzlibSync","fflate.zlibSync handles empty Uint8Array input and produces valid zlib payload","fflate.zlibSync respects compression level options","fflate.zlibSync compresses repetitive data into significantly smaller output","module index wrapper compressZlibSync matches fflate.zlibSync output"],"goal":"verify fflate.zlibSync in pkg:npm/fflate@0.8.3","kind":"HOW","packages":["pkg:npm/fflate@0.8.3"],"schemaVersion":1,"symbols":["fflate.zlibSync"]},"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/fflate@0.8.3"],"schemaVersion":1,"subject":"pkg:npm/fflate@0.8.3","symbols":["fflate.zlibSync"],"verifierAdapter":"node-typescript@1"}

import * as fflate from 'fflate';

export const zlibSync = fflate.zlibSync;
export const unzlibSync = fflate.unzlibSync;

/**
 * Synchronously compresses data using zlib format.
 *
 * @param {Uint8Array} data - The byte array to compress.
 * @param {object} [opts] - Compression options (e.g. level, mem).
 * @returns {Uint8Array} The zlib-compressed byte array.
 */
export function compressZlibSync(data, opts) {
  return fflate.zlibSync(data, opts);
}

/**
 * Synchronously decompresses zlib-compressed data.
 *
 * @param {Uint8Array} data - The compressed zlib byte array.
 * @param {object} [opts] - Decompression options.
 * @returns {Uint8Array} The decompressed byte array.
 */
export function decompressZlibSync(data, opts) {
  return fflate.unzlibSync(data, opts);
}

export default fflate;

{
  "name": "sample-fflate-zlib-sync",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-fflate-zlib-sync",
      "version": "1.0.0",
      "license": "MIT-0",
      "dependencies": {
        "fflate": "0.8.3"
      }
    },
    "node_modules/fflate": {
      "version": "0.8.3",
      "resolved": "https://registry.npmjs.org/fflate/-/fflate-0.8.3.tgz",
      "integrity": "sha512-tbZNuJrLwGUp3zshBtdy4W+ORxZuIh8a5ilyIEQDC5rY1f3U20JMry0Ll3WBzU58EZKsEuJFXhb5gwv8CsPvgA==",
      "license": "MIT"
    }
  }
}

{
  "name": "sample-fflate-zlib-sync",
  "version": "1.0.0",
  "type": "module",
  "main": "index.mjs",
  "license": "MIT-0",
  "scripts": {
    "test": "node test/contract.mjs"
  },
  "dependencies": {
    "fflate": "0.8.3"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify fflate.zlibSync in pkg:npm/fflate@0.8.3",
  "kind": "HOW",
  "packages": [
    "pkg:npm/fflate@0.8.3"
  ],
  "symbols": [
    "fflate.zlibSync"
  ]
}

import assert from 'node:assert/strict';
import * as fflate from 'fflate';
import { zlibSync, unzlibSync, compressZlibSync, decompressZlibSync } from '../index.mjs';

// 1. fflate.zlibSync is exported as a function
assert.equal(typeof fflate.zlibSync, 'function');
assert.equal(typeof zlibSync, 'function');
assert.equal(typeof compressZlibSync, 'function');

// 2. fflate.zlibSync compresses a Uint8Array into valid zlib data decompressible by unzlibSync
const sampleText = 'CodeSampleX contract verification: fflate.zlibSync compressing zlib stream payload.';
const sampleBytes = new TextEncoder().encode(sampleText);
const compressed = fflate.zlibSync(sampleBytes);
assert(compressed instanceof Uint8Array);
assert(compressed.length > 0);

const decompressed = fflate.unzlibSync(compressed);
assert(decompressed instanceof Uint8Array);
assert.equal(new TextDecoder().decode(decompressed), sampleText);

// 3. fflate.zlibSync handles empty Uint8Array input and produces valid zlib payload
const emptyBytes = new Uint8Array(0);
const compressedEmpty = fflate.zlibSync(emptyBytes);
assert(compressedEmpty instanceof Uint8Array);
const decompressedEmpty = fflate.unzlibSync(compressedEmpty);
assert(decompressedEmpty instanceof Uint8Array);
assert.equal(decompressedEmpty.length, 0);

// 4. fflate.zlibSync respects compression level options
const repeatedData = new Uint8Array(2000).fill(0x42);
const compL0 = fflate.zlibSync(repeatedData, { level: 0 });
const compL9 = fflate.zlibSync(repeatedData, { level: 9 });
assert.ok(compL0.length > repeatedData.length, 'level 0 adds uncompressed zlib block overhead');
assert.ok(compL9.length < compL0.length, 'level 9 must achieve higher compression than level 0');
assert.deepEqual(fflate.unzlibSync(compL0), repeatedData, 'level 0 decompressed data must match original');
assert.deepEqual(fflate.unzlibSync(compL9), repeatedData, 'level 9 decompressed data must match original');

// 5. fflate.zlibSync compresses repetitive data into significantly smaller output
const repetitive = new TextEncoder().encode('ABCDEF1234567890'.repeat(100));
const repetitiveComp = fflate.zlibSync(repetitive, { level: 6 });
assert.ok(repetitiveComp.length < repetitive.length / 5, 'repetitive data must compress significantly');
assert.deepEqual(fflate.unzlibSync(repetitiveComp), repetitive, 'repetitive decompressed data must match original');

// 6. module index wrapper compressZlibSync matches fflate.zlibSync output
const wrapperCompressed = compressZlibSync(sampleBytes);
assert(wrapperCompressed instanceof Uint8Array);
const wrapperDecompressed = decompressZlibSync(wrapperCompressed);
assert.equal(new TextDecoder().decode(wrapperDecompressed), sampleText);

console.log('All fflate.zlibSync contract assertions passed.');