The no-bundler build tool for TypeScript libraries. Powered by tsc.\n \n by @colinhacks\n
\n\n \n\n
\n\n\n\n
\n\n \n \n \n\n\n\n
What is zshy?
\n\n`zshy` (zee-shy) is a bundler-free batteries-included build tool for transpiling TypeScript libraries. It was originally created as an internal build tool for [Zod](https://github.com/colinhacks/zod) but is now available as a general-purpose tool for TypeScript libraries.\n\n- π **Powered by `tsc`** β The gold standard for TypeScript transpilation\n- π¦ **Bundler-free** β No bundler or bundler configs involved\n- π¦ **No config file** β Reads from your `package.json` and `tsconfig.json`\n- π **Declarative entrypoint map** β Specify your TypeScript entrypoints in `package.json#/zshy`\n- π€ **Auto-generated `\"exports\"`** β Writes `\"exports\"` map directly into your `package.json` and `jsr.json`\n- 𧱠**Dual-module builds** β Builds ESM and CJS outputs from a single TypeScript source file\n- π **Unopinionated** β Use any file structure or import extension syntax you like\n- π¦ **Asset handling** β Non-JS assets are copied to the output directory\n- βοΈ **Supports `.tsx`** β Rewrites to `.js/.cjs/.mjs` per your `tsconfig.json#/jsx*` settings\n- π **CLI-friendly** β First-class `\"bin\"` support\n- π **Blazing fast** β Just kidding, it's slow. But [it's worth it](#is-it-fast)\n\n\n\n \n \n \n\n
Quickstart
\n\n \n\n### 1. Install `zshy` as a dev dependency:\n\n```bash\nnpm install --save-dev zshy\nyarn add --dev zshy\npnpm add --save-dev zshy\n```\n\n \n\n### 2. Specify your entrypoint(s) in `package.json#zshy`:\n\nSingle entrypoint:\n\n```diff\n// package.json\n{\n \"name\": \"my-pkg\",\n \"version\": \"1.0.0\",\n+ \"zshy\": \"./src/index.ts\"\n}\n```\n\nMultiple entrypoints:\n\n```diff\n// package.json\n{\n \"name\": \"my-pkg\",\n \"version\": \"1.0.0\",\n\n+ \"zshy\": {\n+ \"exports\": {\n+ \".\": \"./src/index.ts\",\n+ \"./utils\": \"./src/utils.ts\",\n+ \"./plugins/*\": \"./src/plugins/*\", // wildcard\n+ \"./components/**/*\": \"./src/components/**/*\" // deep wildcard\n+ }\n+ }\n}\n```\n\n \n\n### 3. Run a build\n\nRun a build with `npx zshy`:\n\n```bash\n$ npx zshy # use --dry-run to try it out without writing/updating files\n\nβ Starting zshy build π\nβ Detected project root: /Users/colinmcd94/Documents/projects/zshy\nβ Reading package.json from ./package.json\nβ Reading tsconfig from ./tsconfig.json\nβ Cleaning up outDir...\nβ Determining entrypoints...\n ββββββββββββββ€βββββββββββββββββ\n β Subpath β Entrypoint β\n ββββββββββββββΌβββββββββββββββββ’\n β \"my-pkg\" β ./src/index.ts β\n ββββββββββββββ§βββββββββββββββββ\nβ Resolved build paths:\n ββββββββββββ€βββββββββββββββββ\n β Location β Resolved path β\n ββββββββββββΌβββββββββββββββββ’\n β rootDir β ./src β\n β outDir β ./dist β\n ββββββββββββ§βββββββββββββββββ\nβ Package is an ES module (package.json#/type is \"module\")\nβ Building CJS... (rewriting .ts -> .cjs/.d.cts)\nβ Building ESM...\nβ Updating package.json#/exports...\nβ Updating package.json#/bin...\nβ Build complete! β \n```\n\n> **Add a `\"build\"` script to your `package.json`**\n>\n> ```diff\n> {\n> // ...\n> \"scripts\": {\n> + \"build\": \"zshy\"\n> }\n> }\n> ```\n>\n> Then, to run a build:\n>\n> ```bash\n> $ npm run build\n> ```\n\n \n\n \n\n
How it works
\n\nVanilla `tsc` does not perform _extension rewriting_; it will only ever transpile a `.ts` file to a `.js` file (never `.cjs` or `.mjs`). This is the fundamental limitation that forces library authors to use bundlers or bundler-powered tools like `tsup`, `tsdown`, or `unbuild`...\n\n...until now! `zshy` works around this limitation using the official [TypeScript Compiler API](https://github.com/microsoft/TypeScript/wiki/Using-the-Compiler-API), which provides some powerful (and criminally under-utilized) hooks for customizing file extensions during the `tsc` build process.\n\nUsing these hooks, `zshy` transpiles each `.ts` file to `.js/.d.ts` (ESM) and `.cjs/.d.cts` (CommonJS):\n\n```bash\n$ tree .\nβββ package.json\nβββ src\nβ βββ index.ts\nβββ dist # generated\n βββ index.js\n βββ index.cjs\n βββ index.d.ts\n βββ index.d.cts\n```\n\nSimilarly, all relative `import`/`export` statements are rewritten to include the appropriate file extension. (Other tools like `tsup` or `tsdown` do the same, but they require a bundler to do so.)\n\n| Original path | Result (ESM) | Result (CJS) |\n| ------------------ | ------------------ | ------------------- |\n| `from \"./util\"` | `from \"./util.js\"` | `from \"./util.cjs\"` |\n| `from \"./util.ts\"` | `from \"./util.js\"` | `from \"./util.cjs\"` |\n| `from \"./util.js\"` | `from \"./util.js\"` | `from \"./util.cjs\"` |\n\nFinally, `zshy` automatically writes `\"exports\"` into your `package.json`:\n\n```diff\n{\n // ...\n \"zshy\": {\n \"exports\": \"./src/index.ts\"\n },\n+ \"exports\": { // auto-generated by zshy\n+ \".\": {\n+ \"types\": \"./dist/index.d.cts\",\n+ \"import\": \"./dist/index.js\",\n+ \"require\": \"./dist/index.cjs\"\n+ }\n+ }\n}\n```\n\nThe result is a tool that I consider to be the \"holy grail\" of TypeScript library build tools:\n\n- performs dual-module (ESM + CJS) builds\n- type checks your code\n- leverages `tsc` for gold-standard transpilation\n- doesn't require a bundler\n- doesn't require another config file (just `package.json` and `tsconfig.json`)\n\n \n \n\n
Usage
\n\n \n\n### Flags\n\n```sh\n$ npx zshy --help\nUsage: zshy [options]\n\nOptions:\n -h, --help Show this help message\n -p, --project Path to tsconfig (default: ./tsconfig.json)\n --verbose Enable verbose output\n --dry-run Don't write any files or update package.json\n --fail-threshold When to exit with non-zero error code\n \"error\" (default)\n \"warn\"\n \"never\"\n```\n\n \n\n### Subpaths and wildcards\n\nMulti-entrypoint packages can specify subpaths or wildcard exports in `package.json#/zshy/exports`:\n\n```jsonc\n{\n \"name\": \"my-pkg\",\n \"version\": \"1.0.0\",\n\n \"zshy\": {\n \"exports\": {\n \".\": \"./src/index.ts\", // root entrypoint\n \"./utils\": \"./src/utils.ts\", // subpath\n \"./plugins/*\": \"./src/plugins/*\", // wildcard\n \"./components/*\": \"./src/components/**/*\" // deep wildcard\n }\n }\n}\n```\n\n\nView typical build output\n\nWhen you run a build, you'll see something like this:\n\n```bash\n$ npx zshy\n\nβ Starting zshy build... π\nβ Detected project root: /path/to/my-pkg\nβ Reading package.json from ./package.json\nβ Reading tsconfig from ./tsconfig.json\nβ Determining entrypoints...\n ββββββββββββββββββββββ€ββββββββββββββββββββββββββββββ\n β Subpath β Entrypoint β\n ββββββββββββββββββββββΌββββββββββββββββββββββββββββββ’\n β \"my-pkg\" β ./src/index.ts β\n β \"my-pkg/utils\" β ./src/utils.ts β\n β \"my-pkg/plugins/*\" β ./src/plugins/* (5 matches) β\n ββββββββββββββββββββββ§ββββββββββββββββββββββββββββββ\nβ Resolved build paths:\n ββββββββββββ€βββββββββββββββββ\n β Location β Resolved path β\n ββββββββββββΌβββββββββββββββββ’\n β rootDir β ./src β\n β outDir β ./dist β\n ββββββββββββ§βββββββββββββββββ\nβ Package is ES module (package.json#/type is \"module\")\nβ Building CJS... (rewriting .ts -> .cjs/.d.cts)\nβ Building ESM...\nβ Updating package.json exports...\nβ Build complete! β \n```\n\nAnd the generated `\"exports\"` map will look like this:\n\n```diff\n// package.json\n{\n // ...\n+ \"exports\": {\n+ \".\": {\n+ \"types\": \"./dist/index.d.cts\",\n+ \"import\": \"./dist/index.js\",\n+ \"require\": \"./dist/index.cjs\"\n+ },\n+ \"./utils\": {\n+ \"types\": \"./dist/utils.d.cts\",\n+ \"import\": \"./dist/utils.js\",\n+ \"require\": \"./dist/utils.cjs\"\n+ },\n+ \"./plugins/*\": {\n+ \"types\": \"./dist/src/plugins/*\",\n+ \"import\": \"./dist/src/plugins/*\",\n+ \"require\": \"./dist/src/plugins/*\"\n+ }\n+ }\n}\n```\n\n\n\n \n\n### Building CLIs (`\"bin\"` support)\n\nIf your package is a CLI, specify your CLI entrypoint in `package.json#/zshy/bin`. `zshy` will include this entrypoint in your builds and automatically set `\"bin\"` in your package.json.\n\n```diff\n{\n // package.json\n \"name\": \"my-cli\",\n \"version\": \"1.0.0\",\n \"type\": \"module\",\n \"zshy\": {\n+ \"bin\": \"./src/cli.ts\"\n }\n}\n```\n\nThe `\"bin\"` field is automatically written into your `package.json`:\n\n```diff\n{\n // package.json\n \"name\": \"my-cli\",\n \"version\": \"1.0.0\",\n \"zshy\": {\n \"exports\": \"./src/index.ts\",\n \"bin\": \"./src/cli.ts\"\n },\n+ \"bin\": {\n+ \"my-cli\": \"./dist/cli.cjs\" // CLI entrypoint\n+ }\n}\n```\n\n> **Note** β The `\"bin\"` field defaults to the CJS build unless you have disabled it with `\"cjs\": false`.\n\n\nMultiple CLIs\n\nFor packages that expose multiple CLI tools, `\"bin\"` can also be an object mappingeach command name to its source file:\n\n```jsonc\n{\n // package.json\n \"name\": \"my-cli\",\n \"version\": \"1.0.0\",\n \"type\": \"module\",\n \"zshy\": {\n \"bin\": {\n \"my-cli\": \"./src/cli.ts\",\n \"other\": \"./src/other.ts\"\n }\n }\n}\n```\n\nThis generates a corresponding object `\"bin\"` field:\n\n```diff\n{\n // package.json\n \"name\": \"my-cli\",\n \"version\": \"1.0.0\",\n \"zshy\": {\n \"exports\": \"./src/index.ts\",\n \"bin\": {\n \"my-cli\": \"./src/cli.ts\",\n \"other\": \"./src/other.ts\"\n }\n },\n \"bin\": {\n \"my-cli\": \"./dist/cli.cjs\",\n \"other\": \"./dist/other.cjs\"\n }\n}\n```\n\n\n\nBe sure to include a [shebang]() as the first line of your CLI entrypoint file:\n\n```ts\n#!/usr/bin/env node\n\n// CLI code here\n```\n\n \n\n### ESM-only\n\nFor packages that only need ESM builds, you can disable CommonJS output entirely:\n\n```jsonc\n{\n \"zshy\": {\n \"exports\": { ... },\n \"cjs\": false\n }\n}\n```\n\nThis will generate only ESM files (`.js` and `.d.ts`) and the `package.json#/exports` will only include `\"import\"` and `\"types\"` conditions.\n\n```jsonc\n{\n // package.json\n \"exports\": {\n \".\": {\n \"types\": \"./dist/index.d.ts\",\n \"import\": \"./dist/index.js\"\n }\n }\n}\n```\n\n \n\n### Custom conditions\n\nTo specify custom conditions in your export maps, specify a `\"conditions\"` map. Each condition name must correspond to one of `\"src\" | \"esm\" | \"cjs\"`.\n\n```diff\n{\n \"zshy\": {\n \"exports\": {\n \".\": \"./src/index.ts\"\n },\n+ \"conditions\": {\n+ \"my-src-condition\": \"src\"\n+ \"my-esm-condition\": \"esm\",\n+ \"my-cjs-condition\": \"cjs\"\n+ }\n}\n```\n\nWith this addition, `zshy` will add the `\"my-source\"` condition to the generated `\"exports\"` map:\n\n```diff\n// package.json\n{\n \"exports\": {\n \".\": {\n+ \"my-src-condition\": \"./src/index.ts\",\n+ \"my-esm-condition\": \"./dist/index.js\",\n+ \"my-cjs-condition\": \"./dist/index.cjs\"\n \"types\": \"./dist/index.d.cts\",\n \"import\": \"./dist/index.js\",\n \"require\": \"./dist/index.cjs\"\n }\n }\n}\n```\n\n### JSR\n\nFor packages that also have a `jsr.json` file for publishing to [JSR](https://jsr.io/), `zshy` will copy your configured exports to `jsr.json/#exports`, making your `zshy` configuration the single source of truth for exports.\n\nThis will copy over the paths of the source code entrypoints, not the paths to the transpiled code, since JSR supports and encourages publishing TypeScript source code rather than pairs of `.js` + `.d.ts` files.\n\n \n \n \n\n
FAQ for nerds
\n\n \n\n### How does `zshy` resolve entrypoints?\n\nIt reads your `package.json#/zshy` config:\n\n```jsonc\n// package.json\n{\n \"name\": \"my-pkg\",\n \"version\": \"1.0.0\",\n \"zshy\": {\n \"exports\": {\n \".\": \"./src/index.ts\",\n \"./utils\": \"./src/utils.ts\",\n \"./plugins/*\": \"./src/plugins/*\", // shallow match {.ts,.tsx,.cts,.mts} files\n \"./components/*\": \"./src/components/**/*\" // deep match *.{.ts,.tsx,.cts,.mts} files\n }\n }\n}\n```\n\nA few important notes about `package.json#/zshy/exports`:\n\n- All keys should start with `\"./\"`\n- All values should be relative paths to source files (resolved relative to the `package.json` file)\n\nA few notes on wildcards exports:\n\n- The _key_ should always end in `\"/*\"`\n- The _value_ should correspond to a glob-like path value that ends in either `\"/*\"` (shallow match) or `\"/**/*\"` (deep match)\n- Do not include a file extensions! `zshy` matches source files with the following extensions:\n - `.ts`, `.tsx`, `.cts`, `.mts`\n- A shallow match (`.//*`) will match both:\n - `.//*.{ts,tsx,cts,mts}`\n - `.//*/index.{ts,tsx,cts,mts}`.\n- A deep match (`.//**/*`) will match all files recursively in the specified directory, including subdirectories:\n - `.//**/*.{ts,tsx,cts,mts}`\n - `.//**/*/index.{ts,tsx,cts,mts}`\n\n**Note** β Since `zshy` computes an exact set of resolved entrypoints, your `\"files\"`, `\"include\"`, and `\"exclude\"` settings in `tsconfig.json` are ignored during the build.\n\n \n\n### Does `zshy` respect my `tsconfig.json` compiler options?\n\nYes! With some strategic overrides:\n\n- **`module`**: Overridden (`\"commonjs\"` for CJS build, `\"esnext\"` for ESM build)\n- **`moduleResolution`**: Overridden (`\"node10\"` for CJS, `\"bundler\"` for ESM)\n- **`declaration`/`noEmit`/`emitDeclarationOnly`**: Overridden to ensure proper output\n- **`verbatimModuleSyntax`**: Set to `false` to allow multiple build formats\n- **`esModuleInterop`**: Set to `true` (it's a best practice)\n- **`composite`**: Set to `false` to avoid resolution issues. `zshy` will build all files that are reachable from your specified entrypoints.\n\nAll other options are respected as defined, though `zshy` will also set the following reasonable defaults if they are not explicitly set:\n\n- `outDir` (defaults to `./dist`)\n- `declarationDir` (defaults to `outDir` β you probably shouldn't set this explicitly)\n- `target` (defaults to `es2020`)\n\n \n\n### Do I need to use a specific file structure?\n\nNo. You can organize your source however you like; `zshy` will transpile your entrypoints and all the files they import, respecting your `tsconfig.json` settings.\n\n> **Comparison to `tshy`** β `tshy` requires you to put your source in a `./src` directory, and always builds to `./dist/esm` and `./dist/cjs`.\n\n \n\n### What files does `zshy` create?\n\nIt depends on your `package.json#/type` field. If your package is ESM (that is, `\"type\": \"module\"` in `package.json`):\n\n- `.js` + `.d.ts` (ESM)\n- `.cjs` + `.d.cts` (CJS)\n\n```bash\n$ tree dist\n\n.\nβββ package.json # if type == \"module\"\nβββ src\nβΒ Β βββ index.ts\nβββ dist\n Β Β βββ index.js\n Β Β βββ index.d.ts\n Β Β βββ index.cjs\n Β Β βββ index.d.cts\n```\n\nOtherwise, the package is considered _default-CJS_ and the ESM build files will be rewritten as `.mjs`/`.d.mts`.\n\n- `.mjs` + `.d.mts` (ESM)\n- `.js` + `.d.ts` (CJS)\n\n```bash\n$ tree dist\n.\nβββ package.json # if type != \"module\"\nβββ src\nβΒ Β βββ index.ts\nβββ dist\n Β Β βββ index.js\n Β Β βββ index.d.ts\n Β Β βββ index.mjs\n Β Β βββ index.d.mts\n```\n\n> **Comparison to `tshy`** β `tshy` generates plain `.js`/`.d.ts` files into separate `dist/esm` and `dist/cjs` directories, each with a stub `package.json` to enable proper module resolution in Node.js. This is more convoluted than the flat file structure generated by `zshy`. It also causes issues with [Module Federation](https://github.com/colinhacks/zod/issues/4656).\n\n \n\n### How does extension rewriting work?\n\n`zshy` uses the [TypeScript Compiler API](https://github.com/microsoft/TypeScript/wiki/Using-the-Compiler-API) to rewrite file extensions during the `tsc` emit step.\n\n- If `\"type\": \"module\"`\n - `.ts` becomes `.js`/`.d.ts` (ESM) and `.cjs`/`.d.cts` (CJS)\n- Otherwise:\n - `.ts` becomes `.mjs`/`.d.mts` (ESM) and `.js`/`.d.ts` (CJS)\n\nSimilarly, all relative `import`/`export` statements are rewritten to account for the new file extensions.\n\n| Original path | Result (ESM) | Result (CJS) |\n| ------------------ | ------------------ | ------------------- |\n| `from \"./util\"` | `from \"./util.js\"` | `from \"./util.cjs\"` |\n| `from \"./util.ts\"` | `from \"./util.js\"` | `from \"./util.cjs\"` |\n| `from \"./util.js\"` | `from \"./util.js\"` | `from \"./util.cjs\"` |\n\nTypeScript's Compiler API provides dedicated hooks for performing such transforms (though they are criminally under-utilized).\n\n- **`ts.TransformerFactory`**: Provides AST transformations to rewrite import/export extensions before module conversion\n- **`ts.CompilerHost#writeFile`**: Handles output file extension changes (`.js` β `.cjs`/`.mjs`)\n\n> **Comparison to `tshy`** β `tshy` was designed to enable dual-package builds powered by the `tsc` compiler. To make this work, it relies on a specific file structure and the creation of temporary `package.json` files to accommodate the various idiosyncrasies of Node.js module resolution. It also requires the use of separate `dist/esm` and `dist/cjs` build subdirectories.\n\n \n\n### Can I use extension-less imports?\n\nYes! `zshy` supports whatever import style you prefer:\n\n- `from \"./utils\"`: classic extensionless imports\n- `from \"./utils.js\"`: ESM-friendly extensioned imports\n- `from \"./util.ts\"`: recently supported natively via[`rewriteRelativeImportExtensions`](https://www.typescriptlang.org/tsconfig/#rewriteRelativeImportExtensions)\n\nUse whatever you like; `zshy` will rewrite all imports/exports properly during the build process.\n\n> **Comparison to `tshy`** β `tshy` forces you to use `.js` imports throughout your codebase. While this is generally a good practice, it's not always feasible, and there are hundreds of thousands of existing TypeScript codebases reliant on extensionless imports.\n\n \n\n### What about `package.json#/exports`?\n\nYour exports map is automatically written into your `package.json` when you run `zshy`. The generated exports map looks like this:\n\n```diff\n{\n \"zshy\": {\n \"exports\": {\n \".\": \"./src/index.ts\",\n \"./utils\": \"./src/utils.ts\",\n \"./plugins/*\": \"./src/plugins/*\"\n }\n },\n+ \"exports\": { // auto-generated by zshy\n+ \".\": {\n+ \"types\": \"./dist/index.d.cts\",\n+ \"import\": \"./dist/index.js\",\n+ \"require\": \"./dist/index.cjs\"\n+ },\n+ \"./utils\": {\n+ \"types\": \"./dist/utils.d.cts\",\n+ \"import\": \"./dist/utils.js\",\n+ \"require\": \"./dist/utils.cjs\"\n+ },\n+ \"./plugins/*\": {\n+ \"import\": \"./dist/src/plugins/*\",\n+ \"require\": \"./dist/src/plugins/*\"\n+ }\n+ }\n}\n```\n\n \n\n### Why `.d.cts` for `\"types\"`?\n\nThe `\"types\"` field always points to the CJS declaration file (`.d.cts`). This is an intentional design choice. **It solves the \"Masquerading as ESM\" issue**. You've likely seen this dreaded error before:\n\n```ts\nimport mod from \"pkg\"; ^^^^^\n// ^ The current file is a CommonJS module whose imports will produce 'require' calls; however, the referenced file is an ECMAScript module and cannot be imported with 'require'. Consider writing a dynamic 'import(\"pkg\")' call instead.\n```\n\nSimply put, an ESM file can `import` CommonJS, but CommonJS files can't `require` ESM. By having `\"types\"` point to the `.d.cts` declarations, we can always avoid the error above. Technically we're tricking TypeScript into thinking our code is CommonJS; in practice, this has no real consequences and maximizes compatibility.\n\nTo learn more, read the [\"Masquerading as ESM\"](https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/FalseESM.md) writeup from ATTW.\n\n> **Comparison to `tshy`** β `tshy` generates independent (but identical) `.d.ts` files in `dist/esm` and `dist/cjs`. This can cause [Excessively Deep](https://github.com/colinhacks/zod/issues/4422) errors if users of the library use declaration merging (`declare module {}`) for plugins/extensions. [Zod](https://github.com/colinhacks/zod), [day.js](https://day.js.org/), and others rely on this pattern for plugins.\n\n \n\n### Why do I see \"Masquerading as CJS\"?\n\nThis is expected behavior when running the \"Are The Types Wrong\" tool. This warning does not cause any resolution issues (unlike \"Masquerading as ESM\"). Technically, we're tricking TypeScript into thinking our code is CommonJS; when in fact it may be ESM. The ATTW tool is very rigorous and flags this; in practice, this has no real consequences and maximizes compatibility (Zod has relied on the CJS masquerading trick since it's earliest days.)\n\nTo learn more, read the [\"Masquerading as CJS\"](https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/FalseCJS.md) writeup from ATTW.\n\n \n\n### How are default exports transpiled?\n\n**CJS interop transform** βΒ When a file contains a single `export default ...` and _no named exports_...\n\n```ts\nfunction hello() {\n console.log(\"hello\");\n}\n\nexport default hello;\n```\n\n...the built `.cjs` code will assign the exported value directly to `module.exports`:\n\n```ts\nfunction hello() {\n console.log(\"hello\");\n}\nexports.default = hello;\nmodule.exports = exports.default;\n```\n\n...and the associated `.d.cts` files will use `export =` syntax:\n\n```ts\ndeclare function hello(): void;\nexport = hello;\n```\n\nThe ESM build is not impacted by this transform.\n\n**ESM interop transform** βΒ Similarly, if a source `.ts` file contains the following syntax:\n\n```ts\nexport = ...\n```\n\n...the generated _ESM_ build will transpile to the following syntax:\n\n```ts\nexport default ...\n```\n\n \n\n### Can it support React Native or non-Node.js environments?\n\nYes! This is one of the key reasons `zshy` was originally developed. Many environments don't support `package.json#/exports` yet:\n\n- Node.js v12.7 or earlier\n- React Native - The Metro bundler does not support `\"exports\"` by default\n- TypeScript projects with legacy configs β e.g. `\"module\": \"commonjs\"`\n\nThis causes issues for packages that want to use subpath imports to structure their package. Fortunately `zshy` unlocks a workaround I call a _flat build_:\n\n1. Remove `\"type\": \"module\"` from your `package.json` (if present)\n2. Set `outDir: \".\"` in your `tsconfig.json`\n3. Configure `\"exclude\"` in `package.json` to exclude all source files:\n\n ```jsonc\n {\n // ...\n \"exclude\": [\"**/*.ts\", \"**/*.tsx\", \"**/*.cts\", \"**/*.mts\", \"node_modules\"]\n }\n ```\n\nWith this setup, your build outputs (`index.js`, etc) will be written to the package root. Older environments will resolve imports like `\"your-library/utils\"` to `\"your-library/utils/index.js\"`, effectively simulating subpath imports in environments that don't support them.\n\n \n\n### Can I prevent `zshy` from modifying my `package.json`/`jsr.json`?\n\nYes. If you prefer to manage your export fields manually, you can prevent `zshy` from making any changes by setting the `noEdit` option to `true` in your `package.json#/zshy` config.\n\n```jsonc\n{\n \"zshy\": {\n \"exports\": \"./src/index.ts\",\n \"noEdit\": true\n }\n}\n```\n\nWhen `noEdit` is enabled, `zshy` will build your files but will not write to `package.json` or `jsr.json`. You will be responsible for populating the `\"exports\"`, `\"bin\"`, `\"main\"`, `\"module\"`, and `\"types\"` fields yourself.\n\n \n\n### Is it fast?\n\nNot really. It uses `tsc` to typecheck your codebase, which is a lot slower than using a bundler that strips types. That said:\n\n1. You _should_ be type checking your code during builds\n2. TypeScript is [about to get 10x faster](https://devblogs.microsoft.com/typescript/typescript-native-port/)\n\n \n \n\n
Acknowledgements
\n\nThe DX of `zshy` was heavily inspired by [tshy](https://github.com/isaacs/tshy) by [@isaacs](https://x.com/izs), particularly its declarative entrypoint map and auto-updating of `package.json#/exports`. It proved that there's a modern way to transpile libraries using pure `tsc` (and various `package.json` hacks). Unfortunately its approach necessarily involved certain constraints that made it unworkable for Zod (described in the FAQ in more detail). `zshy` borrows elements of `tshy`'s DX while using the Compiler API to relax these constraints and provide a more \"batteries included\" experience.\n","readmeFilename":"README.md"}
![\"License\"](\"https://img.shields.io/github/license/colinhacks/zshy\")
\n![\"npm\"](\"https://img.shields.io/npm/dw/zshy.svg\")
\n![\"stars\"](\"https://img.shields.io/github/stars/colinhacks/zshy\")
\n