@cj-tech-master/excelts 4.2.0-canary.20260110111632.c88c61c → 4.2.1-canary.20260111102127.f808a37

package/dist/types/index.browser.d.ts

@@ -25,3 +25,4 @@ export { WorkbookWriter, WorkbookReader, WorksheetWriter, WorksheetReader };
 export type { CsvReadOptions, CsvWriteOptions, CsvStreamReadOptions, CsvStreamWriteOptions } from "./modules/csv/csv.browser.js";
 export { CsvParserStream, CsvFormatterStream } from "./modules/csv/csv.browser.js";
 export * from "./modules/excel/utils/sheet-utils.js";
+export { zip, unzip, ZipArchive, ZipReader, UnzipEntry, type ZipOptions, type ZipEntryOptions, type UnzipOptions, type ArchiveSource, type ArchiveSink, crc32, crc32Update, crc32Finalize, compress, compressSync, decompress, decompressSync, hasCompressionStream, type CompressOptions, createDeflateStream, createInflateStream, hasDeflateRaw, type StreamCompressOptions } from "./modules/archive/index.browser.js";

package/dist/{browser/modules/archive → types/modules/archive/compression}/compress.browser.d.ts

@@ -10,15 +10,9 @@
  * - Safari >= 14.1
  * - Edge >= 89
  */
-import { type CompressOptions } from "@archive/compress.base";
+import { type CompressOptions, hasCompressionStream } from "./compress.base.js";
 export { type CompressOptions };
-/**
- * Check if CompressionStream is available in this environment.
- *
- * Note: Some environments may expose CompressionStream but not support
- * the "deflate-raw" format that ZIP requires.
- */
-export declare function hasCompressionStream(): boolean;
+export { hasCompressionStream };
 /**
  * Compress data using browser's native CompressionStream or JS fallback
  *

package/dist/types/modules/archive/{streaming-compress.browser.d.ts → compression/streaming-compress.browser.d.ts}

@@ -6,7 +6,7 @@
  *
  * API compatible with Node.js version - supports .on("data"), .on("end"), .write(callback), .end()
  */
-export type { StreamCompressOptions } from "./streaming-compress.base.js";
+export type { DeflateStream, InflateStream, StreamCompressOptions, StreamingCodec } from "./streaming-compress.base.js";
 import { type DeflateStream, type InflateStream, type StreamCompressOptions } from "./streaming-compress.base.js";
 /**
  * Check if deflate-raw streaming compression is supported by this library.

package/dist/types/modules/archive/defaults.d.ts

@@ -1,4 +1,5 @@
 import type { ZipTimestampMode } from "./utils/timestamps.js";
+export declare const DEFAULT_DEFLATE_LEVEL = 6;
 export declare const DEFAULT_COMPRESS_LEVEL = 6;
 export declare const DEFAULT_ZIP_LEVEL = 6;
 export declare const DEFAULT_ZIP_TIMESTAMPS: ZipTimestampMode;

package/dist/types/modules/archive/index.base.d.ts

@@ -5,7 +5,7 @@
  * Platform-specific entrypoints (index.ts / index.browser.ts) should re-export
  * from this file and then layer their platform-specific bindings.
  */
-export { createZip, createZipSync, ZipBuilder, type ZipEntry, type ZipOptions } from "./zip-builder.js";
-export { StreamingZip, ZipDeflateFile, Zip, ZipDeflate } from "./streaming-zip.js";
-export { extractAll, extractFile, listFiles, forEachEntry, ZipParser, type ExtractedFile, type ZipParseOptions } from "./extract.js";
-export type { ZipEntryInfo } from "./zip-entry-info.js";
+export type { ArchiveSource } from "./io/archive-source.js";
+export type { ArchiveSink } from "./io/archive-sink.js";
+export { zip, ZipArchive, type ZipOptions, type ZipEntryOptions } from "./zip/index.js";
+export { unzip, ZipReader, UnzipEntry, type UnzipOptions } from "./unzip/index.js";

package/dist/types/modules/archive/index.browser.d.ts

@@ -5,7 +5,6 @@
  * browser-specific implementations so we can enforce export-surface parity.
  */
 export * from "./index.base.js";
-export { crc32, crc32Update, crc32Finalize } from "./crc32.browser.js";
-export { compress, compressSync, decompress, decompressSync, hasCompressionStream, type CompressOptions } from "./compress.browser.js";
-export { createDeflateStream, createInflateStream, hasDeflateRaw, type StreamCompressOptions } from "./streaming-compress.browser.js";
-export { Parse, createParse, type ParseOptions, type ZipEntry as StreamZipEntry } from "./parse.browser.js";
+export { crc32, crc32Update, crc32Finalize } from "./compression/crc32.browser.js";
+export { compress, compressSync, decompress, decompressSync, hasCompressionStream, type CompressOptions } from "./compression/compress.browser.js";
+export { createDeflateStream, createInflateStream, hasDeflateRaw, type StreamCompressOptions } from "./compression/streaming-compress.browser.js";

package/dist/types/modules/archive/index.d.ts

@@ -5,7 +5,6 @@
  * It groups all ZIP creation and extraction utilities in one place.
  */
 export * from "./index.base.js";
-export { crc32, crc32Update, crc32Finalize } from "./crc32.js";
-export { compress, compressSync, decompress, decompressSync, hasCompressionStream, type CompressOptions } from "./compress.js";
-export { createDeflateStream, createInflateStream, hasDeflateRaw, type StreamCompressOptions } from "./streaming-compress.js";
-export { Parse, createParse, type ParseOptions, type ZipEntry as StreamZipEntry } from "./parse.js";
+export { crc32, crc32Update, crc32Finalize } from "./compression/crc32.js";
+export { compress, compressSync, decompress, decompressSync, hasCompressionStream, type CompressOptions } from "./compression/compress.js";
+export { createDeflateStream, createInflateStream, hasDeflateRaw, type StreamCompressOptions } from "./compression/streaming-compress.js";

package/dist/types/modules/archive/internal/byte-queue.d.ts

@@ -0,0 +1,33 @@
+export declare class ByteQueue {
+    private static readonly EMPTY;
+    private _chunks;
+    private _headOffset;
+    private _length;
+    private _cachedView;
+    private _cachedLength;
+    constructor(initial?: Uint8Array);
+    get length(): number;
+    isEmpty(): boolean;
+    view(): Uint8Array;
+    reset(data?: Uint8Array): void;
+    append(chunk: Uint8Array): void;
+    read(length: number): Uint8Array;
+    /**
+     * Return a list of chunk views totaling `length` bytes without consuming.
+     *
+     * This avoids materializing a contiguous buffer for streaming write paths.
+     */
+    peekChunks(length: number): Uint8Array[];
+    discard(length: number): void;
+    /**
+     * Find the first index of `pattern` within the queue.
+     *
+     * This avoids materializing a contiguous `view()` for common small patterns
+     * (ZIP signatures are typically 2-4 bytes).
+     */
+    indexOfPattern(pattern: Uint8Array, startIndex?: number): number;
+    /** Peek a little-endian uint32 at `offset` without consuming bytes. Returns null if not enough bytes. */
+    peekUint32LE(offset: number): number | null;
+    /** Peek a single byte at `offset` without consuming bytes. */
+    peekByte(offset: number): number;
+}

package/dist/types/modules/archive/io/archive-sink.d.ts

@@ -0,0 +1,9 @@
+export type ArchiveSink = WritableStream<Uint8Array> | {
+    write(chunk: Uint8Array): any;
+    end?(cb?: any): any;
+    on?(event: string, listener: (...args: any[]) => void): any;
+    once?(event: string, listener: (...args: any[]) => void): any;
+};
+export declare function isWritableStream(value: unknown): value is WritableStream<Uint8Array>;
+export declare function pipeIterableToSink(iterable: AsyncIterable<Uint8Array>, sink: ArchiveSink): Promise<void>;
+export declare function collect(iterable: AsyncIterable<Uint8Array>): Promise<Uint8Array>;

package/dist/types/modules/archive/io/archive-source.d.ts

@@ -0,0 +1,8 @@
+export type ArchiveSource = Uint8Array | ArrayBuffer | string | Blob | AsyncIterable<unknown> | ReadableStream<unknown> | {
+    [Symbol.asyncIterator](): AsyncIterator<unknown>;
+};
+export declare function isReadableStream(value: unknown): value is ReadableStream<unknown>;
+export declare function isAsyncIterable(value: unknown): value is AsyncIterable<unknown>;
+export declare function toUint8ArraySync(source: Uint8Array | ArrayBuffer | string): Uint8Array;
+export declare function toUint8Array(source: Uint8Array | ArrayBuffer | string | Blob): Promise<Uint8Array>;
+export declare function toAsyncIterable(source: ArchiveSource): AsyncIterable<Uint8Array>;

package/dist/types/modules/archive/unzip/index.d.ts

@@ -0,0 +1,40 @@
+import { ZipParser, type ZipEntryInfo } from "./zip-parser.js";
+import { type ParseOptions, type ZipEntry as ParseZipEntry } from "./stream.js";
+import { type ArchiveSink } from "../io/archive-sink.js";
+import { type ArchiveSource } from "../io/archive-source.js";
+export interface UnzipOptions {
+    decodeStrings?: boolean;
+    parse?: ParseOptions;
+}
+export declare class UnzipEntry {
+    readonly path: string;
+    readonly isDirectory: boolean;
+    private readonly _info?;
+    private readonly _parser?;
+    private readonly _parseEntry?;
+    constructor(args: {
+        kind: "buffer";
+        parser: ZipParser;
+        info: ZipEntryInfo;
+    } | {
+        kind: "stream";
+        entry: ParseZipEntry;
+    });
+    bytes(): Promise<Uint8Array>;
+    stream(): AsyncIterable<Uint8Array>;
+    pipeTo(sink: ArchiveSink): Promise<void>;
+    text(encoding?: string): Promise<string>;
+    discard(): void;
+}
+export declare class ZipReader {
+    private readonly _source;
+    private readonly _options;
+    private _bufferParser;
+    constructor(source: ArchiveSource, options?: UnzipOptions);
+    private _ensureBufferParser;
+    get(path: string): Promise<UnzipEntry | null>;
+    entries(): AsyncIterable<UnzipEntry>;
+    bytes(path: string): Promise<Uint8Array | null>;
+    close(): Promise<void>;
+}
+export declare function unzip(source: ArchiveSource, options?: UnzipOptions): ZipReader;

package/dist/types/modules/archive/{parse.base.d.ts → unzip/stream.base.d.ts}

@@ -1,6 +1,7 @@
-import { Duplex, PassThrough, Transform, type Readable } from "../stream/index.js";
-import { ByteQueue } from "./byte-queue.js";
-import { parseZipExtraFields, type ZipExtraFields, type ZipVars } from "./utils/zip-extra-fields.js";
+import { Duplex, PassThrough, Transform, type Readable } from "../../stream/index.js";
+import { ByteQueue } from "../internal/byte-queue.js";
+import { parseZipExtraFields, type ZipExtraFields, type ZipVars } from "../utils/zip-extra-fields.js";
+export declare const DATA_DESCRIPTOR_SIGNATURE_BYTES: Uint8Array<ArrayBufferLike>;
 export declare const CRX_HEADER_FORMAT: [string, number][];
 export declare const LOCAL_FILE_HEADER_FORMAT: [string, number][];
 export declare const DATA_DESCRIPTOR_FORMAT: [string, number][];
@@ -119,9 +120,14 @@ export interface ValidatedDataDescriptorScanResult {
  */
 export declare function scanValidatedDataDescriptor(view: Uint8Array, dataDescriptorSignature: Uint8Array, bytesEmitted: number, startIndex?: number, out?: ValidatedDataDescriptorScanResult): ValidatedDataDescriptorScanResult;
 export interface StreamUntilValidatedDataDescriptorSource {
-    getView(): Uint8Array;
     getLength(): number;
     read(length: number): Uint8Array;
+    /** Optional: zero-copy chunk views for streaming writes. */
+    peekChunks?(length: number): Uint8Array[];
+    /** Optional: consume bytes previously written from peekChunks(). */
+    discard?(length: number): void;
+    indexOfPattern(pattern: Uint8Array, startIndex: number): number;
+    peekUint32LE(offset: number): number | null;
     isFinished(): boolean;
     onDataAvailable(cb: () => void): () => void;
     maybeReleaseWriteCallback?: () => void;
@@ -142,6 +148,34 @@ export declare function streamUntilValidatedDataDescriptor(options: StreamUntilV
 export interface ParseOptions {
     verbose?: boolean;
     forceStream?: boolean;
+    /**
+     * Browser-only: use a Web Worker to run inflate off the main thread.
+     * Defaults to false.
+     */
+    useWorkerInflate?: boolean;
+    /**
+     * Browser-only: provide an explicit Worker script URL.
+     *
+     * Useful under strict CSP that blocks `blob:` workers. When set, the browser
+     * parser will try to construct `new Worker(workerInflateUrl)`.
+     */
+    workerInflateUrl?: string;
+    /**
+     * Input backpressure high-water mark (bytes).
+     *
+     * When provided, implementations may delay the writable callback until the
+     * internal input buffer drops below `inputLowWaterMarkBytes`.
+     *
+     * This is primarily used by the browser parser, because its writable side
+     * otherwise tends to accept unlimited data and can cause large memory spikes.
+     */
+    inputHighWaterMarkBytes?: number;
+    /**
+     * Input backpressure low-water mark (bytes).
+     * When the internal buffer drops to (or below) this value, a delayed writable
+     * callback may be released.
+     */
+    inputLowWaterMarkBytes?: number;
     /**
      * Threshold (in bytes) for small file optimization.
      * Files smaller than this will use sync decompression (no stream overhead).

package/dist/types/modules/archive/{parse.browser.d.ts → unzip/stream.browser.d.ts}

@@ -5,8 +5,8 @@
  * Falls back to pure JavaScript implementation for older browsers.
  * Uses the browser Duplex stream implementation for compatibility.
  */
-import { Duplex } from "../stream/index.js";
-import { type CrxHeader, type PullStreamPublicApi, type EntryProps, type EntryVars, type InflateFactory, type ParseOptions, type ZipEntry } from "./parse.base.js";
+import { Duplex } from "../../stream/index.js";
+import { type CrxHeader, type PullStreamPublicApi, type EntryProps, type EntryVars, type InflateFactory, type ParseOptions, type ZipEntry } from "./stream.base.js";
 export type { CrxHeader, EntryProps, EntryVars, ParseOptions, ZipEntry };
 export type ParseStream = Duplex & {
     promise(): Promise<void>;

package/dist/types/modules/archive/{parse.d.ts → unzip/stream.d.ts}

@@ -1,6 +1,6 @@
-import type { Duplex } from "../stream/index.js";
-import { type PullStreamPublicApi, type CrxHeader, type EntryProps, type EntryVars, type InflateFactory, type ParseOptions, type ZipEntry } from "./parse.base.js";
-export type { CrxHeader } from "./parse.base.js";
+import type { Duplex } from "../../stream/index.js";
+import { type PullStreamPublicApi, type CrxHeader, type EntryProps, type EntryVars, type InflateFactory, type ParseOptions, type ZipEntry } from "./stream.base.js";
+export type { CrxHeader } from "./stream.base.js";
 export type { EntryProps, EntryVars, ParseOptions, ZipEntry };
 export type ParseStream = Duplex & {
     promise(): Promise<void>;

package/dist/types/modules/archive/{zip-parser.d.ts → unzip/zip-parser.d.ts}

@@ -3,7 +3,7 @@
  * Works in both Node.js and browser environments
  * No dependency on Node.js stream module
  */
-import type { ZipEntryInfo } from "./zip-entry-info.js";
+import type { ZipEntryInfo } from "../zip-spec/zip-entry-info.js";
 export type { ZipEntryInfo };
 /**
  * ZIP parsing options

package/dist/types/modules/archive/utils/async-queue.d.ts

@@ -0,0 +1,7 @@
+export type AsyncQueue<T> = {
+    push: (value: T) => void;
+    fail: (err: Error) => void;
+    close: () => void;
+    iterable: AsyncIterable<T>;
+};
+export declare function createAsyncQueue<T>(): AsyncQueue<T>;

package/dist/types/modules/archive/utils/compressibility.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Heuristic: detect incompressible (high-entropy) data.
+ *
+ * This is a performance optimization: if data looks random, DEFLATE usually
+ * wastes CPU and may even produce slightly larger output.
+ */
+export declare function isProbablyIncompressible(data: Uint8Array, options?: {
+    sampleBytes?: number;
+    minDecisionBytes?: number;
+}): boolean;

package/dist/types/modules/archive/utils/pattern-scanner.d.ts

@@ -0,0 +1,21 @@
+export interface PatternSearchTarget {
+    indexOfPattern(pattern: Uint8Array, startIndex: number): number;
+}
+/**
+ * Stateful helper for incremental pattern scanning in growing buffers.
+ *
+ * The scanner tracks a `searchFrom` cursor and an `overlap` region so callers
+ * can avoid rescanning bytes that cannot start a match.
+ */
+export declare class PatternScanner {
+    readonly pattern: Uint8Array;
+    readonly overlap: number;
+    searchFrom: number;
+    constructor(pattern: Uint8Array);
+    /** Find the next match index starting at the current `searchFrom`. */
+    find(target: PatternSearchTarget): number;
+    /** Update `searchFrom` after consuming `consumed` bytes from the front. */
+    onConsume(consumed: number): void;
+    /** Update `searchFrom` after a no-match scan on a buffer of length `bufferLength`. */
+    onNoMatch(bufferLength: number): void;
+}

package/dist/types/modules/archive/utils/zip-extra-fields.d.ts

@@ -1,7 +1,7 @@
 /**
  * ZIP extra field parsing helpers.
  *
- * Kept standalone so both streaming parser (`parse.base.ts`) and buffer parser
+ * Kept standalone so both streaming parser (`stream.base.ts`) and buffer parser
  * (`zip-parser.ts`) can share ZIP64 + Info-ZIP timestamp handling.
  */
 export interface ZipVars {

package/dist/types/modules/archive/zip/index.d.ts

@@ -0,0 +1,42 @@
+import type { ZipTimestampMode } from "../utils/timestamps.js";
+import { type ArchiveSink } from "../io/archive-sink.js";
+import { type ArchiveSource } from "../io/archive-source.js";
+export interface ZipOptions {
+    level?: number;
+    timestamps?: ZipTimestampMode;
+    comment?: string;
+    /**
+     * Default modification time for entries that don't specify `modTime`.
+     *
+     * If you need stable output across runs, either pass this explicitly or use `reproducible: true`.
+     */
+    modTime?: Date;
+    /**
+     * If true, bias defaults toward reproducible output:
+     * - default `modTime` becomes 1980-01-01 00:00:00 (local time)
+     * - default `timestamps` becomes "dos" (no UTC extra field)
+     */
+    reproducible?: boolean;
+    /**
+     * If true (default), automatically STORE incompressible data.
+     * If false, always follow `level` (DEFLATE when level > 0).
+     */
+    smartStore?: boolean;
+}
+export interface ZipEntryOptions {
+    level?: number;
+    modTime?: Date;
+    comment?: string;
+}
+export declare class ZipArchive {
+    private readonly _options;
+    private readonly _entries;
+    private _sealed;
+    constructor(options?: ZipOptions);
+    add(name: string, source: ArchiveSource, options?: ZipEntryOptions): this;
+    stream(): AsyncIterable<Uint8Array>;
+    bytes(): Promise<Uint8Array>;
+    bytesSync(): Uint8Array;
+    pipeTo(sink: ArchiveSink): Promise<void>;
+}
+export declare function zip(options?: ZipOptions): ZipArchive;

package/dist/types/modules/archive/{streaming-zip.d.ts → zip/stream.d.ts}

@@ -2,17 +2,18 @@
  * True Streaming ZIP creator - shared implementation.
  *
  * This module is intentionally platform-agnostic.
- * - In Node builds it uses `./crc32` + `./streaming-compress` (zlib-backed).
+ * - In Node builds it uses `./compression/crc32` + `./compression/streaming-compress` (zlib-backed).
  * - In browser builds the bundler aliases those imports to their browser variants.
  */
-import type { ZipTimestampMode } from "./utils/timestamps.js";
-import type { ZipEntryInfo as UnzipZipEntryInfo } from "./zip-entry-info.js";
+import type { ZipTimestampMode } from "../utils/timestamps.js";
+import type { ZipEntryInfo as UnzipZipEntryInfo } from "../zip-spec/zip-entry-info.js";
 /**
  * Internal entry info for central directory
  */
 interface ZipEntryInfo {
     name: Uint8Array;
     extraField: Uint8Array;
+    comment: Uint8Array;
     flags: number;
     crc: number;
     compressedSize: number;
@@ -34,43 +35,62 @@ export declare class ZipDeflateFile {
     private _finalized;
     private _headerEmitted;
     private _ondata;
+    private _onerror;
     private _centralDirEntryInfo;
     private _pendingEnd;
     private _emittedDataDescriptor;
     private _localHeader;
+    private _deflateWanted;
+    private _pendingChunks;
+    private _sampleBuffer;
+    private _sampleLen;
+    private _smartStore;
     private _completeResolve;
     private _completeReject;
     private _completePromise;
     private _completeError;
     private _dataQueue;
     private _finalQueued;
+    private _pushChain;
     readonly name: string;
     readonly level: number;
     readonly nameBytes: Uint8Array;
+    readonly commentBytes: Uint8Array;
     readonly dosTime: number;
     readonly dosDate: number;
     readonly extraField: Uint8Array;
     private readonly _flags;
-    private readonly _compressionMethod;
+    private _compressionMethod;
     private readonly _modTime;
     constructor(name: string, options?: {
         level?: number;
         modTime?: Date;
         timestamps?: ZipTimestampMode;
+        comment?: string;
+        smartStore?: boolean;
     });
+    private _buildCompressionMethod;
+    private _initDeflateStream;
     private _buildLocalHeader;
+    private _accumulateSample;
+    private _shouldDecide;
+    private _decideCompressionIfNeeded;
+    private _emitHeaderIfNeeded;
+    private _flushPendingChunks;
     private _enqueueData;
     private _flushQueue;
     get ondata(): ((data: Uint8Array, final: boolean) => void) | undefined;
     set ondata(cb: (data: Uint8Array, final: boolean) => void);
+    get onerror(): ((err: Error) => void) | undefined;
+    set onerror(cb: (err: Error) => void);
     private _resolveComplete;
     private _rejectComplete;
     private _ensureCompletePromise;
     private _tapCallback;
-    private _emitHeaderIfNeeded;
     private _writeData;
     private _endDeflateAndWait;
     private _finalizeAfterWrite;
+    private _pushUnchained;
     /**
      * Push data - immediately compresses and outputs
      * Returns a Promise that resolves when the write is complete.
@@ -108,10 +128,13 @@ export declare class StreamingZip {
     private currentOffset;
     private ended;
     private endPending;
+    private zipComment;
     private fileQueue;
     private fileQueueIndex;
     private activeFile;
-    constructor(callback: (err: Error | null, data: Uint8Array, final: boolean) => void);
+    constructor(callback: (err: Error | null, data: Uint8Array, final: boolean) => void, options?: {
+        comment?: string;
+    });
     add(file: ZipDeflateFile): void;
     private _processNextFile;
     private _finalize;

package/dist/types/modules/archive/zip/zip-bytes.d.ts

@@ -0,0 +1,73 @@
+/**
+ * ZIP file format encoder (single-buffer output)
+ *
+ * Implements ZIP file structure according to PKWARE's APPNOTE.TXT specification
+ * https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
+ *
+ * This module focuses on producing a complete ZIP as a single Uint8Array.
+ * For true streaming (push chunks while reading sources), use `zip()` / `ZipArchive.stream()`.
+ */
+import { type CompressOptions } from "../compression/compress.js";
+import { type ZipTimestampMode } from "../utils/timestamps.js";
+/**
+ * ZIP file entry
+ */
+export interface ZipEntry {
+    /** File name (can include directory path, use forward slashes) */
+    name: string;
+    /** File data (will be compressed unless level=0) */
+    data: Uint8Array;
+    /** Optional per-entry compression level override */
+    level?: number;
+    /** File modification time (optional, defaults to current time) */
+    modTime?: Date;
+    /** File comment (optional) */
+    comment?: string;
+}
+/**
+ * ZIP encoder options
+ */
+export interface ZipOptions extends CompressOptions {
+    /** ZIP file comment (optional) */
+    comment?: string;
+    /**
+     * Default modification time for entries that don't specify `modTime`.
+     *
+     * If you need stable output across runs, either pass this explicitly or use `reproducible: true`.
+     */
+    modTime?: Date;
+    /**
+     * If true, bias defaults toward reproducible output:
+     * - default `modTime` becomes 1980-01-01 00:00:00 (local time)
+     * - default `timestamps` becomes "dos" (no UTC extra field)
+     */
+    reproducible?: boolean;
+    /**
+     * Max number of entries to compress concurrently in `createZip()`.
+     * This helps avoid zlib threadpool saturation / memory spikes with many files.
+     *
+     * Defaults to 4.
+     */
+    concurrency?: number;
+    /**
+     * If true (default), automatically STORE incompressible data.
+     * If false, always follow `level` (DEFLATE when level > 0).
+     */
+    smartStore?: boolean;
+    /**
+     * Timestamp writing strategy.
+     * - "dos": only write DOS date/time fields (smallest output)
+     * - "dos+utc": also write UTC mtime in 0x5455 extra field
+     */
+    timestamps?: ZipTimestampMode;
+}
+/**
+ * Create a ZIP file from entries (async)
+ */
+export declare function createZip(entries: ZipEntry[], options?: ZipOptions): Promise<Uint8Array>;
+/**
+ * Create a ZIP file from entries (sync)
+ *
+ * This is supported in both Node.js and browser builds.
+ */
+export declare function createZipSync(entries: ZipEntry[], options?: ZipOptions): Uint8Array;

package/dist/types/modules/archive/{zip-entry-metadata.d.ts → zip/zip-entry-metadata.d.ts}

@@ -1,4 +1,4 @@
-import { type ZipTimestampMode } from "./utils/timestamps.js";
+import { type ZipTimestampMode } from "../utils/timestamps.js";
 export interface ZipEntryMetadata {
     nameBytes: Uint8Array;
     commentBytes: Uint8Array;

package/dist/types/modules/archive/{zip-records.d.ts → zip-spec/zip-records.d.ts}

@@ -3,6 +3,23 @@
  *
  * Shared by streaming zip writer and buffer zip builder.
  */
+export declare const LOCAL_FILE_HEADER_SIG = 67324752;
+export declare const CENTRAL_DIR_HEADER_SIG = 33639248;
+export declare const END_OF_CENTRAL_DIR_SIG = 101010256;
+export declare const DATA_DESCRIPTOR_SIG = 134695760;
+export declare const ZIP64_END_OF_CENTRAL_DIR_SIG = 101075792;
+export declare const ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG = 117853008;
+export declare const VERSION_NEEDED = 20;
+export declare const VERSION_MADE_BY = 20;
+export declare const COMPRESSION_STORE = 0;
+export declare const COMPRESSION_DEFLATE = 8;
+export declare const FLAG_UTF8 = 2048;
+export declare const FLAG_DATA_DESCRIPTOR = 8;
+export declare const UINT16_MAX = 65535;
+export declare const UINT32_MAX = 4294967295;
+export declare const ZIP_LOCAL_FILE_HEADER_FIXED_SIZE = 30;
+export declare const ZIP_CENTRAL_DIR_HEADER_FIXED_SIZE = 46;
+export declare const ZIP_END_OF_CENTRAL_DIR_FIXED_SIZE = 22;
 export interface ZipLocalFileHeaderInput {
     fileName: Uint8Array;
     extraField: Uint8Array;
@@ -15,6 +32,7 @@ export interface ZipLocalFileHeaderInput {
     uncompressedSize: number;
     versionNeeded?: number;
 }
+export declare function writeLocalFileHeaderInto(out: Uint8Array, view: DataView, offset: number, input: ZipLocalFileHeaderInput): number;
 export declare function buildLocalFileHeader(input: ZipLocalFileHeaderInput): Uint8Array;
 export interface ZipCentralDirectoryHeaderInput {
     fileName: Uint8Array;
@@ -32,6 +50,7 @@ export interface ZipCentralDirectoryHeaderInput {
     versionNeeded?: number;
     externalAttributes?: number;
 }
+export declare function writeCentralDirectoryHeaderInto(out: Uint8Array, view: DataView, offset: number, input: ZipCentralDirectoryHeaderInput): number;
 export declare function buildCentralDirectoryHeader(input: ZipCentralDirectoryHeaderInput): Uint8Array;
 export interface ZipEndOfCentralDirectoryInput {
     entryCount: number;
@@ -39,5 +58,6 @@ export interface ZipEndOfCentralDirectoryInput {
     centralDirOffset: number;
     comment: Uint8Array;
 }
+export declare function writeEndOfCentralDirectoryInto(out: Uint8Array, view: DataView, offset: number, input: ZipEndOfCentralDirectoryInput): number;
 export declare function buildEndOfCentralDirectory(input: ZipEndOfCentralDirectoryInput): Uint8Array;
 export declare function buildDataDescriptor(crc32: number, compressedSize: number, uncompressedSize: number): Uint8Array<ArrayBuffer>;

package/dist/types/modules/excel/stream/workbook-writer.browser.d.ts

@@ -7,7 +7,7 @@
  * Node.js uses `workbook-writer.ts`, which extends the same base implementation
  * with filesystem-specific features (filename output + image loading).
  */
-import { Zip } from "../../archive/streaming-zip.js";
+import { Zip } from "../../archive/zip/stream.js";
 import { StreamBuf } from "../utils/stream-buf.js";
 import { StylesXform } from "../xlsx/xform/style/styles-xform.js";
 import { SharedStrings } from "../utils/shared-strings.js";