@layerzerolabs/deterministic-zip 0.2.108

package/.turbo/turbo-build.log

@@ -0,0 +1,15 @@
+ WARN  Issue while reading "/home/runner/work/monorepo-internal/monorepo-internal/.npmrc". Failed to replace env in config: ${NPM_TOKEN}
+
+> @layerzerolabs/deterministic-zip@0.0.0 build /home/runner/work/monorepo-internal/monorepo-internal/tools/vm-utils/common/deterministic-zip
+> tsup
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Using tsup config: /home/runner/work/monorepo-internal/monorepo-internal/tools/vm-utils/common/deterministic-zip/tsup.config.ts
+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 99ms

package/.turbo/turbo-lint.log

@@ -0,0 +1,8 @@
+
+> @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:83387) [MODULE_TYPELESS_PACKAGE_JSON] Warning: Module type of file:///home/runner/work/monorepo-internal/monorepo-internal/eslint.config.js?mtime=1782249605033 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

@@ -0,0 +1,17 @@
+
+> @layerzerolabs/deterministic-zip@0.0.0 test /home/runner/work/monorepo-internal/monorepo-internal/tools/vm-utils/common/deterministic-zip
+> vitest --run --pass-with-no-tests --typecheck
+
+Testing types with tsc and vue-tsc is an experimental feature.
+Breaking changes might not follow SemVer, please pin Vitest's version when using it.
+
+ RUN  v3.2.4 /home/runner/work/monorepo-internal/monorepo-internal/tools/vm-utils/common/deterministic-zip
+
+ ✓ tests/deterministicZip.test.ts (3 tests) 23ms
+
+ Test Files  1 passed (1)
+      Tests  3 passed (3)
+Type Errors  no errors
+   Start at  21:23:46
+   Duration  443ms (transform 58ms, setup 0ms, collect 62ms, tests 23ms, environment 0ms, prepare 110ms)
+

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+/** fflate deflate compression levels (0 = store, 9 = max). */
+export type DeflateLevel = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+export interface ZipDirectoryOptions {
+    level?: DeflateLevel;
+    mtime?: Date;
+}
+/**
+ * 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.
+ */
+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.
+ */
+export declare const zipDirectoryToUint8Array: (sourceDir: string, options?: ZipDirectoryOptions) => Promise<Uint8Array>;
+export declare const zipDirectoryToBuffer: (sourceDir: string, options?: ZipDirectoryOptions) => Promise<Buffer>;
+export declare const zipDirectoryToBase64: (sourceDir: string, options?: ZipDirectoryOptions) => Promise<string>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +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"}

package/dist/index.js

@@ -0,0 +1,49 @@
+import { zipSync } from 'fflate';
+import fs from 'fs/promises';
+import path from 'path';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var DEFAULT_DETERMINISTIC_ZIP_MTIME = new Date(2026, 5, 15, 0, 0, 0);
+var collectSortedEntries = /* @__PURE__ */ __name(async (root) => {
+  const zipEntries = [];
+  const walk = /* @__PURE__ */ __name(async (rel) => {
+    const entries = await fs.readdir(path.join(root, rel), {
+      withFileTypes: true
+    });
+    for (const entry of entries) {
+      const childRel = rel ? path.posix.join(rel, entry.name) : entry.name;
+      if (entry.isDirectory()) {
+        zipEntries.push({
+          relPath: `${childRel}/`,
+          isDirectory: true
+        });
+        await walk(childRel);
+      } else if (entry.isFile()) {
+        zipEntries.push({
+          relPath: childRel,
+          isDirectory: false
+        });
+      }
+    }
+  }, "walk");
+  await walk("");
+  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 fileMap = {};
+  for (const entry of entries) {
+    fileMap[entry.relPath] = entry.isDirectory ? new Uint8Array(0) : new Uint8Array(await fs.readFile(path.join(sourceDir, entry.relPath)));
+  }
+  return zipSync(fileMap, {
+    level: options?.level ?? 6,
+    mtime: options?.mtime ?? DEFAULT_DETERMINISTIC_ZIP_MTIME
+  });
+}, "zipDirectoryToUint8Array");
+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 };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +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"]}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@layerzerolabs/deterministic-zip",
+  "version": "0.2.108",
+  "private": false,
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    "types": "./dist/index.d.ts",
+    "import": "./dist/index.js",
+    "default": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "dependencies": {
+    "fflate": "^0.8.3"
+  },
+  "devDependencies": {
+    "tsup": "^8.4.0",
+    "vitest": "^3.2.4",
+    "@layerzerolabs/tsup-configuration": "0.2.108",
+    "@layerzerolabs/typescript-configuration": "0.2.108"
+  },
+  "publishConfig": {
+    "access": "restricted",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsup",
+    "lint": "eslint . --max-warnings 0 || (eslint . --fix --max-warnings 0 && false)",
+    "test": "vitest --run --pass-with-no-tests --typecheck"
+  }
+}

package/src/index.ts

@@ -0,0 +1,86 @@
+import { type Zippable, zipSync } from 'fflate';
+import fs from 'node:fs/promises';
+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 interface ZipDirectoryOptions {
+    level?: DeflateLevel;
+    mtime?: Date;
+}
+
+/**
+ * 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.
+ */
+export const DEFAULT_DETERMINISTIC_ZIP_MTIME = new Date(2026, 5, 15, 0, 0, 0);
+
+type DeterministicZipEntry = { relPath: string; isDirectory: boolean };
+
+/**
+ * Recursively collect every 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.
+ */
+const collectSortedEntries = async (root: string): Promise<DeterministicZipEntry[]> => {
+    const zipEntries: DeterministicZipEntry[] = [];
+
+    const walk = async (rel: string): Promise<void> => {
+        const entries = await fs.readdir(path.join(root, rel), { withFileTypes: true });
+        for (const entry of entries) {
+            const childRel = rel ? path.posix.join(rel, entry.name) : entry.name;
+            if (entry.isDirectory()) {
+                zipEntries.push({ relPath: `${childRel}/`, isDirectory: true });
+                await walk(childRel);
+            } else if (entry.isFile()) {
+                zipEntries.push({ relPath: childRel, isDirectory: false });
+            }
+        }
+    };
+
+    await walk('');
+    return zipEntries.sort((a, b) => (a.relPath < b.relPath ? -1 : a.relPath > b.relPath ? 1 : 0));
+};
+
+/**
+ * Build a byte-deterministic ZIP of `sourceDir`.
+ *
+ * Entry order, timestamps, and compression implementation are pinned so output
+ * bytes remain stable across machines.
+ */
+export const zipDirectoryToUint8Array = async (
+    sourceDir: string,
+    options?: ZipDirectoryOptions,
+): Promise<Uint8Array> => {
+    const entries = await collectSortedEntries(sourceDir);
+    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)));
+    }
+
+    return zipSync(fileMap, {
+        level: options?.level ?? 6,
+        mtime: options?.mtime ?? DEFAULT_DETERMINISTIC_ZIP_MTIME,
+    });
+};
+
+export const zipDirectoryToBuffer = async (
+    sourceDir: string,
+    options?: ZipDirectoryOptions,
+): Promise<Buffer> => Buffer.from(await zipDirectoryToUint8Array(sourceDir, options));
+
+export const zipDirectoryToBase64 = async (
+    sourceDir: string,
+    options?: ZipDirectoryOptions,
+): Promise<string> => (await zipDirectoryToBuffer(sourceDir, options)).toString('base64');

package/tests/deterministicZip.test.ts

@@ -0,0 +1,59 @@
+import { unzipSync } from 'fflate';
+import fs from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { zipDirectoryToBase64, zipDirectoryToUint8Array } from '../src';
+
+const testDirs: string[] = [];
+
+const createTempDir = async () => {
+    const dir = await fs.mkdtemp(path.join(tmpdir(), 'deterministic-zip-'));
+    testDirs.push(dir);
+    return dir;
+};
+
+afterEach(async () => {
+    await Promise.all(
+        testDirs.splice(0).map((dir) => fs.rm(dir, { recursive: true, force: true })),
+    );
+});
+
+describe('deterministic zip', () => {
+    it('sorts entries and keeps empty directories', async () => {
+        const dir = await createTempDir();
+        await fs.mkdir(path.join(dir, 'z-empty'), { recursive: true });
+        await fs.mkdir(path.join(dir, 'a'), { recursive: true });
+        await fs.writeFile(path.join(dir, 'b.txt'), 'b');
+        await fs.writeFile(path.join(dir, 'a', 'c.txt'), 'c');
+
+        const unzipped = unzipSync(await zipDirectoryToUint8Array(dir));
+
+        expect(Object.keys(unzipped)).toEqual(['a/', 'a/c.txt', 'b.txt', 'z-empty/']);
+    });
+
+    it('produces stable bytes for equivalent directories', async () => {
+        const first = await createTempDir();
+        const second = await createTempDir();
+
+        await fs.mkdir(path.join(first, 'sources'), { recursive: true });
+        await fs.writeFile(path.join(first, 'sources', 'module.move'), 'module first::m {}');
+        await fs.writeFile(path.join(first, 'Move.toml'), '[package]\nname = "first"\n');
+
+        await fs.writeFile(path.join(second, 'Move.toml'), '[package]\nname = "first"\n');
+        await fs.mkdir(path.join(second, 'sources'), { recursive: true });
+        await fs.writeFile(path.join(second, 'sources', 'module.move'), 'module first::m {}');
+
+        expect(await zipDirectoryToBase64(first)).toEqual(await zipDirectoryToBase64(second));
+    });
+
+    it('writes directory entries into the zip', async () => {
+        const dir = await createTempDir();
+        await fs.mkdir(path.join(dir, 'empty'), { recursive: true });
+
+        const unzipped = unzipSync(await zipDirectoryToUint8Array(dir));
+
+        expect(Object.keys(unzipped)).toEqual(['empty/']);
+    });
+});

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+    "extends": "@layerzerolabs/typescript-configuration/tsconfig.base.json",
+    "compilerOptions": {
+        "rootDir": "./src",
+        "outDir": "./dist",
+        "lib": ["ESNext"],
+        "strictPropertyInitialization": false,
+        "noUnusedLocals": false,
+        "noUnusedParameters": false,
+        "jsx": "react-jsx"
+    },
+    "exclude": [
+        "node_modules",
+        "**/__mocks__/*",
+        "**/__tests__/*",
+        "**/*.spec.ts",
+        "**/*.test.ts",
+        "dist"
+    ],
+    "include": ["src/**/*"]
+}

package/tsup.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'tsup';
+
+import { createPackageTsupConfig } from '@layerzerolabs/tsup-configuration';
+
+export default defineConfig(({ watch }) => ({
+    ...createPackageTsupConfig(),
+    clean: !watch,
+}));