The package manager that shows its work.

Tapid is a JavaScript and TypeScript package manager written in Rust. It makes package identity, install evidence, and execution boundaries visible instead of leaving them implicit.

Read the current pathInspect the CLI
tapid / command surfacecurrent CLI

$ tapid install is-char

error: package argument not implemented

The intended package-facing command. Resolution is the next implementation gap.

verified project behavior

manifestpackage.json validated
lockfileoffline replay implemented
scriptsexplicit root execution
No fabricated install result. The current evidence is a project replay, not package resolution.
built inRust
forJS + TS
next boundaryresolution

The useful part is not the promise. It is the receipt.

Tapid's current install path validates the project before it activates managed output. The result is narrow, explicit, and inspectable.

Understand package identity ↗

The current fixture run produced a verified empty project replay. It proves the activation and lifecycle boundary, but it does not prove package installation.

manifest
rootManifestDigest matches package.json

lockfile
lockfileVersion 3 accepted for replay

store
verified trees available before staging

lifecycle
dependency scripts suppressed during install

fixture-backed behavior, not a package install demo

Read the evidence model

A command is only useful when you know what it guarantees.

The current implementation is deliberately small. That makes its evidence easier to inspect and its limits easier to state.

Start with the working fixture ↗

$tapid install is-char
→This is the package command developers should be able to use. The current CLI still rejects the positional package name, so this is marked as planned.
→The install engine already exists behind the current project and fixture path. Package resolution is the missing piece between this command and a real install.

Start with the projects developers already have.

Tapid's next work is not a promise of a finished ecosystem. It is a sequence of implementation problems: make the current client useful, make artifact decisions inspectable, then build the registry and publishing model that can support them.

See current statusInspect the CLI repository ↗