@tmonier/effract 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tmonier (get-tmonier)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,31 @@
+# @tmonier/effract
+
+Write React components as Effect programs. The same component runs in a SPA, on a Bun/Node server, in a Web
+Worker, or as a React Server Component.
+
+```tsx
+import { Runtime, component, hook } from '@tmonier/effract';
+import { useState } from 'react';
+
+const Dashboard = component(function* () {
+  const stats = yield* Stats; // an Effect service
+  const [tab, setTab] = yield* hook(useState('overview')); // a real React hook
+  return <Panel tab={tab} total={stats.total} onTab={setTab} />;
+});
+
+export const App = () => (
+  <Runtime layer={AppLive}>
+    <Dashboard />
+  </Runtime>
+);
+```
+
+- `component` / `view` — hook-capable and resolve-up-front components.
+- `hook` — lift a React hook into the `yield*` channel.
+- `<Runtime layer={...}>` — provide an Effect runtime to a subtree.
+- `atom`, `observe`, `<Observe>`, `useAtom` — the signals bridge.
+
+See the [project README](https://github.com/get-tmonier/effract#readme) and
+[ADR 0001](https://github.com/get-tmonier/effract/blob/main/docs/adr/0001-fiber-reconciliation.md).
+
+MIT © Tmonier

package/dist/index.d.mts

@@ -0,0 +1,169 @@
+import { ReactNode } from "react";
+import * as Effect from "effect/Effect";
+import * as ManagedRuntime from "effect/ManagedRuntime";
+import { AtomRef } from "effect/unstable/reactivity";
+import * as Layer from "effect/Layer";
+
+//#region src/domain/protocol.d.ts
+/**
+ * The one unavoidable `any` in the framework. The heterogeneous yield protocol
+ * must accept an Effect of *any* error and requirement variance — there is no
+ * other way to express "some Effect" as a generic constraint, which is why
+ * Effect's own `Effect.gen` is typed exactly this way. Precise `E` and `R` are
+ * recovered below through conditional inference, so this never leaks to users.
+ */
+type AnyEffect = Effect.Effect<any, any, any>;
+/** Brand identifying a lifted React hook instruction. */
+declare const HookTypeId: unique symbol;
+type HookTypeId = typeof HookTypeId;
+/**
+ * A React hook result lifted into the `yield*` channel. The hook itself has
+ * already executed (synchronously, during render) by the time the value is
+ * wrapped — `hook(useState(0))` calls `useState` inline. Wrapping it only makes
+ * the result yieldable, so a component body reads as one uniform stream of
+ * `yield*`s whether the value comes from Effect or from React.
+ */
+interface Hook<out A> {
+  readonly [HookTypeId]: true;
+  readonly value: A;
+  [Symbol.iterator](): Iterator<Hook<A>, A>;
+}
+/**
+ * Lift an already-evaluated React hook result into the effract yield channel.
+ *
+ * ```ts
+ * const [tab, setTab] = yield* hook(useState('overview'));
+ * const ref = yield* hook(useRef<HTMLDivElement>(null));
+ * ```
+ *
+ * Because the component body runs synchronously inside React's render pass, the
+ * wrapped hook call obeys the Rules of Hooks: same order on every render.
+ */
+declare const hook: <A>(value: A) => Hook<A>;
+/** Type guard: is this yielded instruction a lifted hook? */
+declare const isHook: (u: unknown) => u is Hook<unknown>;
+/** Everything a component body may `yield*`: an Effect, or a lifted hook. */
+type Yieldable<A> = Effect.Effect<A, unknown, unknown> | Hook<A>;
+/** The generator a React Effect Component body produces. */
+type RecGenerator<A> = Generator<AnyEffect | Hook<unknown>, A, unknown>;
+/** A component body: props in, a generator of yields ending in a rendered `A`. */
+type RecBody<Props, A> = (props: Props) => RecGenerator<A>;
+/**
+ * Distribute over the yield union and keep only its Effect members. Hooks are
+ * not Effects, so they drop away — leaving just what carries `E` and `R`.
+ */
+type EffectsOnly<Eff> = Eff extends AnyEffect ? Eff : never;
+/**
+ * Recover the Effect requirement channel `R` from everything a body yields.
+ * A body that needs both `A` and `B` requires `A & B`, which is exactly the
+ * intersection TypeScript infers from the contravariant requirement slot.
+ */
+type RequirementsOf<Eff> = [EffectsOnly<Eff>] extends [Effect.Effect<unknown, unknown, infer R>] ? R : never;
+/** Recover the Effect error channel `E` (a union — any yielded effect may fail). */
+type ErrorsOf<Eff> = [EffectsOnly<Eff>] extends [Effect.Effect<unknown, infer E, unknown>] ? E : never;
+//#endregion
+//#region src/infrastructure/react/component.d.ts
+declare const RequirementsId: unique symbol;
+/**
+ * A React component produced by effract. It renders like any other component;
+ * the phantom `R` records which Effect services it needs from its `<Runtime>`,
+ * available for type-level introspection and runtime-binding helpers.
+ */
+interface Component<in Props, out R> {
+  (props: Props): ReactNode;
+  readonly [RequirementsId]?: R;
+}
+/**
+ * Define a React Effect Component. The body is a generator that may `yield*`
+ * Effect services and effects, and `yield* hook(...)` for React hooks.
+ *
+ * ```tsx
+ * const Dashboard = component(function* () {
+ *   const stats = yield* Stats;                         // Effect service
+ *   const [tab, setTab] = yield* hook(useState('overview')); // real React hook
+ *   return <Panel tab={tab} total={stats.total} onTab={setTab} />;
+ * });
+ * ```
+ */
+declare function component<Eff extends AnyEffect | Hook<unknown>, A extends ReactNode>(body: () => Generator<Eff, A, never>): Component<Record<never, never>, RequirementsOf<Eff>>;
+declare function component<Eff extends AnyEffect | Hook<unknown>, A extends ReactNode, Props>(body: (props: Props) => Generator<Eff, A, never>): Component<Props, RequirementsOf<Eff>>;
+/**
+ * Define a resolve-up-front component: a pure Effect (no hooks) rendered to a
+ * `ReactNode`. Services resolve synchronously from the runtime; async work
+ * suspends through React Suspense. This is the RSC-friendly mode.
+ *
+ * ```tsx
+ * const Header = view(Effect.gen(function* () {
+ *   const user = yield* CurrentUser;
+ *   return <h1>Welcome, {user.name}</h1>;
+ * }));
+ * ```
+ */
+declare function view<A extends ReactNode, E, R>(render: Effect.Effect<A, E, R>): Component<Record<never, never>, R>;
+declare function view<A extends ReactNode, E, R, Props>(render: (props: Props) => Effect.Effect<A, E, R>): Component<Props, R>;
+//#endregion
+//#region src/infrastructure/react/runtime.d.ts
+type AnyManagedRuntime = ManagedRuntime.ManagedRuntime<unknown, unknown>;
+interface RuntimeProps<ROut, E> {
+  /** A self-contained layer (no open requirements) providing the subtree's services. */
+  readonly layer: Layer.Layer<ROut, E, never>;
+  readonly children: ReactNode;
+}
+/**
+ * Provide an Effect runtime to a React subtree.
+ *
+ * ```tsx
+ * <Runtime layer={AppLive}>
+ *   <Dashboard />
+ * </Runtime>
+ * ```
+ */
+declare function Runtime<ROut, E>({
+  layer,
+  children
+}: RuntimeProps<ROut, E>): ReactNode;
+/** Escape hatch: the underlying `ManagedRuntime`, for imperative `runPromise`/`runFork`. */
+declare const useEffractRuntime: () => AnyManagedRuntime;
+//#endregion
+//#region src/infrastructure/react/reactivity.d.ts
+type Ref<A> = AtomRef.AtomRef<A>;
+/** Read an atom inside `observe`, subscribing the component to it. */
+type Read = <A>(ref: Ref<A>) => A;
+/** Create a reactive cell. Sugar for `AtomRef.make`. */
+declare const atom: <A>(initial: A) => Ref<A>;
+/**
+ * Subscribe to a derived view over one or more atoms. Re-renders precisely when
+ * a read atom changes.
+ *
+ * ```tsx
+ * const doubled = observe(($) => $(count) * 2);
+ * ```
+ */
+declare const observe: <A>(selector: (read: Read) => A) => A;
+/** Read a single atom's value, subscribing the component to it. */
+declare const useAtomValue: <A>(ref: Ref<A>) => A;
+/** A stable setter for an atom, supporting both values and updater functions. */
+declare const useAtomSet: <A>(ref: Ref<A>) => ((value: A | ((prev: A) => A)) => void);
+/** Read and write a single atom — the `useState` shape, backed by Effect. */
+declare const useAtom: <A>(ref: Ref<A>) => readonly [A, (value: A | ((prev: A) => A)) => void];
+interface ObserveProps<A extends ReactNode> {
+  readonly children: (read: Read) => A;
+}
+/** The render-prop form of {@link observe}. */
+declare const Observe: <A extends ReactNode>({
+  children
+}: ObserveProps<A>) => ReactNode;
+//#endregion
+//#region src/index.d.ts
+/**
+ * effract — write React components as Effect programs.
+ *
+ * The same component runs in a SPA, on a Bun/Node server, in a Web Worker, or
+ * as a React Server Component. "Server vs client" is an Effect runtime detail,
+ * supplied by a `<Runtime>` boundary — not an architectural fork.
+ *
+ * @packageDocumentation
+ */
+declare const VERSION = "0.1.0";
+//#endregion
+export { type AnyEffect, type Component, type ErrorsOf, type Hook, HookTypeId, Observe, type ObserveProps, type Read, type RecBody, type RecGenerator, type RequirementsOf, Runtime, type RuntimeProps, VERSION, type Yieldable, atom, component, hook, isHook, observe, useAtom, useAtomSet, useAtomValue, useEffractRuntime, view };

package/dist/index.mjs

@@ -0,0 +1,317 @@
+import { createContext, use, useCallback, useContext, useEffect, useMemo, useRef, useSyncExternalStore } from "react";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as ManagedRuntime from "effect/ManagedRuntime";
+import { jsx } from "react/jsx-runtime";
+import * as Equal from "effect/Equal";
+import { AtomRef } from "effect/unstable/reactivity";
+//#region src/domain/protocol.ts
+/** Brand identifying a lifted React hook instruction. */
+const HookTypeId = Symbol.for("@tmonier/effract/Hook");
+/**
+* Lift an already-evaluated React hook result into the effract yield channel.
+*
+* ```ts
+* const [tab, setTab] = yield* hook(useState('overview'));
+* const ref = yield* hook(useRef<HTMLDivElement>(null));
+* ```
+*
+* Because the component body runs synchronously inside React's render pass, the
+* wrapped hook call obeys the Rules of Hooks: same order on every render.
+*/
+const hook = (value) => {
+	const self = {
+		[HookTypeId]: true,
+		value,
+		[Symbol.iterator]() {
+			let yielded = false;
+			return { next(sent) {
+				if (yielded) return {
+					done: true,
+					value: sent
+				};
+				yielded = true;
+				return {
+					done: false,
+					value: self
+				};
+			} };
+		}
+	};
+	return self;
+};
+/** Type guard: is this yielded instruction a lifted hook? */
+const isHook = (u) => typeof u === "object" && u !== null && HookTypeId in u;
+//#endregion
+//#region src/application/interpreter.ts
+/**
+* The interpreter — the bridge between React's fiber and Effect's fiber.
+*
+* React drives a component by calling its function during a render pass.
+* `driveRec` runs *inside* that pass: it walks the component's generator
+* synchronously, and for every `yield*` it decides who answers.
+*
+*   - a lifted hook  → the React hook already ran inline; unwrap its value
+*   - a service Tag  → resolve it synchronously from the runtime's context
+*   - a sync Effect  → run it synchronously, return its value
+*   - an async Effect → suspend through React's `use`, resuming on the retry
+*
+* Because the walk is synchronous and deterministic, the user's hook calls keep
+* a stable order across renders — they are, and remain, ordinary React hooks.
+* Nothing here forks React's reconciler; it cooperates with it.
+*/
+/**
+* Resolve a single yielded Effect against the runtime. Synchronous effects
+* (services, pure computation, ref reads) return immediately. An effect that
+* cannot finish synchronously surfaces as an `AsyncFiberError`; we route it
+* through React Suspense with a promise cached by encounter order, so the
+* retry after the promise settles returns the value inline. Any other failure
+* is a real error and is thrown to the nearest React error boundary.
+*/
+const resolveEffect = (effect, deps, state) => {
+	if (!Effect.isEffect(effect)) throw new TypeError("effract: a component body yielded a value that is neither an Effect nor a hook(...). Wrap React hooks with `hook(...)`, e.g. `yield* hook(useState(0))`.");
+	const exit = deps.executor.runSyncExit(effect);
+	if (Exit.isSuccess(exit)) return exit.value;
+	const squashed = Cause.squash(exit.cause);
+	if (Cause.isAsyncFiberError(squashed)) {
+		const index = state.index++;
+		let slot = deps.cache.get(index);
+		if (slot === void 0) {
+			slot = { promise: deps.executor.runPromise(effect) };
+			deps.cache.set(index, slot);
+		}
+		return deps.suspender.use(slot.promise);
+	}
+	throw squashed;
+};
+/**
+* Run a React Effect Component body to its rendered result. Creates a fresh
+* generator per render (generators are single-use); a Suspense retry simply
+* runs this again from the top, replaying hooks in order and hitting the async
+* cache for already-started work.
+*/
+const driveRec = (gen, deps) => {
+	const state = { index: 0 };
+	let step = gen.next();
+	while (!step.done) {
+		const instruction = step.value;
+		const result = isHook(instruction) ? instruction.value : resolveEffect(instruction, deps, state);
+		step = gen.next(result);
+	}
+	return step.value;
+};
+//#endregion
+//#region src/infrastructure/react/runtime.tsx
+/**
+* The `<Runtime>` boundary. It builds an Effect `ManagedRuntime` once from a
+* `Layer` and hands it down through React context, where every effract
+* component reads it. This is the seam where "server vs client" lives: provide
+* a browser layer and the same components run in a SPA; provide a server layer
+* and they run under Node, Bun, or a Web Worker — the components never change.
+*
+* Services are resolved up-front into the runtime's context (the RSC-style
+* "resolve near the root" mode), so reading a service inside a component is a
+* synchronous context lookup, not an async round-trip.
+*/
+const RuntimeContext = createContext(null);
+const executorFromRuntime = (runtime) => ({
+	runSyncExit: (effect) => runtime.runSyncExit(effect),
+	runPromise: (effect) => runtime.runPromise(effect)
+});
+/**
+* Provide an Effect runtime to a React subtree.
+*
+* ```tsx
+* <Runtime layer={AppLive}>
+*   <Dashboard />
+* </Runtime>
+* ```
+*/
+function Runtime({ layer, children }) {
+	const runtimeRef = useRef(null);
+	if (runtimeRef.current === null) runtimeRef.current = ManagedRuntime.make(layer);
+	const runtime = runtimeRef.current;
+	const value = useMemo(() => ({
+		executor: executorFromRuntime(runtime),
+		runtime
+	}), [runtime]);
+	useEffect(() => () => void runtime.dispose(), [runtime]);
+	return /* @__PURE__ */ jsx(RuntimeContext.Provider, {
+		value,
+		children
+	});
+}
+const useRuntimeContext = () => {
+	const value = useContext(RuntimeContext);
+	if (value === null) throw new Error("effract: no <Runtime> found above this component. Wrap your tree in <Runtime layer={...}>.");
+	return value;
+};
+/** Internal: the executor the interpreter runs effects through. */
+const useExecutor = () => useRuntimeContext().executor;
+/** Escape hatch: the underlying `ManagedRuntime`, for imperative `runPromise`/`runFork`. */
+const useEffractRuntime = () => useRuntimeContext().runtime;
+//#endregion
+//#region src/infrastructure/react/component.tsx
+/**
+* The two ways to write a component as an Effect program.
+*
+*   component(function* () { ... })   the headline: a *React Effect Component*
+*                                     whose body yields both Effect services
+*                                     and React hooks, interpreted inside the
+*                                     render pass.
+*
+*   view(Effect | (props) => Effect)  the simpler resolve-up-front mode: a pure
+*                                     Effect with no hooks, ideal for server /
+*                                     RSC rendering.
+*
+* Both produce a genuine React function component. There is no custom
+* reconciler — `<Dashboard />` is a real element React renders, suspends, and
+* reconciles like any other.
+*/
+const useSuspender = () => ({ use });
+const useRenderCache = () => {
+	const ref = useRef(void 0);
+	if (ref.current === void 0) ref.current = /* @__PURE__ */ new Map();
+	return ref.current;
+};
+function component(body) {
+	const Rec = (props) => {
+		const executor = useExecutor();
+		const suspender = useSuspender();
+		const cache = useRenderCache();
+		return driveRec(body(props), {
+			executor,
+			suspender,
+			cache
+		});
+	};
+	Rec.displayName = body.name || "EffractComponent";
+	return Rec;
+}
+function view(render) {
+	const View = (props) => {
+		const executor = useExecutor();
+		const suspender = useSuspender();
+		const cache = useRenderCache();
+		return resolveEffect(typeof render === "function" ? render(props) : render, {
+			executor,
+			suspender,
+			cache
+		}, { index: 0 });
+	};
+	View.displayName = "EffractView";
+	return View;
+}
+//#endregion
+//#region src/infrastructure/react/reactivity.tsx
+/**
+* The signals bridge. Effect's reactive cell is `AtomRef`; this binds it to
+* React so a component re-renders precisely when — and only when — an atom it
+* actually read changes.
+*
+*   observe($ => $(count) * 2)          // a hook: read + auto-subscribe
+*   <Observe>{$ => <b>{$(count)}</b>}</Observe>   // the same, as an element
+*   const [n, setN] = useAtom(count)    // read + write a single atom
+*
+* `observe` tracks exactly the atoms touched during its selector and subscribes
+* to that set, re-tracking on every change so dynamic dependencies stay
+* correct. No `Effect.runSync` at the call site, no manual dependency arrays.
+*/
+/** Create a reactive cell. Sugar for `AtomRef.make`. */
+const atom = (initial) => AtomRef.make(initial);
+const depsEqual = (a, b) => {
+	if (a.size !== b.size) return false;
+	for (const [ref, value] of a) if (!b.has(ref) || !Equal.equals(value, b.get(ref))) return false;
+	return true;
+};
+/**
+* Run the selector, tracking which atoms it reads. Returns a *stable* reference
+* when the tracked atoms and their values are unchanged, so it is safe to call
+* from `getSnapshot` without provoking a render loop.
+*/
+const compute = (state) => {
+	const nextDeps = /* @__PURE__ */ new Map();
+	const read = (ref) => {
+		const value = ref.value;
+		nextDeps.set(ref, value);
+		return value;
+	};
+	const next = state.selector(read);
+	if (state.initialized && depsEqual(state.deps, nextDeps)) {
+		state.deps = nextDeps;
+		return state.value;
+	}
+	state.deps = nextDeps;
+	state.value = next;
+	state.initialized = true;
+	return next;
+};
+/**
+* Subscribe to a derived view over one or more atoms. Re-renders precisely when
+* a read atom changes.
+*
+* ```tsx
+* const doubled = observe(($) => $(count) * 2);
+* ```
+*/
+const observe = (selector) => {
+	const stateRef = useRef(null);
+	if (stateRef.current === null) stateRef.current = {
+		selector,
+		deps: /* @__PURE__ */ new Map(),
+		value: void 0,
+		initialized: false
+	};
+	stateRef.current.selector = selector;
+	const subscribe = useCallback((onStoreChange) => {
+		const state = stateRef.current;
+		if (state === null) return () => {};
+		let unsubscribes = [];
+		const resubscribe = () => {
+			for (const unsub of unsubscribes) unsub();
+			unsubscribes = [...state.deps.keys()].map((ref) => ref.subscribe(handleChange));
+		};
+		function handleChange() {
+			compute(state);
+			resubscribe();
+			onStoreChange();
+		}
+		compute(state);
+		resubscribe();
+		return () => {
+			for (const unsub of unsubscribes) unsub();
+		};
+	}, []);
+	const getSnapshot = useCallback(() => compute(stateRef.current), []);
+	return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+};
+/** Read a single atom's value, subscribing the component to it. */
+const useAtomValue = (ref) => {
+	const subscribe = useCallback((onStoreChange) => ref.subscribe(onStoreChange), [ref]);
+	const getSnapshot = useCallback(() => ref.value, [ref]);
+	return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+};
+/** A stable setter for an atom, supporting both values and updater functions. */
+const useAtomSet = (ref) => useCallback((value) => {
+	if (typeof value === "function") ref.update(value);
+	else ref.set(value);
+}, [ref]);
+/** Read and write a single atom — the `useState` shape, backed by Effect. */
+const useAtom = (ref) => [useAtomValue(ref), useAtomSet(ref)];
+/** The render-prop form of {@link observe}. */
+const Observe = ({ children }) => observe(children);
+//#endregion
+//#region src/index.ts
+/**
+* effract — write React components as Effect programs.
+*
+* The same component runs in a SPA, on a Bun/Node server, in a Web Worker, or
+* as a React Server Component. "Server vs client" is an Effect runtime detail,
+* supplied by a `<Runtime>` boundary — not an architectural fork.
+*
+* @packageDocumentation
+*/
+const VERSION = "0.1.0";
+//#endregion
+export { HookTypeId, Observe, Runtime, VERSION, atom, component, hook, isHook, observe, useAtom, useAtomSet, useAtomValue, useEffractRuntime, view };

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@tmonier/effract",
+  "version": "0.1.0",
+  "description": "React components written as Effect programs. yield* services and React hooks in one render pass; run the same component anywhere.",
+  "keywords": [
+    "effect",
+    "fiber",
+    "react",
+    "react-server-components",
+    "reactivity",
+    "rsc",
+    "signals",
+    "ssr"
+  ],
+  "homepage": "https://github.com/get-tmonier/effract#readme",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/get-tmonier/effract.git",
+    "directory": "packages/effract"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "imports": {
+    "#domain/*": "./src/domain/*",
+    "#application/*": "./src/application/*",
+    "#infrastructure/*": "./src/infrastructure/*"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/react": "19.2.17",
+    "@types/react-dom": "19.2.3",
+    "effect": "4.0.0-beta.88",
+    "happy-dom": "20.10.6",
+    "react": "19.2.7",
+    "react-dom": "19.2.7",
+    "tsdown": "0.22.3",
+    "vitest": "4.1.9"
+  },
+  "peerDependencies": {
+    "effect": "4.0.0-beta.88",
+    "react": "19.2.7"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run"
+  }
+}