gro 
security-first JS runtime and toolchain on V8 🌰 generate, run, optimize
⚠️ The TypeScript tool doesn't support Windows because its spawn host module runs only ELF, Mach-O, and
#!programs, not a Windows.exe,.bat, or.cmd; the Rust runtime will.
Today, Gro is a task runner and toolkit extending SvelteKit and Vite for making web frontends and libraries with TypeScript. It runs on Node and is a dev tool, not for production use.
Gro is also becoming its own JS runtime,
a Rust binary on V8 with granular control over what your dependencies and agents can reach.
As designed, a run is confined by default: code reaches only what its imports declare,
reads of the project's own files without asking, and the network, processes, and anything outside the project
only once accepted in a small policy file you review like a lockfile,
so changing capabilities is a diff, and the runtime is designed to enforce it.
A hermetic run is also confined but strictly deterministic, with its clock and randomness fixed or denied,
so it's designed to replay and cache;
an unconfined run (-A) is the escape hatch when you need it.
The runtime grew out of the loader Gro already uses to run tasks, config, and codegen,
and makes a clean break from Node toward web standards.
Its model, authority by import with nothing ambient, is why it's a new runtime and not Deno with other defaults.
It's an in-progress design, and of the confinement only fgro eval's kernel box is built so far.
The experimental build runs modules with no API to the OS (no fs, network, env, or spawn), though fgro run's process itself isn't sandboxed yet - see
the runtime docs for why it exists, the model in a page, the design, and the roadmap,
and feedback is invited in discussions.
The Node tool includes:
- a task runner that runs its builtin tasks by name
and a project's
*.task.tsmodules by path, composed in plain TypeScript - dev, build, test,
deploy, and publish workflows
for SvelteKit apps and library packages,
deferring to SvelteKit and Vite for the frontend and
@sveltejs/packagefor the library - a Node loader with a register hook
that runs TypeScript, JSON, and SSR'd Svelte files directly (
gro run a.ts), with best-effort shims for SvelteKit's$appmodules in tasks and tests - plugins for SvelteKit
and other build processes, configured in an optional
gro.config.ts(see the default config,fuz_templatefor a simple starter, andfuz_reposfor custom tasks) - codegen by convention with
gen - testing with
vitest, linting with ESLint (I also maintain@ryanatkn/eslint-config), and formatting withtsv - its modules exported from
src/lib, except those underinternal/, and Changesets for versioning and changelogs
Docs
- developing web frontends and libraries
Taskrunner- builtin tasks list
- testing with
vitest gencode generation- the experimental runtime, what
fgro runandfgro evaldo today, its security model and the kernel backstop under it, how it resolves modules and strips types, and how it compares to Node, Deno, and Bun - full docs index
Install
depends on node >=24.14
Typical usage installs @fuzdev/gro as a dev dependency:
npm i -D @fuzdev/gro
npx @fuzdev/gro # note the package is namespaced, don't install `gro`
It's handy to install globally too:
npm i -g @fuzdev/gro
gro
Usage
Gro has a task runner that runs TypeScript modules with the .task. subextension
in-process with explicit composition.
Builtins run by name and project tasks by path.
Running gro with no args prints the builtins and usage:
gro # prints the builtins - defers to any local gro installation
builtin tasks:
build build the project
changeset call changeset with gro patterns
check check that everything is ready to commit
clean remove build files, and optionally prune git branches
commit commit and push to a new branch
deploy deploy to a branch
dev start SvelteKit and other dev plugins
format format source files
gen run code generation scripts
lint run eslint
publish bump version, publish to the configured registry, and git push
reinstall refreshes package-lock.json with the latest and cleanest deps
release publish and deploy
run execute a file with the loader, like `node` but works for TypeScript
sync optionally install packages, sync SvelteKit, update `package.json`, and run `gro gen`
test run tests with vitest
typecheck run svelte-check or tsc on the project without emitting any files
upgrade upgrade deps
Run a builtin: gro [name]
View its help: gro [name] --help
Run a project task: gro task [path/to/file.task.ts]
List project tasks: gro task [dir], defaults to src/
A name always means a builtin, so a project task never shadows one, and a path names exactly one task file, with nothing searched for:
gro check # runs the builtin `check`
gro check --help # displays docs for the task and its args, works for every task
gro task # lists the project's tasks under `src/`
gro task src/lib/some/ # lists the tasks under `src/lib/some/`
gro task src/lib/some/file.task.ts # runs that task file
Gro can also run non-task TypeScript files directly
with the gro run task or register hook:
gro run foo.ts --any args # everything after the path goes to the script verbatim
node --import @fuzdev/gro/register.js foo.ts
Or programmatically:
// myfile.js
import { register } from "node:module";
register("@fuzdev/gro/loader.ts", import.meta.url);
await import("./foo.ts");
Gro has a number of builtin tasks that you can run with the CLI. To learn more see the task docs and the generated task index.
gro dev # start developing in watch mode
gro dev -- vite --port 3003 # forward args by separating sections with --
gro build # build everything for production
Testing with vitest,
including shims for SvelteKit modules:
gro test # run all tests for `*.test.ts` files with `vitest`
gro test filepattern1 some.test another.test
gro test optional_pattern -t "optional search string for test name"
gro test -- --forwarded_args 'to vitest' # verbatim, also `-- vitest --forwarded_args`
Check all the things:
gro check # does all of the following:
gro typecheck # svelte-check with tsc fallback
gro test # run tests
gro gen --check # ensure generated files are current
gro format --check # ensure everything is formatted
gro lint # eslint
For a usage example see the check.yml CI config.
Formatting with tsv:
gro format # format all of the source files using tsv
gro format --check # check that all source files are formatted
Codegen with gen:
gro gen # run codegen for all `*.gen.*` files
gro gen --check # error if any generated files are new or different
To deploy: (also see src/docs/deploy.md)
gro deploy # build and push to the `deploy` branch
To publish: (also see src/docs/publish.md)
gro publish # flush changeset to changelog, bump version, publish to npm, and git push
More:
gro clean # delete all build artifacts from the filesystem
gro clean --sveltekit --nodemodules --git # also deletes dirs and prunes git branches
gro upgrade excluded-dep-1 excluded-dep-2 # npm updates to the latest everything
gro --version # print the Gro version
For more see the tasks index, the task feature docs, and the docs index.
Develop
npm i
npm run bootstrap # build and link `gro` without itself - needed only once
gro build # rebuilds `dist/`, which the linked `gro` CLI runs
gro test # make sure everything looks good - same as `npm test`
gro test some.test another.test
# use your development version of `gro` locally in another project:
npm link -f # points the global `gro` at this checkout, once - `npm run bootstrap` does this too
cd ../otherproject
npm link ../gro # from `otherproject/`
gro build # from `../gro` on changes
The Rust runtime in crates/ (docs) builds on x86_64 Linux.
Run cargo xtask fetch-v8 before any plain cargo command, since every build links
the pinned V8 archive it downloads and verifies.
cargo xtask build --release builds fgro with its startup snapshot,
target/gro_snapshot/release/fgro run file.ts runs a module,
and cargo xtask check runs every gate, the Rust and JS halves together.
Credits 🐢🐢🐢
Gro builds on TypeScript ∙ Svelte ∙ SvelteKit ∙ Vite ∙ Vitest ∙ chokidar ∙ @fuzdev/fuz_util ∙ @fuzdev/fuz_schema ∙ ESLint ∙ tsv ∙ svelte-check & more