@cognitap/radiant 0.0.1 → 0.0.2

package/CHANGELOG.md

@@ -4,20 +4,13 @@ See the [release policy](RELEASE_POLICY.md) for versioning and migration rules.
 
 ## Unreleased
 
+## 0.0.2
+
+- Documentation and maintainer tooling cleanup. The Button API, styles and
+  dependency requirements are unchanged; no migration is needed.
+- Still experimental, with a single native Button. Automated package checks do
+  not replace manual keyboard, focus and screen reader verification.
+
 ## 0.0.1
 
-- Compiled `styles.css` for consumers without Tailwind, an optional compiled
-  `reset.css` and a source `tailwind.css` customization entry. Tailwind is now
-  an optional peer dependency.
-- Button inherits application fonts and sets its own box sizing and border
-  style, so its default appearance does not require a global reset.
-- Migration for Tailwind consumers: replace the old source `styles.css` import
-  with `tailwind.css` alongside your own Tailwind entry. Ordinary consumers
-  retain the `styles.css` import. Choose one route to avoid duplicate utilities;
-  import `reset.css` separately if you want Preflight.
-- Public source under MIT, with the copyright notice naming Zoltán Cserei and
-  a documented maintainer workflow and public bug/accessibility reporting.
-- Initial experimental Button with ESM JavaScript, TypeScript declarations and
-  source maps.
-- Public package identity, release policy and publishing metadata prepared for
-  the first `0.0.1` release.
+- Public package identity for the first, `0.0.1` release. Do not expect granular updates until package is mature enough to be used by third parties.

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Zoltán Cserei
+Copyright (c) 2026 Cserei Zoltán
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,146 +1,21 @@
 # Radiant
 
-Reusable React interaction components and presentation primitives, maintained in
-this standalone repository.
+React interaction components and presentation primitives, published as
+[`@cognitap/radiant`](https://www.npmjs.com/package/@cognitap/radiant) under the
+[MIT license](LICENSE). Radiant is experimental: `0.0.2` contains a single native
+Button.
 
-Radiant's source is available under the [MIT license](LICENSE). The library is
-experimental: version `0.0.1` is a native Button proof of concept. The build
-includes standalone component CSS, a separate optional reset and a Tailwind
-customization entry.
-See the
-[release policy](RELEASE_POLICY.md) for identity, compatibility, support and
-publication requirements, and the [changelog](CHANGELOG.md) for release changes.
-
-Install the experimental package in a React application:
-
-```sh
-pnpm add --save-exact @cognitap/radiant@0.0.1
-```
-
-Import `@cognitap/radiant/styles.css` once; see [Button](#button) for usage.
-
-## Getting started
-
-Use the Node version in `.nvmrc` and the pnpm version in `package.json`:
-
-```sh
-nvm install
-nvm use
-npm install --global "$(node -p 'require("./package.json").packageManager')"
-pnpm install --frozen-lockfile
-pnpm storybook
-```
-
-Open [Storybook](http://localhost:6006) for the primary component development
-loop. No Cognitap checkout or private configuration is required.
-
-| Command                                     | Purpose                                                      |
-| ------------------------------------------- | ------------------------------------------------------------ |
-| `pnpm storybook`                            | Edit components in the local workshop                        |
-| `pnpm build`                                | Build library JavaScript, declarations, maps and CSS         |
-| `pnpm watch`                                | Watch JavaScript, declarations and compiled component styles |
-| `pnpm build:storybook`                      | Build the separate static workshop                           |
-| `pnpm typecheck`                            | Check source and Storybook types                             |
-| `pnpm test`                                 | Verify builds and an independently installed archive         |
-| `pnpm test:package`                         | Build, pack and verify an isolated installed package         |
-| `pnpm lint`                                 | Check correctness and accessibility lint rules               |
-| `pnpm fmt`                                  | Format repository files                                      |
-| `pnpm fmt:check`                            | Check formatting                                             |
-| `pnpm check`                                | Run all checks, including the Storybook build                |
-| `pnpm release:prepare`                      | Pack and verify a release candidate; dry-run publication     |
-| `pnpm pack --pack-destination dist/package` | Create a package archive locally                             |
-
-CI installs the pinned dependencies with the committed lockfile and runs
-`pnpm check` and package creation. Installing dependencies registers the
-pre-commit hook, which formats staged files. See
-[CONTRIBUTING.md](CONTRIBUTING.md) for the maintainer workflow.
-
-Releases are independent of Cognitap; see the
-[release workflow](RELEASE_POLICY.md#release-workflow).
-
-## Library build
-
-From the repository root:
+## Usage
 
 ```sh
-pnpm build
+pnpm add --save-exact @cognitap/radiant@0.0.2
 ```
 
-The build removes `dist/library`, compiles JavaScript and declarations with
-`tsc`, and compiles the two stylesheets with the Tailwind CLI. These are
-development tools; ordinary consumers need only React and the packaged CSS.
-
-TypeScript emits separate ES2022 ESM modules, `.d.ts` declarations, JavaScript
-maps with embedded source, and declaration maps into `dist/library`. Keeping
-modules separate preserves `use client` directives and external runtime imports:
-React is a peer dependency and `cn` is a runtime dependency. Relative source
-imports use `.js` extensions so emitted JavaScript and declarations work in Node
-and bundlers, following [TypeScript's library guidance](https://www.typescriptlang.org/docs/handbook/modules/guides/choosing-compiler-options#im-writing-a-library).
-
-The package root and three stylesheet entries are public exports. JavaScript,
-types, component styles and the reset resolve to compiled artifacts. Sources ship for editor
-navigation through declaration maps; stories, tests and Storybook output stay
-out of the archive. Rebuilding cleans only `dist/library`.
-
-JavaScript modules must remain free of import-time side effects. Bundlers can
-discard unused modules; CSS is explicitly marked as having side effects so
-stylesheet imports are retained. Browser interactions belong in the component's
-lifecycle, and client-dependent modules need their own `use client` directive.
-
-`pnpm test` builds the library, checks the Tailwind customization route locally,
-and verifies the public package through an isolated installation.
-
-### Installed archive verification
-
-`pnpm test:package` builds Radiant, packs it into a temporary directory and
-installs the archive there with npm. The small `tests/consumer` fixture owns
-the public import/SSR, CSS, map, metadata and React-peer checks, plus independent
-NodeNext and bundler declaration checks. It uses the repository's pinned React
-and TypeScript versions, with no Tailwind or source aliases. Public package
-checks run once, against installed artifacts. The directory and archive are
-removed after success or failure.
-
-`pnpm test` and `pnpm check` include this verification; npm and registry access
-are required. Use `node scripts/verify-package.mjs /absolute/path/to/candidate.tgz`
-to verify an existing release candidate without rebuilding or repacking it.
-Browser interaction/hydration evidence and registry publication remain separate.
-
-Storybook reads component source directly for rapid editing. `pnpm watch` uses
-TypeScript and Tailwind's native watchers to update JavaScript, declarations and
-the compiled component stylesheet. Run `pnpm build` first when using the watcher
-on its own. The initial build also generates the optional reset; rerun
-`pnpm build:css` after editing `styles/reset.css`. The watcher does not start Storybook.
-
-For live integration, install dependencies in this checkout and Cognitap once,
-then run `pnpm dev` from Cognitap. It automatically selects a sibling `../radiant`
-checkout when present; `pnpm dev /path/to/radiant` selects another location, and
-`pnpm dev --installed` selects the installed dependency explicitly. Without a
-sibling checkout, development uses the installed dependency.
-
-Cognitap builds the selected package, then starts its watchers and Storybook,
-both frontend apps and Trantor together through Nx. The frontend processes resolve
-this checkout's public exports through temporary aliases. The apps consume
-compiled JavaScript and the documented Tailwind entry. Local Next.js development
-uses Webpack for external package watching; ordinary development keeps Turbopack.
-`Ctrl+C` stops the session.
-Installed dependencies, manifests and lockfiles stay unchanged; ordinary Cognitap
-checks and builds use its installed dependency even during a local session.
-
-Run `pnpm dev --typecheck [checkout-path]` from Cognitap to refresh JavaScript,
-declarations and maps with the `build:js` helper and check both apps against the
-public declarations. The helper preserves the output directory and compiled
-stylesheets during a watch session. Local commands select temporary type
-configurations; editors normally read the ordinary app configurations, so use
-this command to validate new public types. See
-[Cognitap's development guide](https://github.com/cognitap/cognitap#live-radiant-development)
-for the full workflow and Trantor setup.
-
-Independent Storybook development needs no Cognitap checkout. Live integration
-complements installed-archive and registry verification; it does not replace them.
-
-## Button
+Import the stylesheet once in your application. It needs no Tailwind and only
+styles Radiant components:
 
 ```tsx
+import '@cognitap/radiant/styles.css'
 import { Button } from '@cognitap/radiant'
 
 <Button onClick={handleContinue}>Continue</Button>
@@ -148,128 +23,85 @@ import { Button } from '@cognitap/radiant'
 <Button type="submit">Save</Button>
 ```
 
-`Button` accepts native React button props (`ButtonProps`), including `ref`,
-`className`, `aria-*`, and form attributes. It defaults to `type="button"` to
-avoid accidental form submission. Import its stylesheet once in your application:
+For a global reset (Tailwind Preflight), also import `@cognitap/radiant/reset.css`
+before `styles.css`. React 19.3+ is a peer dependency.
 
-```tsx
-import '@cognitap/radiant/styles.css'
-```
-
-This route needs no Tailwind installation or CSS compiler. Components do not
-import CSS themselves. The stylesheet contains component utilities and tokens;
-it does not reset headings, body margins or unrelated native controls. Button
-sets its own border style and box sizing and inherits the application's font.
-
-The optional reset is a separate, application-wide choice:
-
-```tsx
-import '@cognitap/radiant/reset.css'
-import '@cognitap/radiant/styles.css'
-```
-
-`reset.css` contains Tailwind Preflight, compiled and self-contained. It changes
-global element defaults; importing it is not required for Radiant components.
+`Button` takes native button props, including `ref`, `aria-*` and form attributes,
+and defaults to `type="button"`. Give every button an accessible name through its
+text or `aria-label`, and use a link for navigation. There are no variants, sizes,
+or loading state yet.
 
-Native button semantics provide keyboard activation and disabled behavior. Give
-every button an accessible name through its text or `aria-label`. Focus indicators
-and forced-colors borders are included. Use a link for navigation.
+Components use semantic tokens such as `bg-primary` and `rounded-control`.
+Override their CSS variables to theme an application or a subtree; the defaults
+are a light theme. Unlayered application CSS takes precedence over Radiant's
+styles.
 
-This PoC has one visual treatment, with no variants, sizes, loading state, or
-polymorphic rendering. The consumer owns actions and state. React 19.3+ is a peer
-dependency.
+### With Tailwind
 
-## Tailwind customization
-
-For an application with Tailwind 4.3.3+, use the source customization entry
-instead of the compiled component sheet. It provides the semantic theme and
-registers Radiant's shipped component sources for scanning; your application
-generates the utilities once with its own Tailwind integration:
+Applications on Tailwind 4.3.3+ can import the source entry instead of
+`styles.css`, so their own build generates Radiant's utilities. Use one route,
+not both, or the utilities are duplicated:
 
 ```css
 @import 'tailwindcss';
 @import '@cognitap/radiant/tailwind.css';
 ```
 
-The application's `tailwindcss` import includes Preflight. To keep the reset
-disabled, use [Tailwind's separate imports](https://tailwindcss.com/docs/preflight#disabling-preflight):
-
-```css
-@layer theme, base, components, utilities;
-@import 'tailwindcss/theme.css' layer(theme);
-@import 'tailwindcss/utilities.css' layer(utilities);
-@import '@cognitap/radiant/tailwind.css';
-```
-
-Choose one component-style route: compiled `styles.css` or generated
-`tailwind.css`. Combining them duplicates the component utilities. The source
-entry does not import Tailwind or generate a second utility sheet. Its `@source`
-is relative to the installed source entry, so library scanning works inside
-`node_modules`; stories and tests are excluded. Application scanning belongs to
-your Tailwind setup. Configure its source base or add an application-relative
-`@source` when automatic scanning does not cover your files. See
-[Tailwind's source detection guide](https://tailwindcss.com/docs/detecting-classes-in-source-files).
+To skip Preflight, replace `@import 'tailwindcss'` with
+[Tailwind's separate imports](https://tailwindcss.com/docs/preflight#disabling-preflight).
+Utilities passed in `className` replace matching defaults, including `hover:` and
+`disabled:` variants: `<Button className="rounded-full hover:bg-red-500">`.
 
-Tokens provide background, foreground, border, primary action states and foreground,
-disabled background and foreground, focus color, and control radius. Components
-use semantic utilities such as `bg-primary`, `text-primary-foreground`, and
-`rounded-control`. Override the corresponding CSS variables to theme an application
-or a subtree; these defaults currently define a light theme.
+## Development
 
-`src/cn.ts` registers the semantic control radius with `cn` so it participates in
-class conflict resolution. Components merge classes with this helper, passing the
-caller's `className` last so matching utilities override defaults. In a Tailwind app, for example,
-`<Button className="rounded-full px-8 hover:bg-red-500">Continue</Button>` replaces
-the default corner radius, horizontal padding, and hover color. Disabled
-overrides use the same prefix, such as `disabled:bg-slate-300`. The compiled
-sheet only includes utilities used by library components; arbitrary caller
-utilities need your own generated CSS. Without Tailwind, use ordinary CSS
-classes or override the semantic variables. Unlayered application CSS takes
-precedence over Radiant's layered utilities.
-
-## Storybook
-
-Storybook uses React and Vite and lives in this package. From the repository root:
+Use the Node.js version in `.nvmrc`. Any recent pnpm switches itself to the version
+pinned in `package.json`:
 
 ```sh
+nvm install && nvm use
+npm install --global pnpm
+pnpm install --frozen-lockfile
 pnpm storybook
 ```
 
-Open http://localhost:6006. The server binds to localhost.
-
-Build a static site:
-
-```sh
-pnpm build:storybook
-```
-
-Output goes to `dist/storybook`, separate from the library build.
-`pnpm check` validates both the library and the static workshop. Each build
-preserves the other's output.
-
-### Accessibility checks
-
-Start Storybook, open a story under **Components → Button** (including **Disabled**),
-and select the **Accessibility** panel. The official `@storybook/addon-a11y` addon
-runs axe-core checks automatically for each story, including new stories. Use
-**Rerun accessibility scan** after changing controls to check the updated state.
-
-Review **Violations** for detected issues, **Passes** for successful checks, and
-**Inconclusive** for checks that need human judgment. Expand a result to see the
-rule, affected elements, and guidance; highlighting elements helps locate them
-in the canvas. A disabled button may be exempt from checks such as color contrast.
-
-Automated checks cover only part of WCAG. A clean result does not establish WCAG
-conformance: manually review keyboard navigation, focus visibility, screen reader
-behavior, and interaction states in the consuming application as well.
-See [Storybook's accessibility testing guide](https://storybook.js.org/docs/writing-tests/accessibility-testing).
-
-## Adding stories
-
-Add `*.stories.tsx` beside a component in `src/`. Import `Meta` and `StoryObj`
-from `@storybook/react-vite`, define metadata with `satisfies Meta<typeof Component>`,
-and export a `StoryObj<typeof meta>` for each supported state. Preview configuration
-enables generated documentation globally. Use `fn()` from `storybook/test` for
-callback args, so interactions appear in the Actions panel.
-
-`src/Button.stories.tsx` demonstrates the real Button in enabled and disabled states.
+Storybook runs at [localhost:6006](http://localhost:6006) and needs no Cognitap
+checkout.
+
+| Command                | Purpose                                                         |
+| ---------------------- | --------------------------------------------------------------- |
+| `pnpm storybook`       | Develop components in Storybook.                                |
+| `pnpm build`           | Build JavaScript, declarations, and CSS into `dist/library`.    |
+| `pnpm watch`           | Rebuild on change, except `reset.css` (run `pnpm build` first). |
+| `pnpm build:storybook` | Build static Storybook into `dist/storybook`.                   |
+| `pnpm lint`            | Run Oxlint, including accessibility rules.                      |
+| `pnpm format`          | Format with Oxfmt (`format:check` to check only).               |
+| `pnpm typecheck`       | Check TypeScript.                                               |
+| `pnpm test`            | Run style tests and verify the packed, installed package.       |
+| `pnpm test:package`    | Verify the packed, installed package only.                      |
+| `pnpm check`           | Run formatting, lint, types, tests, and builds, as CI does.     |
+| `pnpm release:prepare` | Pack and verify a release candidate, then dry-run publishing.   |
+
+Package verification installs the archive with npm, so it needs network access.
+A Husky pre-commit hook formats staged files with Oxfmt.
+[CI](.github/workflows/ci.yml) runs `pnpm check`.
+
+Modules must stay free of import-time side effects, and client-dependent modules
+need their own `use client` directive. Add `*.stories.tsx` next to each component,
+like `src/Button.stories.tsx`. Storybook's Accessibility panel runs axe checks on
+every story, but automated checks cover only part of WCAG, so still test keyboard,
+focus, and screen reader behavior by hand.
+
+## Live development in Cognitap
+
+With this checkout at `../radiant` and its dependencies installed, `pnpm dev` in
+Cognitap builds and watches it, points both apps at it, and starts this Storybook.
+Cognitap's installed package, manifests, and lockfile stay untouched. See
+[Cognitap's guide](https://github.com/cognitap/cognitap#live-radiant-development)
+for other checkouts and type checking.
+
+## Further reading
+
+- [Release policy](RELEASE_POLICY.md): versioning, compatibility, and the release workflow
+- [Changelog](CHANGELOG.md): consumer-facing changes per release
+- [CONTRIBUTING.md](CONTRIBUTING.md): maintainer workflow and bug reports
+- [AGENTS.md](AGENTS.md): component and styling conventions

package/RELEASE_POLICY.md

@@ -1,113 +1,41 @@
 # Radiant release policy
 
-Confirmed in DEV-84 on 13 October 2026. Radiant releases independently of Cognitap
-deployments; the owner and trusted maintainers control development and merges.
-
-## Identity and licensing
-
-This repository is the authoritative Radiant source. Its selected GitHub identity
-is `cognitap/radiant`; the npm package is `@cognitap/radiant`.
-
-The source is licensed under MIT. [LICENSE](LICENSE) contains the complete text
-and names Zoltán Cserei as the copyright holder. Corporate formation is not a
-prerequisite for source opening or npm publication. This decision supersedes
-DEV-84's initial incorporation gate.
-
-Keep `private: true` in the package manifest until npm publication prerequisites
-pass. This prevents package publication while public source development proceeds.
+Radiant releases independently of Cognitap deployments.
 
 ## Versions
 
-Start with ordinary `0.0.1` and publish experimental `0.x` releases under
-`latest`. Make experimental status clear in the README and release notes.
-The first stable release is `1.0.0`, after the complete 31-family catalog,
-documentation and agreed accessibility and compatibility verification pass.
+Releases follow [SemVer](https://semver.org/). `0.x` releases are experimental
+and publish under `latest`; say so in the README and release notes. `1.0.0`
+follows once the full catalog, its documentation, and accessibility
+and compatibility verification are complete.
 
-| Change                                              | During `0.x` | From `1.0.0` |
-| --------------------------------------------------- | ------------ | ------------ |
-| Compatible correction                               | Patch        | Patch        |
-| Compatible addition, cosmetic change or deprecation | Minor        | Minor        |
-| Breaking change                                     | Minor        | Major        |
+Use the largest applicable bump. A fix that requires consumers to adapt is
+breaking, even for accessibility or security. Published versions are immutable.
+Prereleases use a version suffix and their own npm tag, never `latest`.
 
-Use the largest applicable bump. A correction that requires consumers to adapt
-is breaking, including accessibility or security corrections. Pure internal
-changes can use a patch when they preserve the public contract. Published
-versions are immutable; follow-up fixes receive a new version.
+## Public contract
 
-Future previews can use prerelease suffixes and separate tags without replacing
-the ordinary release under `latest`. Version numbers follow
-[SemVer](https://semver.org/); [npm tags](https://docs.npmjs.com/cli/v11/commands/npm-dist-tag/)
-select distribution channels independently.
+The contract covers documented props and types, package exports, behavior,
+semantic tokens, named parts, state attributes and functional CSS requirements.
+Breaking changes include incompatible changes to any of these, sizing or layout
+changes consumers must adapt to, raised peer dependency ranges and narrowed
+environment support.
 
-## Compatibility and consumer requirements
+## Support
 
-The public contract includes documented props and types, exports, behavior,
-semantic tokens, named parts, state attributes and functional CSS requirements.
-Incompatible changes to these, or sizing/layout changes requiring consumer
-adaptation, are breaking.
-
-Raising consumer dependency requirements or narrowing the declared environment
-support policy is also breaking. Versions aging out of an unchanged rolling
-browser or OS support target do not themselves require a breaking release.
-Record tested combinations separately from support targets.
-
-Generated utility strings and foundation internals remain private. Package
-exports define the supported import surface; shipping source for editor
-navigation does not make internal imports supported.
-
-React remains a peer dependency. Keep the current range initially; changes need
-installed-package verification. The [package manifest](package.json) declares
-current peer ranges and runtime dependencies. Contributor Node, pnpm and
-TypeScript pins belong to development configuration and do not establish
-consumer runtime or declaration requirements.
-
-Ordinary consumers use compiled `styles.css` without Tailwind. The optional
-`reset.css` is a separate, global opt-in; importing components loads neither
-stylesheet automatically. Tailwind belongs to the optional `tailwind.css`
-customization route, which registers the library theme and sources for the
-application's own CSS generation. Choose one component stylesheet route.
-
-Cognitap pins exact published versions after its migration. Optional local
-development watches this package's public build and selects its exports through
-process-only aliases. The apps use compiled JavaScript/types and the supported
-Tailwind entry. Installed dependencies stay unchanged, so stopping needs no
-restore step. Normal consumption after migration requires
-only the published package. Local updates complement archive and registry
-verification and do not replace publication readiness checks.
-
-## Support and upgrades
-
-Maintain the current stable major through its latest minor and patch releases.
-Before `1.0.0`, fixes land in the latest experimental release. There is no
-standing commitment to older release branches or response deadlines.
-
-Every published version has a changelog entry describing its consumer-facing
-changes and relevant verification limits. Identify breaking changes and include
-actionable migration instructions. After `1.0.0`, normally deprecate in a minor
-before removal in a major, without a fixed waiting period. During `0.x`, direct
-removal is allowed with migration guidance.
-
-## Publication readiness
-
-Public source opening requires the finalized MIT notice, repository control and
-verified standalone tooling. Initial npm publication additionally
-requires scope permissions, compiled CSS, verified installed archives and an
-independent release workflow.
-
-Archives include the public build, stylesheet, editor-navigation sources, README,
-LICENSE, changelog and this policy; exclude tests, stories and Storybook output.
-The manifest's allowlist and exports define what ships and what is public.
-
-The selected publishing configuration uses public npm access and `latest`.
-Keep publication disabled until its prerequisites pass. Neither public source
-nor an experimental package establishes stable catalog readiness or conformance
-for an entire consumer application.
+Only the latest release is maintained: the latest `0.x` before `1.0.0`, then the
+current major. There are no backports or response deadlines.
+
+Every published version gets a changelog entry covering consumer-facing changes
+and known verification gaps. Mark breaking changes and include migration steps.
+From `1.0.0`, deprecate in a minor before removing in a major; during `0.x`,
+direct removal is allowed.
 
 ## Release workflow
 
 Releases use native pnpm versioning and reviewed changelog notes. In a pull
 request, run `pnpm version patch --no-git-tag-version` (or `minor`, following
-the table above), move the applicable Unreleased notes under a `## <version>`
+the rules above), move the applicable Unreleased notes under a `## <version>`
 heading in `CHANGELOG.md` and commit both. The first release keeps `0.0.1`.
 
 From a clean checkout, `pnpm release:prepare` checks the version and notes,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cognitap/radiant",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "React interaction components and presentation primitives",
   "homepage": "https://github.com/cognitap/radiant#readme",
   "bugs": {
@@ -93,9 +93,9 @@
     "test:package": "pnpm build && node scripts/verify-package.mjs",
     "typecheck": "tsc --noEmit",
     "lint": "oxlint --deny-warnings",
-    "fmt": "oxfmt",
-    "fmt:check": "oxfmt --check",
-    "check": "pnpm fmt:check && pnpm lint && pnpm typecheck && pnpm test && pnpm build:storybook",
+    "format": "oxfmt",
+    "format:check": "oxfmt --check",
+    "check": "pnpm format:check && pnpm lint && pnpm typecheck && pnpm test && pnpm build:storybook",
     "release:prepare": "node scripts/prepare-release.mjs"
   }
 }