svelte-typecheck 0.0.0 → 0.1.1

package/README.md

@@ -1,5 +1,221 @@
 # svelte-typecheck
 
-Placeholder package reserving the "svelte-typecheck" name.
+> Type-check Svelte components with the checker of your choice: `bun check`, tsrs, tsgo or `tsc`.
 
-This package name is currently reserved and not yet implemented.
+svelte-typecheck turns each component into TypeScript, runs a type checker on it, and maps every error back to its line and column in the `.svelte` file. It reports what svelte-check reports, up to 11× faster, with about half the memory.
+
+```sh
+bun add -d svelte-typecheck
+bunx svelte-typecheck
+```
+
+Runs on Bun and on Node 22+ (`npx svelte-typecheck`). It checks with your project's own TypeScript, so the errors match your editor and build; TypeScript 7's `tsc` is native and fast. `--checker bun` or `--checker tsrs` is faster still.
+
+```
+/my-app/src/Errors.svelte:11:8
+Error: Type '"tertiary"' is not assignable to type '"primary" | "ghost" | undefined'. (ts)
+
+/my-app/src/Errors.svelte:13:33
+Error: Property 'nope' does not exist on type '{ text: "primary" | "ghost"; }'. (ts)
+
+====================================
+svelte-typecheck found 2 errors and 0 warnings in 1 file
+```
+
+## Why
+
+|                | svelte-check                    | svelte-typecheck                                                  |
+| :------------- | :------------------------------ | :---------------------------------------------------------------- |
+| Type checker   | TypeScript's JS API (TS 5 or 6) | Any checker that reads a tsconfig: `bun check`, tsrs, tsgo, `tsc` |
+| TypeScript 7   | Needs `typescript@~6` beside it | Works: never imports `typescript`                                 |
+| Dependencies   | 6, plus `typescript` (24 MB)    | None: [sveast](https://github.com/metonym/sveast) is bundled      |
+| Svelte 3, 4, 5 | Yes                             | Yes, runes included                                               |
+| SvelteKit      | `./$types`, typed `load`, hooks | The same                                                          |
+
+The fastest of 5 cold runs on an 8-core Apple M2, each factor against
+svelte-check's default mode. svelte-check's own TypeScript 7 modes are
+in for comparison: the same tsgo, driven differently.
+
+| Tool                                   | Checker               | carbon-components-svelte | bits-ui      | realworld     |
+| :------------------------------------- | :-------------------- | :----------------------- | :----------- | :------------ |
+| svelte-check                           | TypeScript 6          | 40.5 s                   | 6.6 s        | 1.76 s        |
+| svelte-check `--tsgo-experimental-api` | TypeScript 7          | 11.6 s (3.5×)            | 2.8 s (2.3×) | 1.17 s (1.5×) |
+| svelte-typecheck                       | TypeScript 6 (`tsc`)  | 18.9 s (2.1×)            | 5.7 s (1.2×) | 1.24 s (1.4×) |
+| svelte-typecheck                       | TypeScript 7 (`tsgo`) | 7.9 s (5.1×)             | 1.6 s (4.2×) | 0.79 s (2.2×) |
+| svelte-typecheck                       | tsrs                  | 3.7 s (11.1×)            | 1.6 s (4.1×) | 0.70 s (2.5×) |
+| svelte-typecheck                       | `bun check`           | 3.6 s (11.3×)            | 1.4 s (4.7×) | 0.67 s (2.6×) |
+
+Peak memory falls with it: 0.85 GB against svelte-check's 1.74 GB on
+carbon-components-svelte with `bun check`. There, it also replaced
+svelte-check in CI, where the type tests went from 6 to 30 s to 1 to 3 s.
+
+Those are cold runs. After the first, a run regenerates and recompiles
+only the components that changed, the checker reuses its build cache,
+and with nothing changed, the last result comes back without checking
+at all. On carbon-components-svelte, with svelte-check's runs all cold:
+
+| Run                                  | `tsc`  | tsgo   | tsrs   | `bun check` |
+| :----------------------------------- | :----- | :----- | :----- | :---------- |
+| Cold                                 | 18.9 s | 7.9 s  | 3.7 s  | 3.6 s       |
+| One component changed                | 3.1 s  | 0.95 s | 0.72 s | 0.76 s      |
+| Nothing changed                      | 0.09 s | 0.09 s | 0.14 s | 0.09 s      |
+| `--watch`, from a save to its result | n/a    | 0.68 s | 0.37 s | 0.76 s      |
+
+`bun check` has no build cache of its own, so it checks the whole
+program again after a change. A run with nothing changed is known by
+each input's size and modification time: the components, the files
+the tsconfig includes and those it extends, the package manifests and
+lockfiles, the Svelte config and the versions, and the files the last
+run's program imported. An edit that none of those see, such as a
+hand-patched package in `node_modules`, needs `--no-incremental`.
+
+## Usage
+
+A drop-in replacement for svelte-check: the same options, the same output in all four formats, the same exit codes.
+
+```diff
+- "check": "svelte-check --tsconfig ./tsconfig.json"
++ "check": "svelte-typecheck --tsconfig ./tsconfig.json"
+```
+
+| svelte-check's options        |                                                                                                                                                                                |
+| :---------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `--workspace <dir>`           | Project folder (default: the current one)                                                                                                                                      |
+| `--output <format>`           | `human`, `human-verbose` (default), `machine` or `machine-verbose`                                                                                                             |
+| `--tsconfig <path>`           | tsconfig or jsconfig, relative to the workspace (default: the nearest from the workspace up). The components it includes are checked, and its TS and JS files' errors reported |
+| `--no-tsconfig`               | Check every component under the workspace, and no TS or JS files                                                                                                               |
+| `--ignore <list>`             | With `--no-tsconfig`: paths to skip, comma-separated                                                                                                                           |
+| `--config <path>`             | The vite.config or svelte.config to read preprocessors and `compilerOptions` from                                                                                              |
+| `--diagnostic-sources <list>` | `js`, `svelte` and `css`, comma-separated (default: all)                                                                                                                       |
+| `--threshold error`           | Print errors only                                                                                                                                                              |
+| `--compiler-warnings <list>`  | `code:ignore` or `code:error`, comma-separated                                                                                                                                 |
+| `--fail-on-warnings`          | Exit 1 on a warning too                                                                                                                                                        |
+| `--color`, `--no-color`       | Force color on or off                                                                                                                                                          |
+| `--tsgo`                      | Check with tsgo                                                                                                                                                                |
+
+| Its own               |                                                                                                                                                 |
+| :-------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------- |
+| `--checker <name>`    | `tsc` (default: your `typescript`), `tsgo`, `tsrs` or `bun`                                                                                     |
+| `--components <glob>` | Components to check, relative to the workspace, instead of the tsconfig's; repeatable                                                           |
+| `--out-dir <dir>`     | Where the generated code goes (default: `node_modules/.cache/svelte-typecheck/<workspace>`)                                                     |
+| `--no-declarations`   | Type component imports only by their own `.svelte.d.ts`, never the generated code                                                               |
+| `--svelte <dir>`      | The Svelte install to check against, e.g. a Svelte 4 test harness's                                                                             |
+| `--no-incremental`    | Start from nothing: by default, the generated code and the checker's build cache are kept between runs                                          |
+| `--changed`           | Report only the files changed from `HEAD` (and untracked ones), and the files that import them; see [Beyond svelte-check](#beyond-svelte-check) |
+| `--since <ref>`       | As `--changed`, from where the branch left `<ref>`: `--since origin/main`                                                                       |
+| `--baseline <file>`   | Report only diagnostics the baseline doesn't have; see [Beyond svelte-check](#beyond-svelte-check)                                              |
+| `--update-baseline`   | Write the run's diagnostics to `--baseline`'s file                                                                                              |
+
+## Beyond svelte-check
+
+What svelte-typecheck does that svelte-check doesn't:
+
+|                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| :------------------------------ | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Any checker, TypeScript 7**   | Checks with your project's `tsc`, including TypeScript 7's native one, or tsgo, tsrs or `bun check`; svelte-check needs TypeScript 5 or 6's JS API. See [Bring your own checker](#bring-your-own-checker).                                                                                                                                                                                                                                                                                             |
+| **Baselines**                   | `--update-baseline --baseline errors.json` records today's diagnostics; `--baseline errors.json` then reports, and fails on, only new ones. A diagnostic is known by its file, code, message and line's text, not its line number, so edits around it don't make it new; fixed ones are counted, to drop with `--update-baseline`. For turning on `strict`, a new rule, or a checker upgrade without fixing everything first. Its paths are the workspace's, so the file is the same on every machine. |
+| **Changed files only**          | `--changed` and `--since <ref>` report the files git sees changed and the files that import them, whose errors a change can cause. The whole program is still checked, so the errors are the same ones, fewer to read: for a pre-commit hook, or a PR's CI run.                                                                                                                                                                                                                                        |
+| **Speed and memory**            | Up to 11× faster than svelte-check with `bun check` or tsrs, at about half its memory, and 1.2 to 2× with TypeScript 6's own `tsc`: one checker process over files on disk, beside the compiler pass, where svelte-check drives TypeScript's language service file by file.                                                                                                                                                                                                                            |
+| **Zero dependencies**           | One bundle: it uses the project's own Svelte and checker, and installs nothing else.                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| **Generated code you can read** | The TypeScript it writes and its tsconfig are plain files in `--out-dir`: open them, or run any checker on them yourself. They're kept between runs, with the checker's own build cache, so a run after a change rewrites and rechecks only what it touches (`--no-incremental` starts over).                                                                                                                                                                                                          |
+| **No silent passes**            | Generated code that doesn't parse fails the run as a svelte-typecheck bug, and a checker error that names no file (a tsconfig option, a root file) is reported on the tsconfig. svelte-check's language service reads past broken generated code.                                                                                                                                                                                                                                                      |
+
+### Differences from svelte-check
+
+- **CSS diagnostics** (`--diagnostic-sources css`): accepted, but nothing is reported. svelte-check runs a CSS language service on `<style>`, a dependency this package leaves out; Svelte's compiler still reports invalid CSS.
+- **`COMPLETED <n> FILES`** counts components, not every file in TypeScript's program.
+- **`--diagnostic-sources svelte`** with a tsconfig reports no type errors, as svelte-check's docs say; svelte-check itself reports them.
+- **`--tsgo-experimental-api`** is accepted, and does what `--tsgo` does.
+- **tsconfig option errors** that only matter to an emitting build, such as a JS file that `tsc` would overwrite, aren't reported: the checker runs with `noEmit`.
+- **A union's members** can print in another order, as TypeScript orders them by when it first meets each type: `Element | Document` where svelte-check has `Document | Element`.
+- **A syntax error in a TS or JS file** stops `tsc` and the other CLI checkers from type-checking at all, so only syntax errors are reported until it's fixed; svelte-check's language service reports the type errors in other files too. A component's syntax errors don't do this.
+- **Svelte 3 and 4 with `lang="ts"` and no preprocessors**: svelte-check strips the types with a fallback preprocessor and reports the compiler's warnings; here the compiler can't read the script, so there are none.
+- **`--out-dir` outside the project** can't find its packages from the generated code; the default is inside `node_modules`.
+
+### API
+
+```ts
+import {
+  applyBaseline,
+  compilerDiagnostics,
+  createBaseline,
+  typecheck,
+} from "svelte-typecheck";
+
+const { diagnostics, components, timings } = await typecheck({
+  workspace: "src",
+  checker: "tsgo",
+});
+
+// Svelte's own warnings and errors (a11y, unused CSS, invalid markup).
+compilerDiagnostics(source, "Button.svelte");
+
+// What's new since a baseline, in the files a change reaches.
+const result = await typecheck({ only: ["src/Button.svelte"] });
+const baseline = createBaseline(result.diagnostics, result.workspace);
+applyBaseline(result.diagnostics, baseline, result.workspace).diagnostics; // []
+```
+
+## Bring your own checker
+
+svelte-typecheck doesn't bundle or import TypeScript. It writes the generated code and a tsconfig to disk and runs a checker on them as a separate process, so any of these works, at whatever version your project installs:
+
+| `--checker` | Install                                       | Runs                                         | Notes                                                                                               |
+| :---------- | :-------------------------------------------- | :------------------------------------------- | :-------------------------------------------------------------------------------------------------- |
+| `tsc`       | `typescript`                                  | `tsc -p <generated tsconfig> --pretty false` | The default. TypeScript 7's `tsc` is native; with 6, JS files' JSDoc reads as svelte-check reads it |
+| `tsgo`      | `@typescript/native-preview`                  | `tsgo -p … --pretty false`                   | TypeScript 7's preview build. `--tsgo` (svelte-check's flag) picks it too                           |
+| `tsrs`      | [`tsrs`](https://github.com/oxc-project/tsrs) | `tsrs -p … --pretty false`                   | oxc's Rust port of TypeScript 7                                                                     |
+| `bun`       | [Bun](https://bun.sh) 1.4                     | `bun check -p … --no-pretty --all`           | Bun's own TypeScript; no build cache, so it checks the whole program after a change                 |
+
+```sh
+svelte-typecheck                    # your project's typescript: tsc
+svelte-typecheck --checker tsgo     # or tsrs, or bun
+```
+
+```ts
+const result = await typecheck({ checker: "tsrs" });
+result.checker; // "tsrs"
+result.checkerVersion; // "0.20.1", from its package.json
+```
+
+### How a checker is found and run
+
+| Step      | What happens                                                                                                                                                                                                                                                                                           |
+| :-------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Pick      | `--checker`, or else the first of `tsc`, `tsgo`, `tsrs`, `bun` that's installed: your project's own TypeScript when it has one                                                                                                                                                                         |
+| Find      | Its package in `node_modules`, from the workspace up, as Node resolves one (a hoisted install counts), then its `bin` in the package's `package.json`; failing that, the command on `PATH` (on Windows, by `PATHEXT`: `tsc.cmd`, `bun.exe`). `bun` is the running Bun, if svelte-typecheck runs on Bun |
+| Launch    | A Node launcher (all three packages ship one) runs on the current runtime, Node or Bun, rather than through its shebang, so it works on Windows too; a native binary runs directly; a Windows `.cmd` shim runs through the shell                                                                       |
+| Configure | The generated tsconfig `extends` yours, so your compiler options (`strict`, `paths`, `lib`, `types`…) apply. It adds the generated code to `files` and `rootDirs`, and sets `noEmit` and its own `incremental` build info, so your files are never written                                             |
+| Read      | The checker prints errors as `tsc` does, `file(line,col): error TSxxxx: message`; each one maps back to its `.svelte` line, or to your TS file as it is. An error that names no file (a bad option) is reported on your tsconfig                                                                       |
+
+Any version works as long as it reads a tsconfig and prints `tsc`'s format: to pin one, install it in the project. TypeScript 7 reads JSDoc in JS files more strictly than 6, so a JS codebase's error count can move a little between them.
+
+## How it works
+
+1. **Find the project.** The tsconfig svelte-check would use (the nearer of tsconfig.json and jsconfig.json from the workspace up), and the components its `include` names.
+2. **Parse.** [sveast](https://github.com/metonym/sveast) parses each component and resolves its scopes: props, `$:` declarations, runes, stores, `{#each}`, `let:` and snippet scopes, every read and write.
+3. **Generate.** Each component becomes TypeScript (or JS with JSDoc) the way svelte2tsx writes it, with a map from each piece back to its source. The code, the helper types it calls (adapted from svelte2tsx's, MIT) and a tsconfig that extends yours go to `node_modules/.cache/svelte-typecheck`.
+4. **Check and compile, at once.** One checker process type-checks the whole program while Svelte's compiler reports its warnings beside it.
+5. **Map and order.** Each error maps back to its `.svelte` line, with svelte-check's rewrites and filters, in the order svelte-check prints them.
+6. **Keep.** What each step learned is kept for the next run.
+
+### What makes it fast
+
+| Choice                                                                                                                    | Effect on carbon-components-svelte (1,276 components) |
+| :------------------------------------------------------------------------------------------------------------------------ | :---------------------------------------------------- |
+| One batch run of a command-line checker, where svelte-check asks TypeScript's language service file by file               | 18.9 s against 40.5 s, on the same TypeScript 6       |
+| Native checkers (TypeScript 7, tsrs, `bun check`) on every core                                                           | 3.6 s with `bun check`, 11× faster                    |
+| sveast, a one-pass parser, instead of svelte2tsx and its source maps                                                      | Every component parsed and generated in about 0.4 s   |
+| Svelte's compiler alongside the checker, not after it                                                                     | The slower of the two sets the time, not their sum    |
+| Only what changed: components regenerated and recompiled, the checker's build cache, the last result when nothing changed | 0.72 s after one change (tsrs), 0.09 s with none      |
+
+## Limitations
+
+- **Type-checking only:** no editor support. Your editor keeps the Svelte language server, which can disagree with it at the edges.
+- **No CSS diagnostics.**
+
+The rest of what differs from svelte-check is under [Differences from svelte-check](#differences-from-svelte-check).
+
+## Contributing
+
+How it's built, the rules a change keeps, and how to check it against svelte-check and benchmark it: [CONTRIBUTING.md](CONTRIBUTING.md).

package/cli.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+import"./shared-58j2f7by.js";import{EmitError,typecheck2,watch2,createBaseline2,applyBaseline2}from"./shared-7zm6g9d3.js";import{readFileSync as readFileSync2,writeFileSync}from"node:fs";import{resolve}from"node:path";import{parseArgs}from"node:util";import{readFileSync}from"node:fs";import{relative,sep}from"node:path";var OUTPUT_FORMATS=["human","human-verbose","machine","machine-verbose"];function colors(force){let env=process.env,enabled=force??(env.FORCE_COLOR!==void 0?env.FORCE_COLOR!=="0":env.NO_COLOR===void 0&&Boolean(process.stdout.isTTY)&&env.TERM!=="dumb"),paint=(open,close)=>(text)=>enabled?`\x1B[${open}m${text}\x1B[${close}m`:text;return{red:paint(31,39),yellow:paint(33,39),green:paint(32,39),cyan:paint(36,39),magenta:paint(35,39)}}function lineOf(text,line){return text.split(`
+`)[line-1]??""}function codeFrame(d,c){let text;try{text=readFileSync(d.file,"utf-8")}catch{return""}let endLine=d.endLine??d.line,endColumn=d.endColumn??d.column,first=lineOf(text,d.line),last=lineOf(text,endLine),middle=d.line===endLine?first.slice(0,d.column-1)+c.magenta(first.slice(d.column-1,endColumn-1))+first.slice(endColumn-1):first.slice(0,d.column-1)+c.magenta([first.slice(d.column-1),...text.split(`
+`).slice(d.line,endLine-1),last.slice(0,endColumn-1)].join(`
+`))+last.slice(endColumn-1),before=d.line>1?`${lineOf(text,d.line-1)}
+`:"",after=lineOf(text,endLine+1);return`${before}${middle}
+${after}`}function codeOf(d){if(d.code.startsWith("TS"))return Number(d.code.slice(2));return NUMERIC.test(d.code)?Number(d.code):d.code}var NUMERIC=/^-?\d+$/;function sourceOf(d){return d.file.endsWith(".svelte")||d.source==="svelte"?d.source:void 0}var COMPILER_CODE=/^[a-z][\w-]*[-_][\w-]*$/,DASH=/-/g;function codeDescriptionOf(d){if(d.source!=="svelte"||!COMPILER_CODE.test(d.code))return;return{href:`https://svelte.dev/docs/svelte/${d.severity==="warning"?"compiler-warnings":"compiler-errors"}#${d.code.replace(DASH,"_")}`}}function summarize(diagnostics,files){let errors=diagnostics.filter((d)=>d.severity==="error").length;return{files,errors,warnings:diagnostics.length-errors,filesWithProblems:new Set(diagnostics.map((d)=>d.file)).size}}var DRIVE=/^[A-Z]:/;function displayed(workspace){return process.platform==="win32"?workspace.replace(DRIVE,(drive)=>drive.toLowerCase()):workspace}function writer(format,write,c){let machine=format.startsWith("machine"),verbose=format.endsWith("verbose"),log=(message)=>write(`${Date.now()} ${message}
+`);return{start(workspace,clearScreen=!1){if(!machine&&clearScreen&&process.stdout.isTTY)write("\x1B[2J\x1B[3J\x1B[H");if(machine)log(`START ${JSON.stringify(displayed(workspace))}`);else if(verbose)write(`Loading svelte-typecheck in workspace: ${displayed(workspace)}
+Getting Svelte diagnostics...
+
+`)},diagnostic(d,workspace){let filename=relative(workspace,d.file),type=d.severity==="error"?"ERROR":"WARNING";if(machine){if(verbose)log(JSON.stringify({type,filename,start:{line:d.line-1,character:d.column-1},end:{line:(d.endLine??d.line)-1,character:(d.endColumn??d.column)-1},message:d.message,code:codeOf(d),codeDescription:codeDescriptionOf(d),source:sourceOf(d)}));else log(`${type} ${JSON.stringify(filename)} ${d.line}:${d.column} ${JSON.stringify(d.message)}`);return}write(`${displayed(workspace)}${sep}${c.green(filename)}:${d.line}:${d.column}
+`);let source=sourceOf(d)?`(${d.source})`:"",message=verbose?`${d.message} ${source}
+${c.cyan(codeFrame(d,c).trimEnd())}`:`${d.message} ${source}`;write(`${d.severity==="error"?c.red("Error"):c.yellow("Warn")}: ${message}
+
+`)},note(text){if(!machine)write(`${text}
+`)},completion(summary,watching=!1){let{files,errors,warnings,filesWithProblems}=summary;if(machine){log(`COMPLETED ${files} FILES ${errors} ERRORS ${warnings} WARNINGS ${filesWithProblems} FILES_WITH_PROBLEMS`);return}if(filesWithProblems)write(`====================================
+`);let message=`svelte-typecheck found ${errors} ${errors===1?"error":"errors"} and ${warnings} ${warnings===1?"warning":"warnings"}${filesWithProblems?` in ${filesWithProblems} ${filesWithProblems===1?"file":"files"}`:""}
+`;if(errors)write(c.red(message));else if(warnings)write(c.yellow(message));else write(c.green(message));if(watching)write("Watching for file changes...")},failure(error){if(machine)log(`FAILURE ${JSON.stringify(error.message)}`);else write(`${error.message}
+`)}}}import{spawnSync}from"node:child_process";import{join}from"node:path";var LINE_BREAK=/\r?\n/;function git(args,cwd){let result=spawnSync("git",args,{cwd,encoding:"utf-8"});if(result.status!==0)throw Error(`git ${args.join(" ")} failed: ${(result.stderr||result.error?.message||"").trim()}`);return result.stdout}function changedFiles(cwd,since){let top=git(["rev-parse","--show-toplevel"],cwd).trim(),base=since?git(["merge-base",since,"HEAD"],cwd).trim():"HEAD",lines=[...git(["diff","--name-only",base],cwd).split(LINE_BREAK),...git(["ls-files","--others","--exclude-standard"],top).split(LINE_BREAK)];return[...new Set(lines.filter(Boolean).map((line)=>join(top,line)))]}var HELP=`Usage: svelte-typecheck [options]
+
+Type-checks Svelte components, as svelte-check does.
+
+svelte-check's options:
+  --workspace <dir>         Project folder (default: the current one)
+  --output <format>         human, human-verbose, machine or machine-verbose
+                            (default: human-verbose)
+  --tsconfig <path>         tsconfig or jsconfig, relative to the workspace;
+                            its TS and JS files' errors are reported too
+                            (default: the nearest from the workspace up)
+  --no-tsconfig             Check every component under the workspace, and
+                            no TS or JS files
+  --ignore <list>           With --no-tsconfig: paths to skip, relative to
+                            the workspace, comma-separated
+  --config <path>           vite.config or svelte.config to read preprocessors
+                            and compilerOptions from (default: the nearest)
+  --diagnostic-sources <list>
+                            js, svelte and css, comma-separated (default: all;
+                            css reports nothing)
+  --threshold <level>       error reports errors only (default: warning)
+  --compiler-warnings <list>
+                            code:ignore or code:error, comma-separated
+  --fail-on-warnings        Exit 1 on a warning too
+  --color, --no-color       Force color on or off
+  --watch                   Check again when a file changes
+  --preserveWatchOutput     Don't clear the screen between watch runs
+  --incremental             Keep generated code between runs, and let the
+                            checker reuse its last run (the default)
+  --no-incremental          Start from nothing each run
+  --tsgo                    Check with tsgo (same as --checker tsgo)
+  -h, --help                Show this help
+  -v, --version             Show the version
+
+svelte-typecheck's own:
+  --checker <name>          tsc, tsgo, tsrs or bun (default: the project's
+                            TypeScript, then the first installed)
+  --components <glob>       Components to check, relative to the workspace,
+                            instead of the tsconfig's; repeatable
+  --out-dir <dir>           Where to write the generated code (default:
+                            node_modules/.cache/svelte-typecheck/<workspace>)
+  --no-declarations         Resolve component imports to their own
+                            .svelte.d.ts
+  --svelte <dir>            Svelte package to check against
+  --changed                 Report only files changed from HEAD (and
+                            untracked), and the files that import them
+  --since <ref>             As --changed, from where the branch left <ref>
+  --baseline <file>         Report only diagnostics the baseline doesn't have
+  --update-baseline         Write the run's diagnostics to the baseline
+
+Exits 1 on an error, or a warning with --fail-on-warnings.`;async function main(argv){let values;try{values=parse(argv).values}catch(error){return console.error(`${error.message}
+
+${HELP}`),1}if(values.help)return console.log(HELP),0;if(values.version){let{version}=await import("./shared-9c39v7dt.js");return console.log(version),0}let format=formatOf(values.output),out=writer(format,(text)=>process.stdout.write(text),colors(colorFlag(values.color,values["no-color"]))),options={workspace:values.workspace??".",tsconfig:values["no-tsconfig"]?!1:values.tsconfig,ignore:values.ignore?.split(","),config:values.config,checker:values.checker??(values.tsgo||values["tsgo-experimental-api"]?"tsgo":void 0),components:values.components,outDir:values["out-dir"],declarations:!values["no-declarations"],svelte:values.svelte,diagnosticSources:values["diagnostic-sources"]?.split(",").map((source)=>source.trim()),compilerWarnings:parseCompilerWarnings(values["compiler-warnings"]),incremental:!values["no-incremental"]};if(values.changed||values.since)try{options.only=changedFiles(process.cwd(),values.since)}catch(error){return out.failure(error),1}let baselinePath=values.baseline&&resolve(values.baseline);if(values["update-baseline"]&&!baselinePath)return out.failure(Error("--update-baseline needs --baseline <file>")),1;if(values["update-baseline"]&&(values.changed||values.since))return out.failure(Error("--update-baseline takes every file's: drop --changed")),1;let baseline;if(baselinePath&&!values["update-baseline"])try{baseline=JSON.parse(readFileSync2(baselinePath,"utf-8"))}catch{return out.failure(Error(`No baseline at ${baselinePath}: write one with --update-baseline`)),1}let errorsOnly=values.threshold==="error",failOnWarnings=values["fail-on-warnings"],report=(result,watching)=>{if(result instanceof Error)return out.failure(result instanceof EmitError?Error(`${result.message}
+This is a svelte-typecheck bug; please report it.`):result),1;if(baselinePath&&values["update-baseline"]){let written=createBaseline2(result.diagnostics,result.workspace);return writeFileSync(baselinePath,`${JSON.stringify(written,null,2)}
+`),out.note(`Wrote ${result.diagnostics.length} diagnostics to ${baselinePath}`),0}let known=baseline?applyBaseline2(result.diagnostics,baseline,result.workspace):void 0,shown=known?known.diagnostics:result.diagnostics;out.start(result.workspace,watching&&!values.preserveWatchOutput);for(let d of shown)if(!errorsOnly||d.severity==="error")out.diagnostic(d,result.workspace);for(let f of result.failed)out.failure(Error(`${f.file}: failed to parse: ${f.message}`));let summary=summarize(shown,result.components);if(known?.known)out.note(`${known.known} more in the baseline, not shown`);if(known?.fixed)out.note(`${known.fixed} in the baseline are fixed: --update-baseline drops them`);if(result.skipped>0)out.note(`${result.skipped} more in files the changes don't reach, not shown`);return out.completion(summary,watching),summary.errors>0||result.failed.length>0||failOnWarnings&&summary.warnings>0?1:0};if(values.watch)return watch2(options,(result)=>report(result,!0)),new Promise(()=>{});try{return report(await typecheck2(options),!1)}catch(error){return report(error,!1)}}function formatOf(output){if(output&&OUTPUT_FORMATS.includes(output))return output;return process.env.CLAUDECODE==="1"?"machine":"human-verbose"}function parse(argv){return parseArgs({args:argv,options:{workspace:{type:"string"},output:{type:"string"},tsconfig:{type:"string"},"no-tsconfig":{type:"boolean",default:!1},ignore:{type:"string"},config:{type:"string"},"diagnostic-sources":{type:"string"},threshold:{type:"string"},"compiler-warnings":{type:"string"},"fail-on-warnings":{type:"boolean",default:!1},color:{type:"boolean",default:!1},"no-color":{type:"boolean",default:!1},tsgo:{type:"boolean",default:!1},incremental:{type:"boolean",default:!1},"no-incremental":{type:"boolean",default:!1},watch:{type:"boolean",default:!1},preserveWatchOutput:{type:"boolean",default:!1},"tsgo-experimental-api":{type:"boolean",default:!1},checker:{type:"string"},components:{type:"string",multiple:!0},"out-dir":{type:"string"},"no-declarations":{type:"boolean",default:!1},svelte:{type:"string"},changed:{type:"boolean",default:!1},baseline:{type:"string"},"update-baseline":{type:"boolean",default:!1},since:{type:"string"},help:{type:"boolean",short:"h",default:!1},version:{type:"boolean",short:"v",default:!1}}})}function parseCompilerWarnings(list){if(!list)return;let levels={};for(let entry of list.split(",")){let[code,level]=entry.trim().split(":");if(code&&(level==="ignore"||level==="error"))levels[code]=level}return levels}function colorFlag(on,off){if(on)return!0;if(off)return!1;return}process.exitCode=await main(process.argv.slice(2));

package/index.d.ts

@@ -0,0 +1,196 @@
+// The package's public API, as consumers see it: the build copies this file
+// as dist/index.d.ts, so it imports nothing and holds only declarations.
+// tests/api.test.ts fails when an implementation's signature drifts from
+// its declaration here.
+
+/** A type checker that reads a tsconfig and prints errors as `tsc` does. */
+export type Checker = "bun" | "tsrs" | "tsgo" | "tsc";
+
+export interface TypecheckOptions {
+  /** The project root the other paths resolve against. Default: `process.cwd()`. */
+  cwd?: string;
+  /** The project folder, relative to `cwd`. Default: `"."`. */
+  workspace?: string;
+  /**
+   * The tsconfig or jsconfig, relative to the workspace. With one, the
+   * components it includes are checked, and its TS and JS files' errors are
+   * reported too. Default: the nearest from the workspace up. `false`: none,
+   * so every component under the workspace, and only theirs.
+   */
+  tsconfig?: string | false;
+  /**
+   * With no tsconfig: paths to skip, relative to the workspace, as
+   * svelte-check's `--ignore` (a prefix, or `**` at the start or end).
+   */
+  ignore?: string[];
+  /** The svelte.config to read preprocessors from, relative to the workspace. Default: the nearest. */
+  config?: string;
+  /**
+   * Default: the project's own TypeScript (`tsc`; native in TypeScript 7),
+   * then the first of `tsgo`, `tsrs` and `bun` that's installed.
+   */
+  checker?: Checker;
+  /** Globs of the components to check, relative to the workspace, instead of the tsconfig's. */
+  components?: string[];
+  /** Where to write the generated code. Default: `node_modules/.cache/svelte-typecheck/<workspace>`. */
+  outDir?: string;
+  /**
+   * Whether an import of a checked component resolves to its generated
+   * code (the default). With `false`, it resolves to the component's own
+   * `.svelte.d.ts`, as a library's generated declarations are.
+   */
+  declarations?: boolean;
+  /** The Svelte package to check against. Default: `svelte`, resolved from `cwd`. */
+  svelte?: string;
+  /**
+   * What to report: `js` for type errors (in TS and JS), `svelte` for the
+   * compiler's warnings and errors. `css` is accepted, as svelte-check
+   * takes it, and reports nothing. Default: all.
+   */
+  diagnosticSources?: DiagnosticSource[];
+  /** `error` reports errors only. Default: `warning`. */
+  threshold?: "warning" | "error";
+  /** Compiler warnings to drop (`ignore`) or report as errors, by code. */
+  compilerWarnings?: Record<string, "ignore" | "error">;
+  /**
+   * Keep the generated code between runs: rewrite only what changed, and
+   * let `tsc`, tsgo and tsrs reuse their last run. Default `true`.
+   */
+  incremental?: boolean;
+  /**
+   * Report only these files' diagnostics, and those of the files that
+   * import them, relative to `cwd`. The whole program is still checked.
+   * `--changed` and `--since` pass git's changed files.
+   */
+  only?: string[];
+}
+
+/** A kind of check, as svelte-check's `--diagnostic-sources` names them. */
+export type DiagnosticSource = "js" | "svelte" | "css";
+
+/** An error or warning, at its line and column (both 1-based) in the source. */
+export interface Diagnostic {
+  /** An absolute path. */
+  file: string;
+  line: number;
+  column: number;
+  /** Where the range ends, when known. */
+  endLine?: number;
+  endColumn?: number;
+  severity: "error" | "warning";
+  /** `ts` or `js` for a type error (by the file's language), `svelte` for the compiler. */
+  source: "ts" | "js" | "svelte";
+  /** `TS2322`, or a compiler code such as `a11y_missing_attribute`. */
+  code: string;
+  message: string;
+}
+
+export interface TypecheckResult {
+  diagnostics: Diagnostic[];
+  /** The workspace, as an absolute path. */
+  workspace: string;
+  /** The tsconfig used, if any. */
+  tsconfig?: string;
+  /** How many components were checked. */
+  components: number;
+  /** Diagnostics left out by `only`. */
+  skipped: number;
+  /** Errors in generated code, which map to no source. */
+  dropped: Diagnostic[];
+  /** Components that failed to parse. */
+  failed: { file: string; message: string }[];
+  checker: Checker;
+  /** The checker's version, when its package says. */
+  checkerVersion?: string;
+  /** Milliseconds spent emitting, type-checking and compiling. */
+  timings: { emit: number; check: number; compile: number };
+}
+
+/** A warning or error the Svelte compiler reports for a component. */
+export interface CompilerDiagnostic {
+  severity: "error" | "warning";
+  code: string;
+  message: string;
+  line: number;
+  column: number;
+  endLine?: number;
+  endColumn?: number;
+}
+
+/**
+ * Diagnostics a project accepts for now, to report only new ones. Each is
+ * known by its file, code, message and the text of its line, not the
+ * line's number, so an edit above it doesn't make it new.
+ */
+export interface Baseline {
+  version: 1;
+  diagnostics: BaselineEntry[];
+}
+
+export interface BaselineEntry {
+  /** Relative to the workspace, `/`-separated. */
+  file: string;
+  code: string;
+  message: string;
+  /** The text of the diagnostic's line, trimmed. */
+  line: string;
+  /** How many such diagnostics there are. */
+  count: number;
+}
+
+/** What a baseline leaves of a run's diagnostics. */
+export interface BaselineResult {
+  /** The diagnostics the baseline doesn't have. */
+  diagnostics: Diagnostic[];
+  /** How many it has, and were left out. */
+  known: number;
+  /** How many it has that the run no longer reports. */
+  fixed: number;
+}
+
+/**
+ * Type-checks Svelte components, as svelte-check does: with a tsconfig
+ * (given, or the nearest from the workspace up), the components it
+ * includes, and its TS and JS files' errors too; with none, every component
+ * under the workspace. Each component becomes TypeScript under `outDir`,
+ * next to a tsconfig that extends the project's, a checker runs on it, and
+ * each error maps back to its `.svelte` line. Errors in generated code are
+ * dropped. Svelte's compiler reports its warnings in the same pass.
+ */
+export declare function typecheck(
+  options?: TypecheckOptions,
+): Promise<TypecheckResult>;
+
+/**
+ * Checks, then checks again whenever a component, TS or JS file, or a
+ * config under the workspace changes, as svelte-check `--watch` does. Runs
+ * are incremental. Returns a function that stops watching.
+ */
+export declare function watch(
+  options: TypecheckOptions,
+  onResult: (result: TypecheckResult | Error) => void,
+): () => void;
+
+/**
+ * What `svelte/compiler` reports for a component (a11y, unused CSS, invalid
+ * markup), without generating code. `<!-- svelte-ignore -->` applies, as in
+ * a build. A compile error comes back as one `error`.
+ */
+export declare function compilerDiagnostics(
+  source: string,
+  filename: string,
+  options?: { cwd?: string; svelte?: string },
+): CompilerDiagnostic[];
+
+/** A baseline of a run's diagnostics, sorted so it diffs well. */
+export declare function createBaseline(
+  diagnostics: Diagnostic[],
+  workspace: string,
+): Baseline;
+
+/** A run's diagnostics less the baseline's: what's new since it. */
+export declare function applyBaseline(
+  diagnostics: Diagnostic[],
+  baseline: Baseline,
+  workspace: string,
+): BaselineResult;

package/index.js

@@ -0,0 +1 @@
+import"./shared-58j2f7by.js";import{compilerDiagnostics2,typecheck2,watch2,createBaseline2,applyBaseline2}from"./shared-7zm6g9d3.js";export{applyBaseline2 as applyBaseline,compilerDiagnostics2 as compilerDiagnostics,createBaseline2 as createBaseline,typecheck2 as typecheck,watch2 as watch};

package/package.json

@@ -1,8 +1,40 @@
 {
   "name": "svelte-typecheck",
-  "version": "0.0.0",
-  "description": "Placeholder package reserving the \"svelte-typecheck\" name.",
+  "version": "0.1.1",
   "license": "MIT",
+  "description": "A drop-in svelte-check replacement that checks with tsc, tsgo, tsrs or bun check. Up to 11x faster, zero dependencies.",
   "author": "Eric Liu (https://github.com/metonym)",
-  "main": "index.ts"
+  "type": "module",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "svelte-typecheck": "cli.js"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=22"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/metonym/svelte-typecheck.git"
+  },
+  "homepage": "https://github.com/metonym/svelte-typecheck",
+  "bugs": "https://github.com/metonym/svelte-typecheck/issues",
+  "keywords": [
+    "svelte",
+    "typecheck",
+    "typescript",
+    "svelte-check",
+    "tsgo",
+    "tsrs",
+    "bun",
+    "ci"
+  ]
 }

package/shared-58j2f7by.js

@@ -0,0 +1,2 @@
+var version2="0.1.1",package_default={version:version2};
+export{version2,package_default};