@ghostry/fabricator 0.0.1 → 0.0.2

package/dist/types/index.d.ts

@@ -1,5 +1,5 @@
 import type { Limits } from "./Enumeration/Types";
-import type { Instance } from "./Instance/Types";
+import type { Instance, Stack } from "./Instance/Types";
 import type { Algorithm, Attribution, Seed } from "./Random/Types";
 import { registry } from "./Schema/Registry";
 import type { PlainObject } from "./Utility/Types";
@@ -7,180 +7,182 @@ export declare function initialize<const $Registry extends PlainObject = typeof
     /** The registry of type definers to use — `registry` itself. */
     types: $Registry;
     /**
-     * Optional mixer composed into every stream beside `clock`. Accepts
-     * a single string, or several — several lets a seed be composed out
-     * of independent, meaningful parts (a user id, a scenario label)
-     * without hand-joining them first. If omitted, the seed is empty
-     * (unless `FABRICATOR_SEED` / `SEED` / `RANDOM_SEED` supplies one):
-     * wall-clock `clock` is the default entropy, so an unconfigured
-     * instance varies by run and replays from `context.clock` alone.
-     * Pass a seed when two instances should share a clock but draw
-     * different universes, or when `clock: "seeded"` should make the
-     * seed itself the reproducibility unit.
+     * Optional mixer composed into every stream beside `clock`. Accepts a
+     * single string, or several — several lets a seed be composed out of
+     * independent, meaningful parts (a user id, a scenario label) without
+     * hand-joining them first. If omitted, the seed is empty (unless
+     * `FABRICATOR_SEED` / `SEED` / `RANDOM_SEED` supplies one): wall-clock
+     * `clock` is the default entropy, so an unconfigured instance varies by run
+     * and replays from `context.clock` alone. Pass a seed when two instances
+     * should share a clock but draw different universes, or when `clock:
+     * "seeded"` should make the seed itself the reproducibility unit.
      */
     seed?: Seed;
     /**
-     * Bring your own PRNG: a factory that, given a seed, returns a
-     * source of randomness — a `() => number` in `[0, 1)`, a drop-in
-     * for `Math.random`. Defaults to the built-in `sfc32` generator.
+     * Bring your own PRNG: a factory that, given a seed, returns a source of
+     * randomness — a `() => number` in `[0, 1)`, a drop-in for `Math.random`.
+     * Defaults to the built-in `sfc32` generator.
      */
     algorithm?: Algorithm;
     /**
-     * How this instance attributes a construction's randomness to the
-     * file it was written in:
+     * How this instance attributes a construction's randomness to the file it
+     * was written in:
      *
-     * - `{ kind: "rooted", root }` expresses every file relative to
-     *   `root` (an absolute path or a `file://` URL), so the same seed
-     *   reproduces the same data on a checkout at a different absolute
-     *   path.
-     * - `{ kind: "call site" }`, the default, is `"rooted"` at the
-     *   directory of whichever file called `initialize()`.
-     * - `{ kind: "none" }` attributes nothing: every construction of a
-     *   given kind anywhere in the instance shares one stream, keyed
-     *   by kind alone.
+     * - `{ kind: "rooted", root }` expresses every file relative to `root` (an
+     *   absolute path or a `file://` URL), so the same seed reproduces the same
+     *   data on a checkout at a different absolute path.
+     * - `{ kind: "call site" }`, the default, is `"rooted"` at the directory of
+     *   whichever file called `initialize()`.
+     * - `{ kind: "none" }` attributes nothing: every construction of a given kind
+     *   anywhere in the instance shares one stream, keyed by kind alone.
      *
-     * See [Reproducibility](https://ghostry-dev.github.io/fabricator/guides/reproducibility)
+     * See
+     * [Reproducibility](https://docs.ghostry.dev/fabricator/guides/reproducibility)
      * for the trade-offs between the three.
      */
     attribution?: Attribution;
     /**
-     * Instance-wide numeric ceilings. `combinatorial` bounds how many
-     * instances `combinatorial(...)` may enumerate — the check is
-     * eager, it throws at call time before any instance is produced.
-     * Defaults to 1024 if omitted. `coverage(...)` carries no entry
-     * here: its count is the widest single axis, so there is nothing
-     * for a limit to protect against.
+     * Instance-wide numeric ceilings. `combinatorial` bounds how many instances
+     * `combinatorial(...)` may enumerate — the check is eager, it throws at
+     * call time before any instance is produced. Defaults to 1024 if omitted.
+     * `coverage(...)` carries no entry here: its count is the widest single
+     * axis, so there is nothing for a limit to protect against.
      */
     limits?: Limits;
     /**
      * What `T.date.past`/`T.date.future` (and any producer reading
-     * `ProduceContext.clock`) resolve "now" against — and, because it
-     * sits in every leaf's trace, the default entropy for the instance.
-     * Defaults to the wall-clock instant of this `initialize()` call, so
-     * an unconfigured run has realistic dates and varies by process, and
-     * replays from `context.clock` (with the same empty or supplied
-     * `seed`). Pass a fixed `Date` to freeze "now" (and the rest of the
-     * run, unless `seed` also differs). Pass `"seeded"` to derive "now"
-     * from the instance seed instead — an instant drawn across the whole
-     * representable `Date` span, so an implausible date is the expected
-     * outcome of that policy, not a bug. `"seeded"` is what makes `seed`
-     * alone the reproducibility unit.
+     * `ProduceContext.clock`) resolve "now" against — and, because it sits in
+     * every leaf's trace, the default entropy for the instance. Defaults to the
+     * wall-clock instant of this `initialize()` call, so an unconfigured run
+     * has realistic dates and varies by process, and replays from
+     * `context.clock` (with the same empty or supplied `seed`). Pass a fixed
+     * `Date` to freeze "now" (and the rest of the run, unless `seed` also
+     * differs). Pass `"seeded"` to derive "now" from the instance seed instead
+     * — an instant drawn across the whole representable `Date` span, so an
+     * implausible date is the expected outcome of that policy, not a bug.
+     * `"seeded"` is what makes `seed` alone the reproducibility unit.
      */
     clock?: Date | "seeded";
+    /**
+     * The ambient carrier backing `wrap` for this lineage — override only to
+     * force a specific one.
+     *
+     * Left unset (the norm), the `#stack` package import picks it: every
+     * runtime with `node:async_hooks` — Node, Bun, Deno — gets the
+     * `AsyncLocalStorage` carrier, whose frames survive `await` and isolate
+     * concurrent `wrap`s; anywhere else falls back to a synchronous LIFO, on
+     * which `wrap` rejects an async block rather than silently resolving a
+     * later build against this instance. Supplying one is how a test drives the
+     * carrier it did not get by condition.
+     */
+    stack?: Stack;
 }>): Instance<$Registry>;
 export { Omitted } from "./Types";
 /**
- * Tags a `Seed` — for `new Fabricator(schema, { seed })`, or `fork`'s
- * own `Overlay.seed` — as composing onto whatever base is in effect,
- * rather than replacing it outright.
+ * Tags a `Seed` — for `new Fabricator(schema, { seed })`, or `fork`'s own
+ * `Overlay.seed` — as composing onto whatever base is in effect, rather than
+ * replacing it outright.
  */
 export { layer } from "./Random";
 /**
- * `layer(...)`'s return type, so a caller building one programmatically
- * can name it — the same rationale as the existing `Seed`/`Attribution`
- * exports.
+ * `layer(...)`'s return type, so a caller building one programmatically can
+ * name it — the same rationale as the existing `Seed`/`Attribution` exports.
  */
 export type { Layered } from "./Random/Types";
 /**
  * Every failure this library raises is an instance of this class — see
- * `src/Error/index.ts` for the full hierarchy. Only the base is
- * public; subclasses are distinguished by `.name`.
+ * `src/Error/index.ts` for the full hierarchy. Only the base is public;
+ * subclasses are distinguished by `.name`.
  */
 export { FabricatorError } from "./Error";
 /**
- * The adapter contract, exported because an adapter is a separate
- * package rather than something registered here: `Adapter`/`Recurse`
- * are what one declares, `drive` is what its conversion entry point
- * calls, and `Adaptation`/`AdaptationsOf` are how it reads what a
- * Schema declared — `[Adaptation]` at runtime, `AdaptationsOf` at the
- * type level, keyed by its own `key` in both cases.
+ * The adapter contract, exported because an adapter is a separate package
+ * rather than something registered here: `Adapter`/`Recurse` are what one
+ * declares, `drive` is what its conversion entry point calls, and
+ * `Adaptation`/`AdaptationsOf` are how it reads what a Schema declared —
+ * `[Adaptation]` at runtime, `AdaptationsOf` at the type level, keyed by its
+ * own `key` in both cases.
  *
- * This package names no external schema library and depends on none:
- * every mapping, and every dependency it needs, belongs to the
- * adapter.
+ * This package names no external schema library and depends on none: every
+ * mapping, and every dependency it needs, belongs to the adapter.
  *
- * `Adapting` is the odd one out, facing whoever *writes* an adaptation
- * rather than whoever implements an adapter: it is the parameter type
- * of every kind's `.adapt(adapter, produce)` producer, so a caller
- * writing that producer as a named function can name it — the same
- * reason `Stream` is exported below.
+ * `Adapting` is the odd one out, facing whoever _writes_ an adaptation rather
+ * than whoever implements an adapter: it is the parameter type of every kind's
+ * `.adapt(adapter, produce)` producer, so a caller writing that producer as a
+ * named function can name it — the same reason `Stream` is exported below.
  */
 export { drive } from "./Adapter/Core";
 export type { Adaptations, AdaptationsOf, Adapter, Adapting, Recurse, } from "./Adapter/Types";
 export { Adaptation } from "./Types";
 /**
- * The default registry of type definers, exported so it can be
- * extended via `registry.extend(({ T }) => ({ ... }))` before being
- * passed to `initialize({ types })`.
+ * The default registry of type definers, exported so it can be extended via
+ * `registry.extend(({ T }) => ({ ... }))` before being passed to `initialize({
+ * types })`.
  */
 export { registry } from "./Schema/Registry";
 /**
- * Canonical `{ value, exclusive }` endpoint stored on `whereby` min/max,
- * plus the call-site union that still accepts a scalar (inclusive). Exported
- * so a named `.whereby(...)` argument or an `.adapt` producer reading `meta`
- * can type it — the same rationale as `Stream`.
+ * Canonical `{ value, exclusive }` endpoint stored on `whereby` min/max, plus
+ * the call-site union that still accepts a scalar (inclusive). Exported so a
+ * named `.whereby(...)` argument or an `.adapt` producer reading `meta` can
+ * type it — the same rationale as `Stream`.
  */
+export { effectiveDiscrete, toBound } from "./Bound";
 export type { Bound, InputBound } from "./Bound";
-export { toBound, effectiveDiscrete } from "./Bound";
 /**
- * Public because it is the type of `ProduceContext`'s `random` member
- * — the seeded stream every kind's `.as(produce)` and `T.opaque`'s
- * producer are handed — so a caller writing either as a named function
- * can name it.
+ * Public because it is the type of `ProduceContext`'s `random` member — the
+ * seeded stream every kind's `.as(produce)` and `T.opaque`'s producer are
+ * handed — so a caller writing either as a named function can name it.
  */
 export type { Stream } from "./Random/Types";
 /**
- * What every kind's `.as(produce)` producer is called with — a single
- * curated object rather than a positional argument list, so a caller
- * writing the producer as a named function can name its parameter.
- * `T.opaque`'s producer takes the same shape.
+ * What every kind's `.as(produce)` producer is called with — a single curated
+ * object rather than a positional argument list, so a caller writing the
+ * producer as a named function can name its parameter. `T.opaque`'s producer
+ * takes the same shape.
  */
 export type { ProduceContext } from "./Random/Types";
 /**
- * The shape `initialize({ seed })` and `new Fabricator(schema, { seed })`
- * both accept — a single string, or several — so a caller building one
- * programmatically (rather than as an inline literal) can name the
- * type.
+ * The shape `initialize({ seed })` and `new Fabricator(schema, { seed })` both
+ * accept — a single string, or several — so a caller building one
+ * programmatically (rather than as an inline literal) can name the type.
  */
 export type { Seed } from "./Random/Types";
 /**
- * The shape `initialize({ attribution })` accepts, so a caller building
- * one programmatically — a rooted policy derived from an env var, say
- * — can name the type.
+ * The shape `initialize({ attribution })` accepts, so a caller building one
+ * programmatically — a rooted policy derived from an env var, say — can name
+ * the type.
  */
 export type { Attribution } from "./Random/Types";
 /**
- * Reads the value type a built Fabricator produces straight off its
- * `fabricate` signature — `Fabrication<typeof Product>` instead of
- * `ReturnType<typeof Product.fabricate>`.
+ * Reads the value type a built Fabricator produces straight off its `fabricate`
+ * signature — `Fabrication<typeof Product>` instead of `ReturnType<typeof
+ * Product.fabricate>`.
  */
 export type { Fabrication } from "./Fabricator/Types";
 /**
- * Reads the value type a Schema (not yet built) will eventually
- * produce, via its phantom `[Produces]` marker. Mostly useful for a
- * helper that accepts a Schema before it's built into a Fabricator.
+ * Reads the value type a Schema (not yet built) will eventually produce, via
+ * its phantom `[Produces]` marker. Mostly useful for a helper that accepts a
+ * Schema before it's built into a Fabricator.
  */
 export type { ValueOf } from "./Schema/Types";
 /**
- * `fabricator.trace`'s type — otherwise unnameable by a caller
- * wanting to hold onto one, the same reason `Stream` is exported
- * above.
+ * `fabricator.trace`'s type — otherwise unnameable by a caller wanting to hold
+ * onto one, the same reason `Stream` is exported above.
  */
 export type { Trace } from "./Random/Types";
 /**
- * How `file` and `ordinal` on a {@link Trace} were resolved — recorded
- * so a captured trace is self-describing, including `"counted"`
- * (replayed for a node taken from inside a `T.recursive` expansion;
- * not a variant you choose when building).
+ * How `file` and `ordinal` on a {@link Trace} were resolved — recorded so a
+ * captured trace is self-describing, including `"counted"` (replayed for a node
+ * taken from inside a `T.recursive` expansion; not a variant you choose when
+ * building).
  */
 export type { RootKind } from "./Random/Types";
 /**
  * `fork`/`wrap`'s own config shapes, so a caller building an overlay
- * programmatically (rather than as an inline literal) can name them —
- * the same rationale as the existing `Seed`/`Attribution` exports.
- * `Config` is what `initialize`'s own parameter is a `Partial` of;
- * `Overlay` is what `fork`/`wrap` accept; `Context` is
- * `instance.context`'s own type, so a caller writing a helper that
- * reads it can name the parameter.
+ * programmatically (rather than as an inline literal) can name them — the same
+ * rationale as the existing `Seed`/`Attribution` exports. `Config` is what
+ * `initialize`'s own parameter is a `Partial` of; `Overlay` is what
+ * `fork`/`wrap` accept; `Context` is `instance.context`'s own type, so a caller
+ * writing a helper that reads it can name the parameter.
  */
-export type { Config, Context, Overlay } from "./Instance/Types";
+export type { Config, Context, Overlay, Stack } from "./Instance/Types";

package/dist/types/internal.d.ts

@@ -1,64 +1,95 @@
 /**
  * The "adapter-authoring SDK" entry point — published as the
- * `@ghostry/fabricator/internal` package export, deliberately *not*
- * re-exported from `./index.ts`. An external adapter package (e.g.
- * `@ghostry/fabricator-adapter-typebox-v0`) needs to walk a Schema/
- * Fabricator structurally and dispatch on each primitive kind's `Core`
- * shape — see "Match `Core`, never `Schema`, in a dispatch" — which
- * the end-user-facing `.` export has no reason to carry.
+ * `@ghostry/fabricator/internal` package export, deliberately _not_ re-exported
+ * from `./index.ts`. An external adapter package (e.g.
+ * `@ghostry/fabricator-adapter-typebox-v0`) needs to walk a Schema/ Fabricator
+ * structurally and dispatch on each primitive kind's `Core` shape — see "Match
+ * `Core`, never `Schema`, in a dispatch" — which the end-user-facing `.` export
+ * has no reason to carry.
  *
- * Also this package's own white-box test suite's route to source: a
- * test file imports through `@ghostry/fabricator`/
- * `@ghostry/fabricator/internal` rather than a relative `../src/...`
- * path specifically so it resolves through the built `dist/` (see the
- * "Random", "Schema", and "Enumeration" groups below) — the same
- * reason an adapter needs this entry point, applied to this package's
+ * Also this package's own white-box test suite's route to source: a test file
+ * imports through `@ghostry/fabricator`/ `@ghostry/fabricator/internal` rather
+ * than a relative `../src/...` path specifically so it resolves through the
+ * built `dist/` (see the "Random", "Schema", and "Enumeration" groups below) —
+ * the same reason an adapter needs this entry point, applied to this package's
  * own tests instead of an external one.
  *
- * Everything here is curated, not incidental. When wiring a new leaf
- * kind into the rest of the system, add its module to
- * `Primitive/namespace.ts` (re-exported here as `Primitive`), or no
- * adapter can reach that kind's `Core` type.
+ * Everything here is curated, not incidental. When wiring a new leaf kind into
+ * the rest of the system, add its module to `Primitive/namespace.ts`
+ * (re-exported here as `Primitive`), or no adapter can reach that kind's `Core`
+ * type.
  */
 export type { Fabrication, NaiveFabricator } from "./Fabricator/Types";
+/**
+ * Schema -> the Fabricator type `construct()` produces for it, dispatching per
+ * kind. `Constructor` already names this as its own construct signature's
+ * return, but only _inside_ a generic call: a wrapping library that hands a
+ * built Fabricator to its own callers has to name the type without making that
+ * call, and cannot infer it back out of `Constructor` because the signature is
+ * generic (a `Constructor extends { new (schema: $S, ...): infer $R }` match
+ * instantiates at the constraint, not at `$S`).
+ *
+ * `@ghostry/extern-extension-fabricator-v0` is the case in point: it hands the
+ * built Fabricator to a user callback as the shaping handle, so the handle's
+ * type is exactly this. Without it, an integration is pushed into hand-writing
+ * a per-kind stand-in — a second copy of this mapping, susceptible to drift.
+ */
+export type { AsFabricator } from "./Fabricator/Types";
 export { Children, Kind, Meta, Produces, type Buildable } from "./Types";
 export { isPlainObject } from "./Utility/Core";
 export type * as Primitive from "./Primitive/namespace";
 /**
- * `Schema/Types.ts`'s own value-type resolution, needed by tests
- * asserting `ValueOf<...>` directly rather than through a built
- * Fabricator's `Fabrication<...>`.
+ * `Schema/Types.ts`'s own value-type resolution, needed by tests asserting
+ * `ValueOf<...>` directly rather than through a built Fabricator's
+ * `Fabrication<...>`.
  */
 export type { ValueOf } from "./Schema/Types";
 /**
- * `Constructor` is `Instance.Fabricator`'s own type — public in effect
- * (every `initialize()` caller receives one), just never named
- * directly by the `.` export, which only ever describes it inline.
+ * `Constructor` is `Instance.Fabricator`'s own type — public in effect (every
+ * `initialize()` caller receives one), just never named directly by the `.`
+ * export, which only ever describes it inline.
  */
 export type { Constructor } from "./Fabricator/Constructor";
 /**
- * The enumeration planner's own shapes — `combinatorial`/`coverage`
- * (the `.` export's public entry points) are built on `plan`/`resolve`,
- * which a test asserting `axisFor`'s per-kind width/strategy decisions
- * needs directly.
+ * The enumeration planner's own shapes — `combinatorial`/`coverage` (the `.`
+ * export's public entry points) are built on `plan`/`resolve`, which a test
+ * asserting `axisFor`'s per-kind width/strategy decisions needs directly.
  */
 export { plan, resolve } from "./Enumeration/Plan";
 export type { Axis, Enumerable, Pin, Resolvable } from "./Enumeration/Types";
 /**
- * The randomness layer underneath
- * `initialize({ seed, algorithm, attribution })` and a Fabricator's
- * `.trace` — needed by tests exercising stream attribution and
- * construction directly, beneath the level `initialize()` itself
- * exposes.
+ * The randomness layer underneath `initialize({ seed, algorithm, attribution
+ * })` and a Fabricator's `.trace` — needed by tests exercising stream
+ * attribution and construction directly, beneath the level `initialize()`
+ * itself exposes.
  */
 export { defaultAlgorithm, encode, randomSeed, toRandomSource, toStream, toStreamFromTrace, } from "./Random";
 export type { Algorithm, ConstructionTrace, ConstructorOptions, ResolvedAttribution, RootKind, RootPins, Seed, Trace, } from "./Random/Types";
 /**
- * `Random/CallSite.ts`'s pure string helpers. Exported for this
- * package's own tests: the percent-encoded, `file://`-prefixed, and
- * backslashed spellings they exist to fold together cannot be produced
- * by running the suite from an ordinary POSIX checkout, so they have
- * to be driven with synthetic frame strings instead of real stack
- * frames.
+ * `Random/CallSite.ts`'s pure string helpers. Exported for this package's own
+ * tests: the percent-encoded, `file://`-prefixed, and backslashed spellings
+ * they exist to fold together cannot be produced by running the suite from an
+ * ordinary POSIX checkout, so they have to be driven with synthetic frame
+ * strings instead of real stack frames.
  */
 export { directoryOf, normalizeLocation, relativize } from "./Random/CallSite";
+/**
+ * Resolves the file that triggered the current call. Exported here for a
+ * library that wraps fabricator (e.g. `@ghostry/extern`'s testing scope) and
+ * wants a construction attributed to _its own_ caller rather than to itself,
+ * which is what the `skip` option is for. See `Random/CallSite.ts`'s doc
+ * comment for the full contract, including why `skip` is a list of roots that
+ * composes onto this library's own root rather than replacing it.
+ */
+export { resolveCallerFile } from "./Random/CallSite";
+/**
+ * The synchronous ambient carrier. `#stack` (`package.json`) selects it only
+ * where there is no `node:async_hooks` — in practice a browser bundle — so on
+ * Bun, Node, and Deno alike the condition always resolves to the
+ * `AsyncLocalStorage` one instead. Exported for this package's own tests:
+ * without it, neither the synchronous carrier's behavior nor `wrap`'s rejection
+ * of an async block under it is reachable from the suite. It is also a
+ * serviceable argument for `initialize({ stack })` for anyone who wants the old
+ * semantics back deliberately.
+ */
+export { toStack as toSynchronousStack } from "./Instance/Stack/Sync";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghostry/fabricator",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "license": "MIT",
   "description": "Fabricate typed data from composable schemas.",
   "keywords": [
@@ -19,6 +19,15 @@
   "type": "module",
   "types": "./dist/types/index.d.ts",
   "module": "./dist/esm/index.js",
+  "imports": {
+    "#stack": {
+      "types": "./src/Instance/Stack/Async.ts",
+      "deno": "./src/Instance/Stack/Async.ts",
+      "node": "./dist/esm/Instance/Stack/Async.js",
+      "bun": "./dist/esm/Instance/Stack/Async.js",
+      "default": "./dist/esm/Instance/Stack/Sync.js"
+    }
+  },
   "exports": {
     ".": {
       "types": "./dist/types/index.d.ts",
@@ -39,13 +48,16 @@
     "build:reset": "rm -rf ./dist",
     "build:compile": "bunx --no-install --bun rslib build --config ./rslib.config.ts",
     "build:compile:rsdoctor": "RSDOCTOR=true bunx --no-install --bun rslib build --config ./rslib.config.ts",
+    "build:types": "bun --bun ../../node_modules/typescript-5/lib/tsc.js -p ./tsconfig.build.json --noEmit false --declaration --emitDeclarationOnly --declarationDir ./dist/types",
+    "build:verify": "tsc --noEmit -p ./tsconfig.verify.json",
     "build:clean": "find ./dist -type f -name '*.tsbuildinfo' -delete",
-    "build": "bun run build:reset && bun run build:compile && bun run build:clean",
-    "build:rsdoctor": "bun run build:reset && bun run build:compile:rsdoctor && bun run build:clean",
+    "build": "bun run build:reset && bun run build:compile && bun run build:types && bun run build:verify && bun run build:clean",
+    "build:rsdoctor": "bun run build:reset && bun run build:compile:rsdoctor && bun run build:types && bun run build:verify && bun run build:clean",
     "check": "tsc --noEmit",
     "check:ts5": "bun --bun ../../node_modules/typescript-5/lib/tsc.js --noEmit",
-    "prettier": "bunx --no-install --bun prettier .",
-    "test": "bun run check && bun run check:ts5 && bun test"
+    "check:jsr": "DENO_BIN_PATH=$PWD/../../node_modules/.bin/deno bunx --no-install jsr publish --dry-run --allow-dirty",
+    "format": "bunx --no-install oxfmt .",
+    "test": "bun run check && bun run check:ts5 && bun run check:jsr && bun test"
   },
   "files": [
     "dist"