@typeonce/effect-machine 0.8.0 → 0.10.0

package/docs/agent-guide.md

@@ -22,10 +22,10 @@ declared:
 
 1. Domain schemas used by state and event fields.
 2. Tagged schemas for states that own data.
-3. Tagged public-event, internal-event, and emitted-event schemas.
+3. Tagged public-event, internal-event, parent-event, and emitted-event schemas.
 4. `Machine.defineStates`.
-5. `Machine.make`, including input, events, internal events, emits, and the
-   initial function.
+5. `Machine.make`, including input, `events`, `internalEvents`, `parentEvents`,
+   `emittedEvents`, and the initial function.
 6. One or more `.handle(...)` calls.
 7. Child descriptors.
 8. Runtime, Atom, or Cluster adapters.
@@ -49,13 +49,17 @@ const InternalEvent = Schema.TaggedUnion({
 })
 
 const States = Machine.defineStates(State.cases)
+const Events = Machine.events(Event)
+const InternalEvents = Machine.internalEvents(InternalEvent)
 ```
 
-Construct event values with `Event.cases.Save.make({})`. Construct new state
-values through the target or initial builder's `.from(...)` method so schema
-construction runs inside planning. Pass a state directly only when it is
-already decoded. Use `Schema.TaggedClass` when a case needs class methods or
-nominal class identity; `.from(...)` preserves that identity.
+Pass these descriptors to `Machine.make` and export `Events` instead of the raw
+event schema. Construct new state values through the target or initial
+builder's `.from(...)` method. Both event constructors and state `.from(...)`
+defer schema construction until planning, so validation failures remain typed
+machine errors. Use
+`Schema.TaggedClass` when a case needs class methods or nominal class identity;
+the deferred constructors preserve that identity after decoding.
 
 ## Hard invariants
 
@@ -68,23 +72,26 @@ nominal class identity; `.from(...)` preserves that identity.
 - Return snapshots or typed target-builder results from transitions. Do not
   return raw decoded state values.
 - Transition and lifecycle callbacks are synchronous. Put asynchronous work in
-  an invoked Effect, actor, or child machine and map its result to an event.
+  an invoked Effect, logic process, or child machine and handle its lifecycle
+  with `onDone`, `onFailure`, and `onSnapshot`.
 - Put data on the narrowest state where it is valid. Put data shared by sibling
   phases on their compound parent.
 - Declare finality only in the state definition. Do not put `type: "final"` in
   a handler.
 - Every declared output schema needs a matching handler implementation before
   planning or execution.
-- `parents` keys are full dotted paths.
+- Handler `ancestors` keys are full dotted paths.
 - Invoke lifetimes follow state entry and exit, not the spelling of the target
   builder.
-- Recover expected invoked Effect failures into machine events. Unrecovered
-  child failures terminate the owning machine.
-- Reuse the exact child descriptor value for `invokeMachine`, `sendTo`, and
-  child lookup.
-- `events` is the public input protocol. `internalEvents` contains machine-local
-  deliveries such as invoke results and invoked-child emissions. Handlers see
-  both; typed public `send` and `Machine.plan` accept only `events`.
+- Handle every typed invoked Effect failure with `onFailure`. Defects and
+  interruption terminate the owning machine.
+- Reuse an exported child descriptor for inline invocation, `sendTo`, and child
+  lookup. Independently constructed descriptors are equivalent only when both
+  their id and machine identity match.
+- `events` is the public actor-input protocol. `internalEvents` contains
+  machine-local raised events. `parentEvents` describes the public events a
+  child may send to its owner. `emittedEvents` describes outward ephemeral
+  notifications and is never delivered implicitly to a parent.
 - Event tags in `events` and `internalEvents` must be disjoint.
 - Event tags must also be unique within each protocol list.
 
@@ -96,13 +103,15 @@ its extra control is required:
 - Bind a shared Atom runtime once with `AtomMachine.bind(runtime)`, then use the
   returned `make` or `resume`. Use `AtomMachine.make(machine)` and
   `AtomMachine.resume(machine, snapshot)` for service-free machines.
-- Use `Machine.invokeEffect` for a typed one-shot Effect and `Machine.after` for
-  a timer. Use `Machine.invoke` with `Machine.effect` only for custom child
-  process behavior or snapshot mapping.
+- Use one invocation object: `effect` for one-shot work, `after` for a timer,
+  `logic` for reusable process logic, and `child` for a complete child
+  statechart. `Machine.invoke({...})` preserves owner context and source
+  channels across sibling lifecycle handlers. Use a direct object only when its
+  lifecycle handlers do not need source-derived context.
 - Use `Machine.child(id, machine)` for a complete statechart descriptor and
-  `Machine.childAddress<Event>(id)` for a low-level process address. An
-  invocation is addressable only when `Machine.invoke` receives that address
-  explicitly.
+  `Machine.childAddress<Event>(id)` for a low-level process address. A logic
+  invocation is addressable only when `Machine.invoke` receives that
+  address explicitly.
 - Use the callback's `enqueue` argument for `raise`, `emit`, `sendTo`, and
   `stop`. These operations record closed actor commands and do not run Effects.
 
@@ -148,8 +157,8 @@ States.get(snapshot, "Form")                  // type error: no value schema
 
 For a schema-less path, builders expose only `.from(...)`; the direct callable
 form is reserved for already-decoded schema values. Structural ancestors are
-also omitted from `parents`; an immediate structural parent is typed as
-`undefined`. Add `schema` when a state begins to own data or needs runtime
+also omitted from `ancestors`; an immediate structural containing state is
+typed as `undefined`. Add `schema` when a state begins to own data or needs runtime
 validation and persistence for that data.
 
 Use an atomic state when no child phase can be active beneath it.
@@ -217,7 +226,7 @@ const States = Machine.defineStates({
 
 const machine = Machine.make({
   states: States.states,
-  events: [],
+  events: Machine.events(),
   initial: () => States.initial.Done.from()
 }).handle({
   Done: {
@@ -372,7 +381,7 @@ parallel builders still require a callback selecting their active child or
 every active region. Omitted input is normalized to `{}` and still passes
 through `schema.makeEffect`, including refinements.
 
-## Reading state and parents
+## Reading state and structural ancestors
 
 `Machine.defineStates` returns typed helpers:
 
@@ -394,16 +403,18 @@ States.matches(ready, "Route.Ready.Saving")
 
 All paths are checked against the definition. `get` and `getWithParents` accept
 only schema-backed paths; use `matches` or `getSnapshot` for any active path.
-`context.parent` is the immediate typed parent value (`undefined` at a root or
-when that parent is schema-less). `parents` contains only valued ancestors. Use
-its full paths when another ancestor value is needed:
+`context.containingState` is the immediate typed state value (`undefined` at a
+root or when that state is schema-less). `context.ancestors` contains only
+valued structural ancestors. This is separate from `context.parent`, which is
+the owning actor reference or `undefined` for a root actor. Use full state paths
+when another ancestor value is needed:
 
 ```ts
-parents["Route.Ready"]
-parents["Route.Ready.Editing"]
+ancestors["Route.Ready"]
+ancestors["Route.Ready.Editing"]
 ```
 
-Do not guess short properties such as `parents.Ready`.
+Do not guess short properties such as `ancestors.Ready`.
 
 ### Inspecting the full transition configuration
 
@@ -415,7 +426,7 @@ microstep, before any selected transition is applied:
 BufferReady: ({ snapshot, target }) =>
   States.matches(snapshot, "Player.Network.Online")
     ? target.local.Playing.from()
-    : undefined
+    : target.none()
 ```
 
 Use the existing `States.matches`, `States.get`, `States.getWithParents`, and
@@ -446,11 +457,19 @@ history definitions may declare an `annotations` object containing only
 they cannot change behavior, identity, or targeting. Visualization may show a
 title, while the structural path remains authoritative.
 
-Use `Machine.retag(TargetCase, source, patch?)` when sibling state payloads
-share fields. It removes the source discriminator, reuses only compatible
-fields, and requires a patch for every missing or incompatible required field.
-Prefer moving broadly shared data to the compound parent rather than retagging
-it through every phase.
+When sibling state payloads share fields, destructure away the source
+discriminator and construct the destination through its target builder:
+
+```ts
+Submit: ({ state, target }) => {
+  const { _tag: _, ...fields } = state
+  return target.local.Saving.from({ ...fields, attempt: 1 })
+}
+```
+
+The target schema remains responsible for defaults, transforms, refinements,
+and class identity. Prefer moving broadly shared data to the compound parent
+rather than copying it through every phase.
 
 ## Planning, actions, raised events, and emissions
 
@@ -458,18 +477,89 @@ A transition returns a target synchronously:
 
 ```ts
 Submit: ({ state, target }) =>
-  state.valid ? target.local.Saving.from({ draft: state.draft }) : undefined
+  state.valid ? target.local.Saving.from({ draft: state.draft }) : target.none()
 ```
 
+Every installed event, `always`, `onDone`, and invoke lifecycle handler must
+return a concrete target or `target.none()`. An absent event handler means the
+event is ignored. Returning `target.none()` means it was handled without a
+destination, so queued commands, raised events, and emitted events are still
+retained. It remains valid when a transition declares `targets`: those paths
+are an upper bound on concrete destinations, not an exhaustive result set.
+
+`reenter: true` remains meaningful with `target.none()`: the source exits and
+enters again while its logical configuration is retained.
+
 Closed statechart and actor operations use `enqueue`:
 
 ```ts
 Submit: ({ target }, enqueue) => {
-  enqueue.emit(new SaveRequested({}))
+  enqueue.emit(Emissions.SaveRequested())
   return target.local.Saving.from()
 }
 ```
 
+Declare emission constructors separately from actor inputs:
+
+```ts
+const Emissions = Machine.emittedEvents(SaveRequested, AuditRecorded)
+
+const definition = Machine.make({
+  events: Commands,
+  internalEvents: InternalEvents,
+  emittedEvents: Emissions,
+  // ...
+})
+```
+
+`enqueue.raise(...)` is a same-macrostep input to self. `enqueue.sendTo(...)`
+targets an actor mailbox and is processed later. `enqueue.emit(...)` is neither:
+it publishes a one-off outward notification. Observe it with
+`ref.emissions`, a hot non-replayed `Stream` that completes with the actor.
+`ref.changes` is stateful and begins with the current lifecycle snapshot.
+Startup emissions occur before `Machine.start` returns and therefore are not
+visible through the returned ref; use state for facts that must be retained.
+
+For child-to-parent input, export a public builder protocol and reuse it at both
+composition boundaries:
+
+```ts
+export const ParentEvents = Machine.events(ChildFinished)
+
+const child = Machine.make({
+  events: ChildEvents,
+  parentEvents: ParentEvents,
+  // ...
+}).handle({
+  Working: {
+    on: {
+      Finish: ({ parent }, enqueue) => {
+        if (parent !== undefined) {
+          enqueue.sendTo(parent, ParentEvents.ChildFinished())
+        }
+      }
+    }
+  }
+})
+
+const parent = Machine.make({
+  events: Machine.events(ParentCommands, ParentEvents),
+  // ...
+})
+```
+
+Invoking the child under a parent that lacks any required `parentEvents` case
+is a type error. Within child handlers, `parent` accepts only that protocol.
+The same child may run as a root, where `parent` is `undefined`. `self` accepts
+the machine's public inputs. Neither actor reference is a structural state
+value; use `containingState` and `ancestors` for statechart ancestry.
+
+Atom-backed actors retain the same transient semantics. Use
+`AtomMachine.emissions(machineAtom)` for a root and
+`AtomMachine.childEmissions(childAtom)` for the currently active child. Both
+return streams requiring the corresponding `AtomRegistry`; emissions are not
+stored as atom state.
+
 For asynchronous validation or persistence, invoke an Effect or child machine
 from the state and handle its typed success or failure event in a later
 transition. This keeps `(state, event) => [nextState, commands]` synchronous.
@@ -499,86 +589,119 @@ an event for the parent. Both operations validate their schemas.
 union handled inside the statechart:
 
 ```ts
-const machine = Machine.make({
+const Events = Machine.events(Event)
+const InternalEvents = Machine.internalEvents(InternalEvent)
+
+const definition = Machine.make({
   states: States.states,
-  events: [Event.cases.Save],
-  internalEvents: [InternalEvent.cases.Saved, InternalEvent.cases.SaveFailed],
+  events: Events,
+  internalEvents: InternalEvents,
   initial: () => States.initial.Idle.from()
 })
 ```
 
-When the same already-constructed event may be delivered repeatedly, construct
-it once through its owning machine protocol:
+Use the protocol-bound constructors at every machine delivery boundary:
 
 ```ts
-const save = Machine.event(machine, Event.cases.Save)
-yield* ref.send(save)
+yield* ref.send(Events.Save())
+enqueue.raise(InternalEvents.Saved({ id: "entry-1" }))
 ```
 
-`Machine.event` runs the configured schema constructor once. That machine and
-definitions derived from it with `handle` then recognize the decoded event as
-trusted and do not decode it again. Tagged-union case schemas are recognized
-when their union is configured. Treat the returned event as immutable. Raw
-objects and values constructed for another machine continue through normal
-runtime validation on every delivery.
+`Machine.events` exposes only public constructors;
+`Machine.internalEvents` exposes only machine-local constructors. Both flatten
+configured tagged unions and preserve tagged classes, finite discriminator
+unions, required inputs, and constructor defaults. A constructor returns an
+opaque instruction whose `_tag` is available for activity metadata. Its decoded
+fields are intentionally unavailable until the owning machine processes it.
+
+Invalid constructor input fails `Machine.plan` or the running machine with
+`MachineSchemaDecodeError`; creating the instruction itself never performs
+schema validation. APIs that explicitly retain decoded events, such as manual
+model-testing scenarios or transport messages, can receive complete event
+objects directly.
+
+An open discriminator such as `_tag: Schema.String` cannot produce named
+constructors because its tag set is not finite. The schema still participates
+in the protocol; pass a complete event object at the delivery boundary.
 
 Use the exported utility types when another API must preserve the boundary:
 
 ```ts
-type PublicEvent = Machine.Machine.InputEvent<typeof machine>
-type AnyHandledEvent = Machine.Machine.Event<typeof machine>
+type PublicEvent = Machine.Machine.InputEvent<typeof definition>
+type AnyHandledEvent = Machine.Machine.Event<typeof definition>
 ```
 
-`MachineRef.send`, `machineAtom.send`, and `Machine.plan` use `InputEvent` at
-their TypeScript boundary. Transition handlers, raised events, invoke results,
-and mapped child events use the complete `Event` union. The local planner and
-runtime intentionally share the complete decoder to support those internal
-deliveries, so JavaScript or `any` can bypass the local public distinction.
+`MachineRef.send`, `machineAtom.send`, and `Machine.plan` accept decoded public
+events or constructions returned by `Machine.events`. Transition handlers
+receive only decoded events. Raised events additionally accept constructions
+from `Machine.internalEvents`; outward notifications accept constructions from
+`Machine.emittedEvents`. The
+local planner and runtime intentionally share the complete decoder to support
+those internal deliveries, so JavaScript or `any` can bypass the local public
+distinction.
 Cluster RPC payloads are additionally decoded against the public `events`
 schemas at the transport boundary. Never repeat an `_tag` within a list or
 across both configuration lists.
 
 ## Recoverable state-scoped work
 
-Use `Machine.invokeEffect` for a one-shot Effect. Its callbacks preserve the
-typed success and failure channels while mapping both into machine events:
+Use `Machine.invoke` with an `effect` for one-shot work. Lifecycle callbacks
+receive the typed Effect channels and can transition directly:
 
 ```ts
-invoke: ({ state }) =>
-  Machine.invokeEffect({
-    id: "save",
-    effect: SaveService.save(state.draft),
-    onSuccess: (entry) => new Saved({ entry }),
-    onFailure: (error) => new SaveFailed({ message: error.message })
-  })
+invoke: Machine.invoke({
+  id: "save",
+  effect: SaveService.save(draft),
+  onDone: ({ output, target }) => target.full.Saved({ entry: output }),
+  onFailure: ({ error, target }) =>
+    target.full.SaveFailed({ message: error.message })
+})
 ```
 
 The owning state scopes the child. Owner-driven interruption on state exit is
-normal cancellation and stale output is ignored. A child Effect that defects
-or self-interrupts fails the parent. Omit `onFailure` only when the Effect error
-type is `never`; defects and interruption are not mapped.
+normal cancellation and stale output is ignored. An Effect that defects or
+self-interrupts fails the parent. `onDone` is required when the output is not
+`never`; `onFailure` is required when the typed error is not `never`. Handlers
+are forbidden when their channel is `never`.
+
+The source may also be a function of the owning state's entry context when it
+needs `state`, `containingState`, `ancestors`, or the entry `event`. Source construction
+errors, defects, and interruption are machine failures rather than a second
+phase in `onFailure`.
+
+When a source function reads `state`, `containingState`, `ancestors`, or the entry `event`,
+`Machine.invoke` infers that owner context and the returned Effect's output,
+error, and service channels together. No return annotation is needed:
+
+```ts
+invoke: Machine.invoke({
+  id: "load",
+  effect: ({ state }) => LoadService.load(state.userId),
+  onDone: ({ output, target }) => target.full.Loaded({ user: output }),
+  onFailure: ({ error, target }) => target.full.LoadFailed({ error })
+})
+```
 
-Successful non-void output is delivered as a parent event. Include every
-possible mapped result schema in the parent machine's `internalEvents` array and
-add handlers for the relevant tags. Leave defects and interruption fatal;
-recover only expected typed failures.
+A direct `invoke: { ... }` object remains available when lifecycle handlers do
+not need source-derived context.
 
-A cancellable timer uses `Machine.after`:
+A cancellable timer uses the same object:
 
 ```ts
-invoke: Machine.after("3 seconds", new ClearStatus({}), {
-  id: "clear-status"
+invoke: Machine.invoke({
+  id: "clear-status",
+  after: "3 seconds",
+  onDone: ({ target }) => target.full.Clear()
 })
 ```
 
-The timer starts on state entry and is interrupted on exit. Supply an explicit
-id when more than one active timer could deliver the same event tag. Use
-lower-level `Machine.invoke` with `Machine.effect` when custom child logic or
-snapshot mapping is required. In that API, `id` is only the invocation's
-state-local lifecycle key. To communicate with the invocation, create a
-`Machine.childAddress<Event>("worker")` and pass it as `address`; TypeScript
-checks the address protocol against the child logic. Lifecycle ids must be
-unique among simultaneously active invokes owned by the same state.
+The timer starts on state entry and is interrupted on exit. Its `onDone` is
+always required. `effect: Effect.sleep(...)` has the same scoped cancellation
+behavior, but `after` records timer intent and exposes a static duration through
+`Machine.activityDefinitions`. For reusable process logic, provide `logic`, a
+state-local lifecycle `id`, and a typed `address`. TypeScript checks the address
+protocol against the logic event protocol. Lifecycle ids and addresses serve
+different purposes and must both be explicit.
 
 ## Invoked child statecharts
 
@@ -591,24 +714,24 @@ const Editor = Machine.child("editor", EditorMachine)
 Invoke it from its owning state:
 
 ```ts
-invoke: Machine.invokeMachine({
+invoke: Machine.invoke({
   child: Editor,
   input: editorInput,
-  onDone: ({ output }) => new EditorCompleted({ output })
+  onDone: ({ output, target }) => target.full.EditorDone({ output })
 })
 ```
 
 Use `Editor` for:
 
 ```ts
-Machine.sendTo(Editor, new Reset({}))
+Machine.sendTo(Editor, EditorEvent.Reset())
 parentRef.child(Editor)
 parentAtom.child(Editor)
 ```
 
-Child emissions, mapped snapshots, and mapped completion output are delivered as
-parent events and must be accepted by the parent's `internalEvents` list.
-Invoked child IDs must be unique while simultaneously active.
+Child emissions are delivered through the parent's internal protocol.
+`onSnapshot`, `onDone`, and `onFailure` are direct parent transitions. Invoked
+child IDs must be unique while simultaneously active.
 
 Descriptors with the same id and machine identity address the same child, even
 when independently constructed. The descriptor objects themselves are not
@@ -620,21 +743,18 @@ logic that does not have a complete machine descriptor.
 ### Inspecting state-owned activities
 
 Use `Machine.activityDefinitions(machine)` to inspect invokes without running
-them. Static `Machine.invoke`, `Machine.invokeEffect`, `Machine.after`, and
-`Machine.invokeMachine` descriptors expose serializable ownership metadata:
+them. Static inline `Machine.invoke` definitions expose serializable ownership
+metadata:
 
 ```ts
 Machine.activityDefinitions(machine)
 // [{ source: "Loading", id: "load-timeout", type: "timer",
-//    duration: "10s", event: "LoadTimedOut" }]
+//    duration: "10s" }]
 ```
 
-Effect success/failure mappers are closures and therefore appear as dynamic
-outcomes. Child machines expose descriptor identity, never their runtime or
-implementation. A function-valued `invoke` factory is represented as a dynamic
-activity because inspection must not evaluate user code. The existing invoke
-helpers remain the only execution API; this metadata does not add lifecycle
-configuration syntax or affect execution.
+Child machines expose descriptor identity, never their runtime or
+implementation. Function-valued sources and durations are represented as
+dynamic because inspection must not evaluate user code.
 
 ## AtomMachine and React
 
@@ -743,8 +863,8 @@ Encoding does not preserve:
 - completion and history records survive but do not retrigger `onDone`;
 - active-state invokes start once in ordinary ancestor/document order with
   `Machine.InitialEvent`;
-- `invokeEffect` restarts, `invokeMachine` creates a fresh child from its normal
-  initial state, and `Machine.after` restarts its complete duration;
+- inline Effects restart, child machines start fresh from their normal initial
+  state, and timers restart their complete duration;
 - inactive invokes, spawned children, child snapshots, elapsed timer time, and
   prior `RuntimeSnapshot` status/errors are not restored;
 - a final logical snapshot creates an immediately completed ref;
@@ -918,26 +1038,26 @@ Wrap the initial builder result:
 initial: () => States.initial.Idle.from()
 ```
 
-### Invoked child output must be a machine event
+### Invoked child expects events not accepted by the parent
 
-Add the output's tagged schema to the parent machine's `internalEvents` array,
-or map/ignore the output before it reaches the parent.
+Export one parent-event protocol from the child boundary and compose it into
+the parent's public events:
 
-### Invoked child emits events not accepted by the parent
+```ts
+export const ChildParentEvents = Machine.events(ChildFinished)
 
-Add the child's emitted schemas to the parent machine's `internalEvents` array:
+// child
+parentEvents: ChildParentEvents
 
-```ts
-events: [Submit],
-internalEvents: [...ChildMachine.emits]
+// parent
+events: Machine.events(Submit, ChildParentEvents)
 ```
 
 ### An internal event is rejected by `send`
 
 This is intentional. Public input boundaries accept only schemas declared in
-`events`. Handle the event as an invoke result, child delivery, or raised event;
-move it to `events` only if external callers should genuinely be allowed to
-send it.
+`events`. Handle the event as a child delivery or raised event; move it to
+`events` only if external callers should genuinely be allowed to send it.
 
 ### Public and internal event tags overlap
 
@@ -965,15 +1085,15 @@ handlers own behavior.
 
 ### Parent property does not exist
 
-Use its full path:
+Use the structural ancestor's full path:
 
 ```ts
-parents["Route.Ready"]
+ancestors["Route.Ready"]
 ```
 
 ### Child descriptor types are unrelated
 
-Use the descriptor exported by the module that configured `invokeMachine`.
+Use the descriptor exported by the module that configured the child invocation.
 An independently created descriptor with the same id and machine identity also
 matches; the same id paired with a different machine remains a distinct child.
 
@@ -997,6 +1117,6 @@ The current API does not include:
 - declarative first-class guards;
 - a complete inspectable graph for arbitrary transition Effects.
 
-Use ordinary TypeScript conditions for guards and `Machine.after` for
-state-scoped timers. Do not invent undocumented state-node properties such as
-`guard`.
+Use ordinary TypeScript conditions for guards and an inline `Machine.invoke`
+with `after` for state-scoped timers. Do not invent undocumented state-node
+properties such as `guard`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typeonce/effect-machine",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "Schema-first state machines and statecharts for Effect",
   "author": "Sandro Maglione",
   "repository": {
@@ -69,7 +69,7 @@
     "test": "vitest run",
     "test:types": "tstyche",
     "check:architecture": "node --test scripts/check-architecture.test.mjs && node scripts/check-architecture.mjs",
-    "check:ci": "node --test scripts/ci-changes.test.mjs scripts/runtime-performance-regression.test.mjs",
+    "check:ci": "node --test scripts/ci-changes.test.mjs scripts/runtime-performance-compatibility.test.mjs scripts/runtime-performance-regression.test.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "perf:types": "pnpm build && node scripts/type-performance.mjs",
     "perf:runtime": "pnpm build && node --expose-gc scripts/runtime-performance.mjs",