@layerzerolabs/deterministic-zip 0.2.113 → 0.2.115

package/.turbo/turbo-build.log

@@ -10,6 +10,6 @@
 CLI Target: ES2023
 CLI Cleaning output folder
 ESM Build start
-ESM dist/index.js     2.09 KB
-ESM dist/index.js.map 5.65 KB
-ESM ⚡️ Build success in 90ms
+ESM dist/index.js     2.74 KB
+ESM dist/index.js.map 7.33 KB
+ESM ⚡️ Build success in 86ms

package/.turbo/turbo-lint.log

@@ -2,7 +2,7 @@
 > @layerzerolabs/deterministic-zip@0.0.0 lint /home/runner/work/monorepo-internal/monorepo-internal/tools/vm-utils/common/deterministic-zip
 > eslint . --max-warnings 0 || (eslint . --fix --max-warnings 0 && false)
 
-(node:89679) [MODULE_TYPELESS_PACKAGE_JSON] Warning: Module type of file:///home/runner/work/monorepo-internal/monorepo-internal/eslint.config.js?mtime=1783384524622 is not specified and it doesn't parse as CommonJS.
+(node:83928) [MODULE_TYPELESS_PACKAGE_JSON] Warning: Module type of file:///home/runner/work/monorepo-internal/monorepo-internal/eslint.config.js?mtime=1783546211968 is not specified and it doesn't parse as CommonJS.
 Reparsing as ES module because module syntax was detected. This incurs a performance overhead.
 To eliminate this warning, add "type": "module" to /home/runner/work/monorepo-internal/monorepo-internal/package.json.
 (Use `node --trace-warnings ...` to show where the warning was created)

package/.turbo/turbo-test.log

@@ -7,11 +7,11 @@ Breaking changes might not follow SemVer, please pin Vitest's version when using
 
  RUN  v3.2.6 /home/runner/work/monorepo-internal/monorepo-internal/tools/vm-utils/common/deterministic-zip
 
- ✓ tests/deterministicZip.test.ts (3 tests) 21ms
+ ✓ tests/deterministicZip.test.ts (8 tests) 30ms
 
  Test Files  1 passed (1)
-      Tests  3 passed (3)
+      Tests  8 passed (8)
 Type Errors  no errors
-   Start at  00:39:27
-   Duration  443ms (transform 106ms, setup 0ms, collect 75ms, tests 21ms, environment 0ms, prepare 155ms)
+   Start at  21:34:01
+   Duration  376ms (transform 67ms, setup 0ms, collect 66ms, tests 30ms, environment 0ms, prepare 107ms)
 

package/dist/index.d.ts

@@ -1,23 +1,41 @@
 /** fflate deflate compression levels (0 = store, 9 = max). */
 export type DeflateLevel = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+export declare enum ZipEntryType {
+    File = "file",
+    Directory = "directory"
+}
+export interface ZipEntryInfo {
+    /** POSIX-relative path from the zip root, no trailing slash. */
+    relPath: string;
+    type: ZipEntryType;
+}
+export type PathInclusionPredicate = (entry: ZipEntryInfo) => boolean;
 export interface ZipDirectoryOptions {
+    /** Deflate compression level passed to fflate. Defaults to `6`. */
     level?: DeflateLevel;
+    /** Modification time stamped onto every ZIP entry. */
     mtime?: Date;
+    /**
+     * Called for every file and directory. Return `false` to drop the entry;
+     * `false` on a directory prunes its entire subtree (children are never
+     * visited). Omitted = include everything.
+     *
+     * Symlinks are not supported and always throw.
+     */
+    pathInclusionPredicate?: PathInclusionPredicate;
 }
 /**
  * Fixed modification time stamped onto every archive entry.
  *
- * fflate derives each ZIP entry's DOS timestamp from the local-time components
- * of the supplied `mtime` (getFullYear/getMonth/getHours/...). Constructing the
- * date from local fields, rather than a UTC instant, makes those components
- * identical on every machine regardless of the builder's timezone.
+ * fflate writes ZIP timestamps from local date fields, so this value is built
+ * with local fields to keep the encoded timestamp stable across timezones.
  */
 export declare const DEFAULT_DETERMINISTIC_ZIP_MTIME: Date;
 /**
  * Build a byte-deterministic ZIP of `sourceDir`.
  *
- * Entry order, timestamps, and compression implementation are pinned so output
- * bytes remain stable across machines.
+ * Entry order and timestamps are normalized so equivalent directories produce
+ * stable archive bytes.
  */
 export declare const zipDirectoryToUint8Array: (sourceDir: string, options?: ZipDirectoryOptions) => Promise<Uint8Array>;
 export declare const zipDirectoryToBuffer: (sourceDir: string, options?: ZipDirectoryOptions) => Promise<Buffer>;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,8DAA8D;AAC9D,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAEjE,MAAM,WAAW,mBAAmB;IAChC,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,KAAK,CAAC,EAAE,IAAI,CAAC;CAChB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,+BAA+B,MAAiC,CAAC;AA+B9E;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,GACjC,WAAW,MAAM,EACjB,UAAU,mBAAmB,KAC9B,OAAO,CAAC,UAAU,CAepB,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC7B,WAAW,MAAM,EACjB,UAAU,mBAAmB,KAC9B,OAAO,CAAC,MAAM,CAAoE,CAAC;AAEtF,eAAO,MAAM,oBAAoB,GAC7B,WAAW,MAAM,EACjB,UAAU,mBAAmB,KAC9B,OAAO,CAAC,MAAM,CAAwE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,8DAA8D;AAC9D,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAEjE,oBAAY,YAAY;IACpB,IAAI,SAAS;IACb,SAAS,cAAc;CAC1B;AAED,MAAM,WAAW,YAAY;IACzB,gEAAgE;IAChE,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,YAAY,CAAC;CACtB;AAED,MAAM,MAAM,sBAAsB,GAAG,CAAC,KAAK,EAAE,YAAY,KAAK,OAAO,CAAC;AAEtE,MAAM,WAAW,mBAAmB;IAChC,mEAAmE;IACnE,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,sDAAsD;IACtD,KAAK,CAAC,EAAE,IAAI,CAAC;IACb;;;;;;OAMG;IACH,sBAAsB,CAAC,EAAE,sBAAsB,CAAC;CACnD;AAED;;;;;GAKG;AACH,eAAO,MAAM,+BAA+B,MAAiC,CAAC;AAyC9E;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,GACjC,WAAW,MAAM,EACjB,UAAU,mBAAmB,KAC9B,OAAO,CAAC,UAAU,CAiBpB,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC7B,WAAW,MAAM,EACjB,UAAU,mBAAmB,KAC9B,OAAO,CAAC,MAAM,CAAoE,CAAC;AAEtF,eAAO,MAAM,oBAAoB,GAC7B,WAAW,MAAM,EACjB,UAAU,mBAAmB,KAC9B,OAAO,CAAC,MAAM,CAAwE,CAAC"}

package/dist/index.js

@@ -4,8 +4,14 @@ import path from 'path';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var ZipEntryType = /* @__PURE__ */ (function(ZipEntryType2) {
+  ZipEntryType2["File"] = "file";
+  ZipEntryType2["Directory"] = "directory";
+  return ZipEntryType2;
+})({});
 var DEFAULT_DETERMINISTIC_ZIP_MTIME = new Date(2026, 5, 15, 0, 0, 0);
-var collectSortedEntries = /* @__PURE__ */ __name(async (root) => {
+var INCLUDE_EVERYTHING = /* @__PURE__ */ __name(() => true, "INCLUDE_EVERYTHING");
+var collectSortedEntries = /* @__PURE__ */ __name(async (root, includeEntry) => {
   const zipEntries = [];
   const walk = /* @__PURE__ */ __name(async (rel) => {
     const entries = await fs.readdir(path.join(root, rel), {
@@ -14,16 +20,26 @@ var collectSortedEntries = /* @__PURE__ */ __name(async (root) => {
     for (const entry of entries) {
       const childRel = rel ? path.posix.join(rel, entry.name) : entry.name;
       if (entry.isDirectory()) {
+        if (!includeEntry({
+          relPath: childRel,
+          type: "directory"
+        })) continue;
         zipEntries.push({
           relPath: `${childRel}/`,
           isDirectory: true
         });
         await walk(childRel);
       } else if (entry.isFile()) {
+        if (!includeEntry({
+          relPath: childRel,
+          type: "file"
+        })) continue;
         zipEntries.push({
           relPath: childRel,
           isDirectory: false
         });
+      } else if (entry.isSymbolicLink()) {
+        throw new Error(`symlink entries are not supported: ${childRel}`);
       }
     }
   }, "walk");
@@ -31,7 +47,7 @@ var collectSortedEntries = /* @__PURE__ */ __name(async (root) => {
   return zipEntries.sort((a, b) => a.relPath < b.relPath ? -1 : a.relPath > b.relPath ? 1 : 0);
 }, "collectSortedEntries");
 var zipDirectoryToUint8Array = /* @__PURE__ */ __name(async (sourceDir, options) => {
-  const entries = await collectSortedEntries(sourceDir);
+  const entries = await collectSortedEntries(sourceDir, options?.pathInclusionPredicate ?? INCLUDE_EVERYTHING);
   const fileMap = {};
   for (const entry of entries) {
     fileMap[entry.relPath] = entry.isDirectory ? new Uint8Array(0) : new Uint8Array(await fs.readFile(path.join(sourceDir, entry.relPath)));
@@ -44,6 +60,6 @@ var zipDirectoryToUint8Array = /* @__PURE__ */ __name(async (sourceDir, options)
 var zipDirectoryToBuffer = /* @__PURE__ */ __name(async (sourceDir, options) => Buffer.from(await zipDirectoryToUint8Array(sourceDir, options)), "zipDirectoryToBuffer");
 var zipDirectoryToBase64 = /* @__PURE__ */ __name(async (sourceDir, options) => (await zipDirectoryToBuffer(sourceDir, options)).toString("base64"), "zipDirectoryToBase64");
 
-export { DEFAULT_DETERMINISTIC_ZIP_MTIME, zipDirectoryToBase64, zipDirectoryToBuffer, zipDirectoryToUint8Array };
+export { DEFAULT_DETERMINISTIC_ZIP_MTIME, ZipEntryType, zipDirectoryToBase64, zipDirectoryToBuffer, zipDirectoryToUint8Array };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"names":["DEFAULT_DETERMINISTIC_ZIP_MTIME","Date","collectSortedEntries","root","zipEntries","walk","rel","entries","fs","readdir","path","join","withFileTypes","entry","childRel","posix","name","isDirectory","push","relPath","isFile","sort","a","b","zipDirectoryToUint8Array","sourceDir","options","fileMap","Uint8Array","readFile","zipSync","level","mtime","zipDirectoryToBuffer","Buffer","from","zipDirectoryToBase64","toString"],"mappings":";;;;;;AAoBO,IAAMA,+BAAAA,GAAkC,IAAIC,IAAAA,CAAK,IAAA,EAAM,GAAG,EAAA,EAAI,CAAA,EAAG,GAAG,CAAA;AAW3E,IAAMC,oBAAAA,iCAA8BC,IAAAA,KAAAA;AAChC,EAAA,MAAMC,aAAsC,EAAA;AAE5C,EAAA,MAAMC,IAAAA,iCAAcC,GAAAA,KAAAA;AAChB,IAAA,MAAMC,OAAAA,GAAU,MAAMC,EAAAA,CAAGC,OAAAA,CAAQC,KAAKC,IAAAA,CAAKR,IAAAA,EAAMG,GAAAA,CAAAA,EAAM;MAAEM,aAAAA,EAAe;KAAK,CAAA;AAC7E,IAAA,KAAA,MAAWC,SAASN,OAAAA,EAAS;AACzB,MAAA,MAAMO,QAAAA,GAAWR,MAAMI,IAAAA,CAAKK,KAAAA,CAAMJ,KAAKL,GAAAA,EAAKO,KAAAA,CAAMG,IAAI,CAAA,GAAIH,KAAAA,CAAMG,IAAAA;AAChE,MAAA,IAAIH,KAAAA,CAAMI,aAAW,EAAI;AACrBb,QAAAA,UAAAA,CAAWc,IAAAA,CAAK;AAAEC,UAAAA,OAAAA,EAAS,GAAGL,QAAAA,CAAAA,CAAAA,CAAAA;UAAaG,WAAAA,EAAa;SAAK,CAAA;AAC7D,QAAA,MAAMZ,KAAKS,QAAAA,CAAAA;MACf,CAAA,MAAA,IAAWD,KAAAA,CAAMO,QAAM,EAAI;AACvBhB,QAAAA,UAAAA,CAAWc,IAAAA,CAAK;UAAEC,OAAAA,EAASL,QAAAA;UAAUG,WAAAA,EAAa;SAAM,CAAA;AAC5D,MAAA;AACJ,IAAA;EACJ,CAAA,EAXa,MAAA,CAAA;AAab,EAAA,MAAMZ,KAAK,EAAA,CAAA;AACX,EAAA,OAAOD,UAAAA,CAAWiB,IAAAA,CAAK,CAACC,CAAAA,EAAGC,MAAOD,CAAAA,CAAEH,OAAAA,GAAUI,CAAAA,CAAEJ,OAAAA,GAAU,KAAKG,CAAAA,CAAEH,OAAAA,GAAUI,CAAAA,CAAEJ,OAAAA,GAAU,IAAI,CAAA,CAAA;AAC/F,CAAA,EAlB6B,sBAAA,CAAA;AA0BtB,IAAMK,wBAAAA,mBAA2B,MAAA,CAAA,OACpCC,SAAAA,EACAC,OAAAA,KAAAA;AAEA,EAAA,MAAMnB,OAAAA,GAAU,MAAML,oBAAAA,CAAqBuB,SAAAA,CAAAA;AAC3C,EAAA,MAAME,UAAoB,EAAC;AAE3B,EAAA,KAAA,MAAWd,SAASN,OAAAA,EAAS;AAEzBoB,IAAAA,OAAAA,CAAQd,KAAAA,CAAMM,OAAO,CAAA,GAAIN,KAAAA,CAAMI,cACzB,IAAIW,UAAAA,CAAW,CAAA,CAAA,GACf,IAAIA,WAAW,MAAMpB,EAAAA,CAAGqB,SAASnB,IAAAA,CAAKC,IAAAA,CAAKc,WAAWZ,KAAAA,CAAMM,OAAO,CAAA,CAAA,CAAA;AAC7E,EAAA;AAEA,EAAA,OAAOW,QAAQH,OAAAA,EAAS;AACpBI,IAAAA,KAAAA,EAAOL,SAASK,KAAAA,IAAS,CAAA;AACzBC,IAAAA,KAAAA,EAAON,SAASM,KAAAA,IAAShC;GAC7B,CAAA;AACJ,CAAA,EAlBwC,0BAAA;AAoBjC,IAAMiC,oBAAAA,mBAAuB,MAAA,CAAA,OAChCR,SAAAA,EACAC,OAAAA,KACkBQ,MAAAA,CAAOC,IAAAA,CAAK,MAAMX,wBAAAA,CAAyBC,SAAAA,EAAWC,OAAAA,CAAAA,CAAAA,EAHxC,sBAAA;AAK7B,IAAMU,oBAAAA,mBAAuB,MAAA,CAAA,OAChCX,SAAAA,EACAC,OAAAA,KAAAA,CACmB,MAAMO,oBAAAA,CAAqBR,SAAAA,EAAWC,OAAAA,CAAAA,EAAUW,QAAAA,CAAS,QAAA,CAAA,EAH5C,sBAAA","file":"index.js","sourcesContent":["import { type Zippable, zipSync } from 'fflate';\nimport fs from 'node:fs/promises';\nimport path from 'node:path';\n\n/** fflate deflate compression levels (0 = store, 9 = max). */\nexport type DeflateLevel = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;\n\nexport interface ZipDirectoryOptions {\n    level?: DeflateLevel;\n    mtime?: Date;\n}\n\n/**\n * Fixed modification time stamped onto every archive entry.\n *\n * fflate derives each ZIP entry's DOS timestamp from the local-time components\n * of the supplied `mtime` (getFullYear/getMonth/getHours/...). Constructing the\n * date from local fields, rather than a UTC instant, makes those components\n * identical on every machine regardless of the builder's timezone.\n */\nexport const DEFAULT_DETERMINISTIC_ZIP_MTIME = new Date(2026, 5, 15, 0, 0, 0);\n\ntype DeterministicZipEntry = { relPath: string; isDirectory: boolean };\n\n/**\n * Recursively collect every file and directory under `root`, sorted by\n * POSIX-relative path (UTF-16 code unit order).\n *\n * The explicit sort is required for reproducibility because filesystem\n * `readdir` order is not stable across operating systems.\n */\nconst collectSortedEntries = async (root: string): Promise<DeterministicZipEntry[]> => {\n    const zipEntries: DeterministicZipEntry[] = [];\n\n    const walk = async (rel: string): Promise<void> => {\n        const entries = await fs.readdir(path.join(root, rel), { withFileTypes: true });\n        for (const entry of entries) {\n            const childRel = rel ? path.posix.join(rel, entry.name) : entry.name;\n            if (entry.isDirectory()) {\n                zipEntries.push({ relPath: `${childRel}/`, isDirectory: true });\n                await walk(childRel);\n            } else if (entry.isFile()) {\n                zipEntries.push({ relPath: childRel, isDirectory: false });\n            }\n        }\n    };\n\n    await walk('');\n    return zipEntries.sort((a, b) => (a.relPath < b.relPath ? -1 : a.relPath > b.relPath ? 1 : 0));\n};\n\n/**\n * Build a byte-deterministic ZIP of `sourceDir`.\n *\n * Entry order, timestamps, and compression implementation are pinned so output\n * bytes remain stable across machines.\n */\nexport const zipDirectoryToUint8Array = async (\n    sourceDir: string,\n    options?: ZipDirectoryOptions,\n): Promise<Uint8Array> => {\n    const entries = await collectSortedEntries(sourceDir);\n    const fileMap: Zippable = {};\n\n    for (const entry of entries) {\n        // A directory is a zero-length entry whose name already ends in `/`.\n        fileMap[entry.relPath] = entry.isDirectory\n            ? new Uint8Array(0)\n            : new Uint8Array(await fs.readFile(path.join(sourceDir, entry.relPath)));\n    }\n\n    return zipSync(fileMap, {\n        level: options?.level ?? 6,\n        mtime: options?.mtime ?? DEFAULT_DETERMINISTIC_ZIP_MTIME,\n    });\n};\n\nexport const zipDirectoryToBuffer = async (\n    sourceDir: string,\n    options?: ZipDirectoryOptions,\n): Promise<Buffer> => Buffer.from(await zipDirectoryToUint8Array(sourceDir, options));\n\nexport const zipDirectoryToBase64 = async (\n    sourceDir: string,\n    options?: ZipDirectoryOptions,\n): Promise<string> => (await zipDirectoryToBuffer(sourceDir, options)).toString('base64');\n"]}
+{"version":3,"sources":["../src/index.ts"],"names":["ZipEntryType","DEFAULT_DETERMINISTIC_ZIP_MTIME","Date","INCLUDE_EVERYTHING","collectSortedEntries","root","includeEntry","zipEntries","walk","rel","entries","fs","readdir","path","join","withFileTypes","entry","childRel","posix","name","isDirectory","relPath","type","push","isFile","isSymbolicLink","Error","sort","a","b","zipDirectoryToUint8Array","sourceDir","options","pathInclusionPredicate","fileMap","Uint8Array","readFile","zipSync","level","mtime","zipDirectoryToBuffer","Buffer","from","zipDirectoryToBase64","toString"],"mappings":"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","file":"index.js","sourcesContent":["import { type Zippable, zipSync } from 'fflate';\nimport fs from 'node:fs/promises';\nimport path from 'node:path';\n\n/** fflate deflate compression levels (0 = store, 9 = max). */\nexport type DeflateLevel = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;\n\nexport enum ZipEntryType {\n    File = 'file',\n    Directory = 'directory',\n}\n\nexport interface ZipEntryInfo {\n    /** POSIX-relative path from the zip root, no trailing slash. */\n    relPath: string;\n    type: ZipEntryType;\n}\n\nexport type PathInclusionPredicate = (entry: ZipEntryInfo) => boolean;\n\nexport interface ZipDirectoryOptions {\n    /** Deflate compression level passed to fflate. Defaults to `6`. */\n    level?: DeflateLevel;\n    /** Modification time stamped onto every ZIP entry. */\n    mtime?: Date;\n    /**\n     * Called for every file and directory. Return `false` to drop the entry;\n     * `false` on a directory prunes its entire subtree (children are never\n     * visited). Omitted = include everything.\n     *\n     * Symlinks are not supported and always throw.\n     */\n    pathInclusionPredicate?: PathInclusionPredicate;\n}\n\n/**\n * Fixed modification time stamped onto every archive entry.\n *\n * fflate writes ZIP timestamps from local date fields, so this value is built\n * with local fields to keep the encoded timestamp stable across timezones.\n */\nexport const DEFAULT_DETERMINISTIC_ZIP_MTIME = new Date(2026, 5, 15, 0, 0, 0);\n\nconst INCLUDE_EVERYTHING: PathInclusionPredicate = () => true;\n\ntype DeterministicZipEntry = { relPath: string; isDirectory: boolean };\n\n/**\n * Recursively collect every included file and directory under `root`, sorted\n * by POSIX-relative path (UTF-16 code unit order).\n *\n * Filesystem `readdir` order varies by platform, so sorting is required for\n * reproducible archives.\n */\nconst collectSortedEntries = async (\n    root: string,\n    includeEntry: PathInclusionPredicate,\n): Promise<DeterministicZipEntry[]> => {\n    const zipEntries: DeterministicZipEntry[] = [];\n\n    const walk = async (rel: string): Promise<void> => {\n        const entries = await fs.readdir(path.join(root, rel), { withFileTypes: true });\n        for (const entry of entries) {\n            const childRel = rel ? path.posix.join(rel, entry.name) : entry.name;\n            if (entry.isDirectory()) {\n                if (!includeEntry({ relPath: childRel, type: ZipEntryType.Directory })) continue;\n                // fflate treats trailing-slash zero-length entries as directories.\n                zipEntries.push({ relPath: `${childRel}/`, isDirectory: true });\n                await walk(childRel);\n            } else if (entry.isFile()) {\n                if (!includeEntry({ relPath: childRel, type: ZipEntryType.File })) continue;\n                zipEntries.push({ relPath: childRel, isDirectory: false });\n            } else if (entry.isSymbolicLink()) {\n                throw new Error(`symlink entries are not supported: ${childRel}`);\n            }\n        }\n    };\n\n    await walk('');\n    return zipEntries.sort((a, b) => (a.relPath < b.relPath ? -1 : a.relPath > b.relPath ? 1 : 0));\n};\n\n/**\n * Build a byte-deterministic ZIP of `sourceDir`.\n *\n * Entry order and timestamps are normalized so equivalent directories produce\n * stable archive bytes.\n */\nexport const zipDirectoryToUint8Array = async (\n    sourceDir: string,\n    options?: ZipDirectoryOptions,\n): Promise<Uint8Array> => {\n    const entries = await collectSortedEntries(\n        sourceDir,\n        options?.pathInclusionPredicate ?? INCLUDE_EVERYTHING,\n    );\n    const fileMap: Zippable = {};\n\n    for (const entry of entries) {\n        fileMap[entry.relPath] = entry.isDirectory\n            ? new Uint8Array(0)\n            : new Uint8Array(await fs.readFile(path.join(sourceDir, entry.relPath)));\n    }\n\n    return zipSync(fileMap, {\n        level: options?.level ?? 6,\n        mtime: options?.mtime ?? DEFAULT_DETERMINISTIC_ZIP_MTIME,\n    });\n};\n\nexport const zipDirectoryToBuffer = async (\n    sourceDir: string,\n    options?: ZipDirectoryOptions,\n): Promise<Buffer> => Buffer.from(await zipDirectoryToUint8Array(sourceDir, options));\n\nexport const zipDirectoryToBase64 = async (\n    sourceDir: string,\n    options?: ZipDirectoryOptions,\n): Promise<string> => (await zipDirectoryToBuffer(sourceDir, options)).toString('base64');\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/deterministic-zip",
-  "version": "0.2.113",
+  "version": "0.2.115",
   "private": false,
   "license": "MIT",
   "type": "module",
@@ -18,8 +18,8 @@
   "devDependencies": {
     "tsup": "^8.4.0",
     "vitest": "^3.2.6",
-    "@layerzerolabs/tsup-configuration": "0.2.113",
-    "@layerzerolabs/typescript-configuration": "0.2.113"
+    "@layerzerolabs/tsup-configuration": "0.2.115",
+    "@layerzerolabs/typescript-configuration": "0.2.115"
   },
   "publishConfig": {
     "access": "restricted",

package/src/index.ts

@@ -5,31 +5,57 @@ import path from 'node:path';
 /** fflate deflate compression levels (0 = store, 9 = max). */
 export type DeflateLevel = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
 
+export enum ZipEntryType {
+    File = 'file',
+    Directory = 'directory',
+}
+
+export interface ZipEntryInfo {
+    /** POSIX-relative path from the zip root, no trailing slash. */
+    relPath: string;
+    type: ZipEntryType;
+}
+
+export type PathInclusionPredicate = (entry: ZipEntryInfo) => boolean;
+
 export interface ZipDirectoryOptions {
+    /** Deflate compression level passed to fflate. Defaults to `6`. */
     level?: DeflateLevel;
+    /** Modification time stamped onto every ZIP entry. */
     mtime?: Date;
+    /**
+     * Called for every file and directory. Return `false` to drop the entry;
+     * `false` on a directory prunes its entire subtree (children are never
+     * visited). Omitted = include everything.
+     *
+     * Symlinks are not supported and always throw.
+     */
+    pathInclusionPredicate?: PathInclusionPredicate;
 }
 
 /**
  * Fixed modification time stamped onto every archive entry.
  *
- * fflate derives each ZIP entry's DOS timestamp from the local-time components
- * of the supplied `mtime` (getFullYear/getMonth/getHours/...). Constructing the
- * date from local fields, rather than a UTC instant, makes those components
- * identical on every machine regardless of the builder's timezone.
+ * fflate writes ZIP timestamps from local date fields, so this value is built
+ * with local fields to keep the encoded timestamp stable across timezones.
  */
 export const DEFAULT_DETERMINISTIC_ZIP_MTIME = new Date(2026, 5, 15, 0, 0, 0);
 
+const INCLUDE_EVERYTHING: PathInclusionPredicate = () => true;
+
 type DeterministicZipEntry = { relPath: string; isDirectory: boolean };
 
 /**
- * Recursively collect every file and directory under `root`, sorted by
- * POSIX-relative path (UTF-16 code unit order).
+ * Recursively collect every included file and directory under `root`, sorted
+ * by POSIX-relative path (UTF-16 code unit order).
  *
- * The explicit sort is required for reproducibility because filesystem
- * `readdir` order is not stable across operating systems.
+ * Filesystem `readdir` order varies by platform, so sorting is required for
+ * reproducible archives.
  */
-const collectSortedEntries = async (root: string): Promise<DeterministicZipEntry[]> => {
+const collectSortedEntries = async (
+    root: string,
+    includeEntry: PathInclusionPredicate,
+): Promise<DeterministicZipEntry[]> => {
     const zipEntries: DeterministicZipEntry[] = [];
 
     const walk = async (rel: string): Promise<void> => {
@@ -37,10 +63,15 @@ const collectSortedEntries = async (root: string): Promise<DeterministicZipEntry
         for (const entry of entries) {
             const childRel = rel ? path.posix.join(rel, entry.name) : entry.name;
             if (entry.isDirectory()) {
+                if (!includeEntry({ relPath: childRel, type: ZipEntryType.Directory })) continue;
+                // fflate treats trailing-slash zero-length entries as directories.
                 zipEntries.push({ relPath: `${childRel}/`, isDirectory: true });
                 await walk(childRel);
             } else if (entry.isFile()) {
+                if (!includeEntry({ relPath: childRel, type: ZipEntryType.File })) continue;
                 zipEntries.push({ relPath: childRel, isDirectory: false });
+            } else if (entry.isSymbolicLink()) {
+                throw new Error(`symlink entries are not supported: ${childRel}`);
             }
         }
     };
@@ -52,18 +83,20 @@ const collectSortedEntries = async (root: string): Promise<DeterministicZipEntry
 /**
  * Build a byte-deterministic ZIP of `sourceDir`.
  *
- * Entry order, timestamps, and compression implementation are pinned so output
- * bytes remain stable across machines.
+ * Entry order and timestamps are normalized so equivalent directories produce
+ * stable archive bytes.
  */
 export const zipDirectoryToUint8Array = async (
     sourceDir: string,
     options?: ZipDirectoryOptions,
 ): Promise<Uint8Array> => {
-    const entries = await collectSortedEntries(sourceDir);
+    const entries = await collectSortedEntries(
+        sourceDir,
+        options?.pathInclusionPredicate ?? INCLUDE_EVERYTHING,
+    );
     const fileMap: Zippable = {};
 
     for (const entry of entries) {
-        // A directory is a zero-length entry whose name already ends in `/`.
         fileMap[entry.relPath] = entry.isDirectory
             ? new Uint8Array(0)
             : new Uint8Array(await fs.readFile(path.join(sourceDir, entry.relPath)));

package/tests/deterministicZip.test.ts

@@ -4,7 +4,12 @@ import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { afterEach, describe, expect, it } from 'vitest';
 
-import { zipDirectoryToBase64, zipDirectoryToUint8Array } from '../src';
+import {
+    zipDirectoryToBase64,
+    zipDirectoryToUint8Array,
+    type ZipEntryInfo,
+    ZipEntryType,
+} from '../src';
 
 const testDirs: string[] = [];
 
@@ -56,4 +61,88 @@ describe('deterministic zip', () => {
 
         expect(Object.keys(unzipped)).toEqual(['empty/']);
     });
+
+    describe('pathInclusionPredicate', () => {
+        it('includes everything when no predicate is given', async () => {
+            const dir = await createTempDir();
+            await fs.writeFile(path.join(dir, '.env'), 'SECRET=1');
+            await fs.writeFile(path.join(dir, 'id_rsa'), 'key');
+
+            const unzipped = unzipSync(await zipDirectoryToUint8Array(dir));
+
+            expect(Object.keys(unzipped)).toEqual(['.env', 'id_rsa']);
+        });
+
+        it('filters files through the predicate while directories remain', async () => {
+            const dir = await createTempDir();
+            await fs.mkdir(path.join(dir, 'sources'), { recursive: true });
+            await fs.writeFile(path.join(dir, 'sources', 'module.move'), 'module a::m {}');
+            await fs.writeFile(path.join(dir, 'sources', '.env'), 'SECRET=1');
+            await fs.writeFile(path.join(dir, 'Move.toml'), '[package]\n');
+            await fs.writeFile(path.join(dir, 'notes.txt'), 'n');
+
+            const unzipped = unzipSync(
+                await zipDirectoryToUint8Array(dir, {
+                    pathInclusionPredicate: ({ relPath, type }) =>
+                        type === ZipEntryType.Directory ||
+                        (type === ZipEntryType.File &&
+                            /(^|\/)Move\.(toml|lock)$|\.move$/.test(relPath)),
+                }),
+            );
+
+            expect(Object.keys(unzipped)).toEqual(['Move.toml', 'sources/', 'sources/module.move']);
+        });
+
+        it('prunes an excluded directory subtree without visiting its children', async () => {
+            const dir = await createTempDir();
+            await fs.mkdir(path.join(dir, 'tests', 'nested'), { recursive: true });
+            await fs.writeFile(path.join(dir, 'tests', 't.move'), 'x');
+            await fs.writeFile(path.join(dir, 'tests', 'nested', 'u.move'), 'y');
+            await fs.writeFile(path.join(dir, 'keep.move'), 'k');
+
+            const seen: string[] = [];
+            const unzipped = unzipSync(
+                await zipDirectoryToUint8Array(dir, {
+                    pathInclusionPredicate: (entry) => {
+                        seen.push(entry.relPath);
+                        return entry.relPath !== 'tests';
+                    },
+                }),
+            );
+
+            expect(Object.keys(unzipped)).toEqual(['keep.move']);
+            // Children of the pruned directory are never offered to the predicate.
+            expect([...seen].sort()).toEqual(['keep.move', 'tests']);
+        });
+
+        it('passes a POSIX relPath without trailing slash and the entry type', async () => {
+            const dir = await createTempDir();
+            await fs.mkdir(path.join(dir, 'a'), { recursive: true });
+            await fs.writeFile(path.join(dir, 'a', 'b.txt'), 'b');
+
+            const seen: ZipEntryInfo[] = [];
+            await zipDirectoryToUint8Array(dir, {
+                pathInclusionPredicate: (entry) => {
+                    seen.push(entry);
+                    return true;
+                },
+            });
+
+            expect(seen).toEqual([
+                { relPath: 'a', type: ZipEntryType.Directory },
+                { relPath: 'a/b.txt', type: ZipEntryType.File },
+            ]);
+        });
+    });
+
+    describe('symlinks', () => {
+        it('throws when a symlink is encountered', async () => {
+            const dir = await createTempDir();
+            await fs.symlink('missing-target', path.join(dir, 'link.txt'));
+
+            await expect(zipDirectoryToUint8Array(dir)).rejects.toThrow(
+                'symlink entries are not supported: link.txt',
+            );
+        });
+    });
 });