@nwire/apollo 0.10.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alex Gefter / 200apps Ltd.
+
+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,103 @@
+# @nwire/apollo
+
+> Apollo Server (v4) interop — plug Nwire actions into a GraphQL schema as field resolvers; reuse a hand-authored schema you already maintain.
+
+## What it is
+
+A thin adapter (~60 LOC of real code). `actionResolver(action)` wraps a Nwire `ActionDefinition` so it serves as a GraphQL field resolver. `nwireApolloContext({ runtime })` injects the runtime + a fresh envelope onto every request. `mountNwireOnApollo(...)` bundles the context factory with Nwire-aware error formatting so `defineError` errors surface with stable `extensions.code`.
+
+Same migration story Express got: keep the schema and gateway you already have, stop hand-writing resolver bodies that just call services.
+
+> A native GraphQL transport (schema generated from actions/queries automatically, subscriptions on top of `@nwire/bus`) is a separate roadmap item. **This package is for teams already running Apollo with a hand-authored schema.** Cross-link: [`@nwire/express`](../nwire-http-express/README.md).
+
+## Install
+
+```bash
+pnpm add @nwire/apollo @apollo/server graphql
+```
+
+`@apollo/server` (^4) and `graphql` (^16) are peer deps — bring whatever versions your Apollo setup already uses. Apollo v3 is EOL and unsupported.
+
+## Quickstart
+
+```ts
+import { z } from "zod";
+import { ApolloServer } from "@apollo/server";
+import { startStandaloneServer } from "@apollo/server/standalone";
+import gql from "graphql-tag";
+import { defineAction, Runtime } from "@nwire/forge";
+import { actionResolver, mountNwireOnApollo } from "@nwire/apollo";
+
+const submitAnswer = defineAction({
+  name: "submissions.submit-answer",
+  schema: z.object({ questionId: z.string(), answer: z.string() }),
+  handler: async (input, ctx) => ({
+    id: "sub-1",
+    ...input,
+    student: ctx.envelope.userId,
+  }),
+});
+
+const runtime = new Runtime();
+runtime.registerHandler(submitAnswer.handler!);
+
+const typeDefs = gql`
+  input SubmitAnswerInput {
+    questionId: String!
+    answer: String!
+  }
+  type Submission {
+    id: ID!
+    questionId: String!
+    answer: String!
+    student: String
+  }
+  type Mutation {
+    submitAnswer(input: SubmitAnswerInput!): Submission!
+  }
+  type Query {
+    _: Boolean
+  }
+`;
+
+const apollo = new ApolloServer({
+  typeDefs,
+  resolvers: {
+    Mutation: { submitAnswer: actionResolver(submitAnswer) },
+  },
+  ...mountNwireOnApollo({ runtime }),
+});
+
+await startStandaloneServer(apollo, { listen: { port: 4000 } });
+```
+
+`actionResolver` reads `args.input` by default (matches GraphQL convention for mutation inputs); customise via `extractInput` for query-style flat args. Dispatched actions return their handler value verbatim to the GraphQL response — emit events, no events, return a plain object, whatever the handler does.
+
+## API
+
+- `actionResolver(action, options?)` — `ActionDefinition` → GraphQL field resolver. Options: `extractInput`, `extractEnvelope`, `resolveRuntime`.
+- `nwireApolloContext({ runtime, extractEnvelope?, extractUser? })` — Apollo `context` factory that injects `runtime` + envelope per request.
+- `mountNwireOnApollo({ runtime, ... })` — convenience bundle: returns `{ context, formatError }` you spread into `ApolloServer` constructor + `startStandaloneServer` options.
+- `formatNwireError(formattedError, rawError)` — standalone `formatError` callback. Use directly if you compose your own error formatter.
+
+## Errors
+
+When a handler throws a `defineError`-style value (e.g. `QuestionLocked`), GraphQL clients receive:
+
+```json
+{
+  "errors": [
+    {
+      "message": "Question is locked for further submissions.",
+      "extensions": { "code": "QUESTION_LOCKED", "status": 423 }
+    }
+  ]
+}
+```
+
+Same stable `code` the REST transport emits — clients can branch on `extensions.code` and ignore wire format.
+
+## See also
+
+- [`@nwire/express`](../nwire-http-express/README.md) — same architectural pattern for Express interop.
+- [`docs/recipes/apollo-interop.md`](../../docs/recipes/apollo-interop.md) — full recipe with auth header extraction + per-resolver overrides.

package/dist/apollo-interop.d.ts

@@ -0,0 +1,191 @@
+/**
+ * `@nwire/apollo` — Apollo Server (v4) interop, adapter form.
+ *
+ * Three exports, each tiny:
+ *
+ *   - `actionResolver(action, options?)` — wraps a Nwire `ActionDefinition`
+ *     so it can be plugged into a GraphQL schema as a field resolver. The
+ *     returned function reads input from `args`, builds an envelope from
+ *     Apollo's per-request context (tenant / user — caller-controlled via
+ *     `extractEnvelope`), dispatches via the runtime found on the GraphQL
+ *     context, and returns the action result.
+ *
+ *   - `nwireApolloContext({ runtime })` — Apollo `context` callback factory.
+ *     Returns a function that injects `runtime` + a freshly-seeded envelope
+ *     onto every request's GraphQL context. Resolvers built by
+ *     `actionResolver` read both off this context; user-authored resolvers
+ *     can use `ctx.runtime.dispatch(...)` directly.
+ *
+ *   - `mountNwireOnApollo({ apollo, runtime })` — convenience constructor
+ *     options builder. Returns the option bag (`context`, `formatError`)
+ *     you spread into Apollo's HTTP integration (e.g.
+ *     `startStandaloneServer(server, mountNwireOnApollo({...}))`). The
+ *     `formatError` step recognises `NwireError` (from `defineError`) and
+ *     surfaces its `code` in `extensions.code`, mapping to the stable error
+ *     contract the rest of the framework already exposes over REST.
+ *
+ * The whole package is ~60 LOC of real code. Same architectural invariant
+ * as `@nwire/express`: with the Runtime as the universal dispatch
+ * joint, the adapter is plumbing — no shadow execution, no proxy, no
+ * translation layer. An action stays the source of truth; Apollo is just
+ * one more way to invoke it.
+ *
+ * ## Why an adapter, not a transport
+ *
+ * `@nwire/graphql` ships a native GraphQL transport — schema generated
+ * from actions/queries automatically, with subscriptions on top of
+ * `@nwire/bus`. That story is for greenfield Nwire services that pick
+ * GraphQL as their primary interface.
+ *
+ * This package is for the OTHER case: a team already running Apollo with
+ * a hand-authored schema. They want to keep that schema (and their gateway,
+ * persisted queries, federation, cache hints — everything) and just stop
+ * writing boilerplate resolvers. `actionResolver(submitAnswer)` is the
+ * one-liner that says "this GraphQL field is implemented by this Nwire
+ * action" — same migration story Express got.
+ */
+import type { ActionDefinition, ForgeApp } from "@nwire/forge";
+import { type MessageEnvelope } from "@nwire/envelope";
+import type { ApolloServerOptions, BaseContext } from "@apollo/server";
+import type { GraphQLFormattedError } from "graphql";
+/**
+ * The minimal GraphQL context surface that Nwire-aware resolvers expect.
+ * `nwireApolloContext` produces exactly this shape; user-extended contexts
+ * should intersect it (`type MyCtx = NwireApolloContext & { …app fields }`).
+ */
+export interface NwireApolloContext extends BaseContext {
+    /** The Nwire app to dispatch actions through. */
+    readonly app: ForgeApp;
+    /**
+     * The fresh envelope seeded for this GraphQL request. Resolvers can
+     * dispatch through `runtime` and the envelope will be derived as a
+     * child of this one, so the entire request stays correlated.
+     */
+    readonly envelope: MessageEnvelope;
+    /**
+     * Authenticated principal, if any. Free-form `unknown` here — the
+     * upstream integration (an Apollo plugin / @nwire/auth-better-auth
+     * verifier / a custom middleware) is responsible for typing it.
+     */
+    readonly user?: unknown;
+}
+/**
+ * Options for `actionResolver`. All optional.
+ *
+ *   - `extractInput` — how to derive the action input from `args`. Default:
+ *     pull `args.input` if present, else the whole `args` object. The
+ *     action's zod schema is the source of truth either way (`runtime.
+ *     dispatch` re-validates), so callers only need this to flatten
+ *     non-standard arg shapes.
+ *
+ *   - `extractEnvelope` — how to derive envelope overrides (tenant, userId,
+ *     user) from the GraphQL context. Default: read `context.envelope` if
+ *     present, else seed a fresh envelope from `context.user`. Override to
+ *     plug in your own auth shape (`ctx.session.userId`, `ctx.tenant`, etc).
+ */
+export interface ActionResolverOptions<TContext extends BaseContext = NwireApolloContext> {
+    readonly extractInput?: (args: Record<string, unknown>, context: TContext) => unknown;
+    readonly extractEnvelope?: (context: TContext) => MessageEnvelope;
+    /**
+     * How to find the app. Defaults to `context.app`. Provide this if
+     * your context shape names the app differently or pulls it from a
+     * DI container.
+     */
+    readonly resolveApp?: (context: TContext) => ForgeApp;
+}
+/**
+ * Wrap a Nwire `ActionDefinition` as a GraphQL field resolver.
+ *
+ * ```ts
+ * import { actionResolver, nwireApolloContext } from "@nwire/apollo"
+ *
+ * const resolvers = {
+ *   Mutation: {
+ *     submitAnswer: actionResolver(submitAnswer),
+ *   },
+ * }
+ *
+ * const apollo = new ApolloServer({ typeDefs, resolvers })
+ * await startStandaloneServer(apollo, {
+ *   context: nwireApolloContext({ runtime }),
+ * })
+ * ```
+ *
+ * The resolver signature returned matches Apollo's standard
+ * `(parent, args, context, info)` — it's a plain function. Errors thrown
+ * by the handler (including `defineError` values) propagate to Apollo as
+ * normal; pair with `mountNwireOnApollo`'s `formatError` to surface the
+ * stable error code in `extensions.code`.
+ */
+export declare function actionResolver<TContext extends NwireApolloContext = NwireApolloContext>(action: ActionDefinition, options?: ActionResolverOptions<TContext>): (parent: unknown, args: Record<string, unknown>, context: TContext) => Promise<unknown>;
+/**
+ * Build an Apollo `context` callback that injects `runtime` + a fresh
+ * envelope onto every request's GraphQL context.
+ *
+ * ```ts
+ * await startStandaloneServer(apollo, {
+ *   context: nwireApolloContext({
+ *     runtime,
+ *     // Optional: derive tenant + user from the HTTP request headers.
+ *     extractEnvelope: ({ req }) => seedEnvelope({
+ *       tenant: req.headers["x-tenant-id"] as string | undefined,
+ *       userId: req.headers["x-user-id"] as string | undefined,
+ *     }),
+ *   }),
+ * })
+ * ```
+ *
+ * Generic over the integration-specific arg shape Apollo passes to the
+ * context callback (e.g. `{ req, res }` for express middleware,
+ * `{ req }` for the standalone server). Default `unknown` keeps the
+ * type usable in any integration without a forced cast.
+ */
+export interface NwireApolloContextOptions<TArgs = unknown> {
+    readonly app: ForgeApp;
+    /**
+     * Build a request-scoped envelope. The integration arg (`req`, headers,
+     * etc.) is available so caller can read auth headers. Defaults to a
+     * fresh seeded envelope with no tenant / user — fine for unauth dev
+     * workflows.
+     */
+    readonly extractEnvelope?: (args: TArgs) => MessageEnvelope;
+    /** Build an arbitrary `user` value alongside the envelope. */
+    readonly extractUser?: (args: TArgs) => unknown;
+}
+export declare function nwireApolloContext<TArgs = unknown>(options: NwireApolloContextOptions<TArgs>): (args: TArgs) => Promise<NwireApolloContext>;
+/**
+ * Build the Apollo Server constructor options bundle that registers Nwire
+ * error formatting. Spread the result into `ApolloServerOptions` (or use
+ * the individual exports `formatNwireError` / `nwireApolloContext`
+ * directly).
+ *
+ * ```ts
+ * const apollo = new ApolloServer({
+ *   typeDefs,
+ *   resolvers,
+ *   ...mountNwireOnApollo({ runtime }),
+ * })
+ * ```
+ *
+ * What it sets up:
+ *   - `formatError` — recognises `NwireError` (`defineError` instances)
+ *     and surfaces `code` in `extensions.code`, plus `status` and `tags`
+ *     for clients that care. Non-Nwire errors pass through unchanged.
+ *   - The matching `context` factory you'd pass to your HTTP integration
+ *     is included as `context` for convenience; pull it out and pass to
+ *     `startStandaloneServer` / `expressMiddleware` as appropriate.
+ */
+export interface MountNwireOptions<TArgs = unknown> {
+    readonly app: ForgeApp;
+    readonly extractEnvelope?: (args: TArgs) => MessageEnvelope;
+    readonly extractUser?: (args: TArgs) => unknown;
+}
+export declare function mountNwireOnApollo<TArgs = unknown>(options: MountNwireOptions<TArgs>): Pick<ApolloServerOptions<NwireApolloContext>, "formatError"> & {
+    context: (args: TArgs) => Promise<NwireApolloContext>;
+};
+/**
+ * Apollo `formatError` callback that maps `NwireError` instances onto
+ * GraphQL error extensions. Exposed standalone so consumers using their
+ * own custom `formatError` can compose it.
+ */
+export declare function formatNwireError(formattedError: GraphQLFormattedError, rawError: unknown): GraphQLFormattedError;

package/dist/apollo-interop.js

@@ -0,0 +1,148 @@
+/**
+ * `@nwire/apollo` — Apollo Server (v4) interop, adapter form.
+ *
+ * Three exports, each tiny:
+ *
+ *   - `actionResolver(action, options?)` — wraps a Nwire `ActionDefinition`
+ *     so it can be plugged into a GraphQL schema as a field resolver. The
+ *     returned function reads input from `args`, builds an envelope from
+ *     Apollo's per-request context (tenant / user — caller-controlled via
+ *     `extractEnvelope`), dispatches via the runtime found on the GraphQL
+ *     context, and returns the action result.
+ *
+ *   - `nwireApolloContext({ runtime })` — Apollo `context` callback factory.
+ *     Returns a function that injects `runtime` + a freshly-seeded envelope
+ *     onto every request's GraphQL context. Resolvers built by
+ *     `actionResolver` read both off this context; user-authored resolvers
+ *     can use `ctx.runtime.dispatch(...)` directly.
+ *
+ *   - `mountNwireOnApollo({ apollo, runtime })` — convenience constructor
+ *     options builder. Returns the option bag (`context`, `formatError`)
+ *     you spread into Apollo's HTTP integration (e.g.
+ *     `startStandaloneServer(server, mountNwireOnApollo({...}))`). The
+ *     `formatError` step recognises `NwireError` (from `defineError`) and
+ *     surfaces its `code` in `extensions.code`, mapping to the stable error
+ *     contract the rest of the framework already exposes over REST.
+ *
+ * The whole package is ~60 LOC of real code. Same architectural invariant
+ * as `@nwire/express`: with the Runtime as the universal dispatch
+ * joint, the adapter is plumbing — no shadow execution, no proxy, no
+ * translation layer. An action stays the source of truth; Apollo is just
+ * one more way to invoke it.
+ *
+ * ## Why an adapter, not a transport
+ *
+ * `@nwire/graphql` ships a native GraphQL transport — schema generated
+ * from actions/queries automatically, with subscriptions on top of
+ * `@nwire/bus`. That story is for greenfield Nwire services that pick
+ * GraphQL as their primary interface.
+ *
+ * This package is for the OTHER case: a team already running Apollo with
+ * a hand-authored schema. They want to keep that schema (and their gateway,
+ * persisted queries, federation, cache hints — everything) and just stop
+ * writing boilerplate resolvers. `actionResolver(submitAnswer)` is the
+ * one-liner that says "this GraphQL field is implemented by this Nwire
+ * action" — same migration story Express got.
+ */
+import { isNwireError } from "@nwire/forge";
+import { seedEnvelope } from "@nwire/envelope";
+/**
+ * Wrap a Nwire `ActionDefinition` as a GraphQL field resolver.
+ *
+ * ```ts
+ * import { actionResolver, nwireApolloContext } from "@nwire/apollo"
+ *
+ * const resolvers = {
+ *   Mutation: {
+ *     submitAnswer: actionResolver(submitAnswer),
+ *   },
+ * }
+ *
+ * const apollo = new ApolloServer({ typeDefs, resolvers })
+ * await startStandaloneServer(apollo, {
+ *   context: nwireApolloContext({ runtime }),
+ * })
+ * ```
+ *
+ * The resolver signature returned matches Apollo's standard
+ * `(parent, args, context, info)` — it's a plain function. Errors thrown
+ * by the handler (including `defineError` values) propagate to Apollo as
+ * normal; pair with `mountNwireOnApollo`'s `formatError` to surface the
+ * stable error code in `extensions.code`.
+ */
+export function actionResolver(action, options = {}) {
+    const extractInput = options.extractInput ??
+        ((args) => 
+        // GraphQL convention: mutation inputs land under `input`. Fall back
+        // to the whole args object so query-style resolvers (where each arg
+        // is named separately) work without configuration.
+        "input" in args ? args.input : args);
+    const resolveApp = options.resolveApp ?? ((ctx) => ctx.app);
+    const extractEnvelope = options.extractEnvelope ??
+        ((ctx) => 
+        // If `nwireApolloContext` is used the envelope is already on the
+        // context; otherwise fall back to seeding one from the loose user
+        // field. Either way `runtime.dispatch` derives a child envelope for
+        // the actual action, so this just sets the root of the chain.
+        ctx.envelope ?? seedEnvelope({ user: ctx.user }));
+    return async (_parent, args, context) => {
+        const app = resolveApp(context);
+        const envelope = extractEnvelope(context);
+        const input = extractInput(args, context);
+        return app.dispatch(action, input, envelope);
+    };
+}
+export function nwireApolloContext(options) {
+    const { app, extractEnvelope, extractUser } = options;
+    return async (args) => {
+        const user = extractUser?.(args);
+        const envelope = extractEnvelope?.(args) ?? seedEnvelope(user !== undefined ? { user } : {});
+        return { app, envelope, user };
+    };
+}
+export function mountNwireOnApollo(options) {
+    return {
+        formatError: formatNwireError,
+        context: nwireApolloContext({
+            app: options.app,
+            extractEnvelope: options.extractEnvelope,
+            extractUser: options.extractUser,
+        }),
+    };
+}
+/**
+ * Apollo `formatError` callback that maps `NwireError` instances onto
+ * GraphQL error extensions. Exposed standalone so consumers using their
+ * own custom `formatError` can compose it.
+ */
+export function formatNwireError(formattedError, rawError) {
+    // Apollo wraps the thrown error inside GraphQLError.originalError —
+    // we accept it on the raw error or one level deep.
+    const candidate = pickNwireError(rawError);
+    if (!candidate)
+        return formattedError;
+    return {
+        ...formattedError,
+        message: candidate.summary,
+        extensions: {
+            ...formattedError.extensions,
+            code: candidate.code,
+            status: candidate.status,
+            ...(candidate.tags ? { tags: candidate.tags } : {}),
+        },
+    };
+}
+/**
+ * Look at the value Apollo handed `formatError` and return a `NwireError`
+ * if there's one to find — either directly or as the wrapped
+ * `originalError` of a `GraphQLError`. Returns `undefined` otherwise so
+ * callers can fall through to default formatting.
+ */
+function pickNwireError(raw) {
+    if (isNwireError(raw))
+        return raw;
+    const wrapped = raw?.originalError;
+    if (isNwireError(wrapped))
+        return wrapped;
+    return undefined;
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `@nwire/apollo` — Apollo Server (v4) interop adapter.
+ *
+ * Three exports cover the surface:
+ *
+ *   - `actionResolver(action)` — wrap a Nwire ActionDefinition as a GraphQL
+ *     field resolver. The action stays the source of truth; Apollo gets a
+ *     thin resolver that dispatches through the runtime.
+ *
+ *   - `nwireApolloContext({ runtime, ... })` — Apollo `context` factory
+ *     that injects `runtime` + a fresh envelope onto every request.
+ *
+ *   - `mountNwireOnApollo({ runtime, ... })` — convenience bundle: pairs
+ *     the context factory with Nwire-aware error formatting so
+ *     `defineError` values surface with stable `extensions.code`.
+ *
+ * See the README + `docs/recipes/apollo-interop.md` for the quickstart.
+ */
+export { actionResolver, formatNwireError, mountNwireOnApollo, nwireApolloContext, type ActionResolverOptions, type MountNwireOptions, type NwireApolloContext, type NwireApolloContextOptions, } from "./apollo-interop.js";

package/dist/index.js

@@ -0,0 +1,19 @@
+/**
+ * `@nwire/apollo` — Apollo Server (v4) interop adapter.
+ *
+ * Three exports cover the surface:
+ *
+ *   - `actionResolver(action)` — wrap a Nwire ActionDefinition as a GraphQL
+ *     field resolver. The action stays the source of truth; Apollo gets a
+ *     thin resolver that dispatches through the runtime.
+ *
+ *   - `nwireApolloContext({ runtime, ... })` — Apollo `context` factory
+ *     that injects `runtime` + a fresh envelope onto every request.
+ *
+ *   - `mountNwireOnApollo({ runtime, ... })` — convenience bundle: pairs
+ *     the context factory with Nwire-aware error formatting so
+ *     `defineError` values surface with stable `extensions.code`.
+ *
+ * See the README + `docs/recipes/apollo-interop.md` for the quickstart.
+ */
+export { actionResolver, formatNwireError, mountNwireOnApollo, nwireApolloContext, } from "./apollo-interop.js";

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@nwire/apollo",
+  "version": "0.10.0",
+  "description": "Nwire — Apollo Server (v4) interop adapter. actionResolver(action) plugs a Nwire ActionDefinition into a GraphQL schema as a field resolver; nwireApolloContext({ runtime }) adds runtime.dispatch + envelope to Apollo's per-request context; mountNwireOnApollo() registers Nwire-aware error mapping (defineError -> extensions.code). Opt-in, peer dep, ~60 LOC of real code.",
+  "keywords": [
+    "adapter",
+    "apollo",
+    "graphql",
+    "interop",
+    "nwire"
+  ],
+  "license": "MIT",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@nwire/forge": "0.10.0",
+    "@nwire/envelope": "0.10.0"
+  },
+  "devDependencies": {
+    "@apollo/server": "^4.11.0",
+    "@types/node": "^22.19.9",
+    "graphql": "^16.9.0",
+    "graphql-tag": "^2.12.6",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18",
+    "zod": "^4.0.0"
+  },
+  "peerDependencies": {
+    "@apollo/server": "^4.0.0",
+    "graphql": "^16.0.0"
+  },
+  "scripts": {
+    "build": "tsc && node ../../scripts/fix-dist-extensions.mjs dist",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit"
+  }
+}