@radsoft/markbase 2026.8.1

package/README.md

@@ -0,0 +1,153 @@
+# @radsoft/markbase
+
+Official Node client for the [Markbase](https://markbase.co) USPTO trademark API.
+Search, screen, and look up 14M+ US trademarks with full TypeScript types.
+
+Covers the **USPTO only**. If you need EUIPO, WIPO, or UKIPO, a multi-office
+platform is a better fit.
+
+```bash
+npm i @radsoft/markbase
+```
+
+## Quick start
+
+No key needed to try it — the keyless tier allows 1,000 requests a month.
+[Get a free key](https://markbase.co/login) for 5,000.
+
+```ts
+import { Markbase } from "@radsoft/markbase";
+
+const mb = new Markbase({ apiKey: process.env.MARKBASE_API_KEY });
+
+// "can we call it this?"
+const result = await mb.clearance("Acme", { trademarkClass: 9 });
+if (result.highest_risk === "high") {
+  console.log("Conflicts:", result.matches.map((m) => m.word_mark));
+}
+```
+
+The key is read from `MARKBASE_API_KEY` if you don't pass one. Pass `apiKey: null`
+to force the keyless tier even when that variable is set.
+
+## Screening a name
+
+Trademark rights are scoped to goods and services — DELTA coexists as an airline,
+a faucet maker, and dental insurance. **Always pass a class**, or you get noise
+instead of blockers.
+
+```ts
+const { highest_risk, matches } = await mb.clearance("nikee", { trademarkClass: 25 });
+// highest_risk: "high"
+// matches[0]: { word_mark: "NIKE", owner_name: "Nike, Inc.", similarity: 0.85, risk: "high" }
+```
+
+`mb.classes()` returns all 45 Nice classes if you need to pick one.
+
+## Searching
+
+Typo-tolerant — `gogle` finds Google's marks.
+
+```ts
+const res = await mb.search({ q: "gogle", limit: 10 });
+
+// filters
+await mb.search({
+  q: "acme",
+  trademarkClass: 9,        // 9 and "009" both work
+  statusCode: "800",        // registered
+  ownerCountry: "US",
+  filingDateFrom: "20200101",
+});
+```
+
+`total_hits` is capped at 1,000 by the search engine — narrow with filters when
+you need an exact count, or use `aggregate()`.
+
+Walk large result sets without managing pages:
+
+```ts
+for await (const mark of mb.paginate({ q: "coffee", limit: 100 }, 5)) {
+  console.log(mark.word_mark);
+}
+```
+
+## Everything else
+
+```ts
+await mb.suggest("nik", 5);              // autocomplete, tuned for as-you-type
+await mb.getTrademark("72414177");       // one full record
+await mb.getTimeline("72414177");        // prosecution history
+await mb.byOwner("Nike, Inc.");          // an owner's whole portfolio
+await mb.aggregate("class");             // distribution counts
+await mb.info();                         // index size and freshness
+await mb.getBatch([...]);                // up to 50 at once — Scale plan only
+```
+
+## Helpers
+
+USPTO records are raw. These make them presentable:
+
+```ts
+import { statusOf, parseDate } from "@radsoft/markbase";
+
+statusOf("800");        // "registered"  (600s are dead, 710s cancelled, 900+ expired)
+parseDate("19720131");  // Date — USPTO stores YYYYMMDD strings
+```
+
+## Errors and limits
+
+Typed errors, so you can branch on what actually went wrong:
+
+```ts
+import { RateLimitError, PlanError, AuthError, NotFoundError } from "@radsoft/markbase";
+
+try {
+  await mb.getBatch(serials);
+} catch (err) {
+  if (err instanceof PlanError) {
+    // batch is Scale-only
+  } else if (err instanceof RateLimitError && err.kind === "quota") {
+    // monthly allowance gone — err.resetsAt tells you when it returns.
+    // retrying sooner won't help, which is why the client doesn't.
+  }
+}
+```
+
+Per-minute limits and 5xx are retried automatically with backoff (`maxRetries`,
+default 2). Monthly quota exhaustion is not — waiting seconds can't fix a
+month-long window.
+
+Current limits are on the client after any call:
+
+```ts
+mb.rateLimit;
+// { plan: "launch", rateLimit: 120, rateRemaining: 119,
+//   quotaLimit: 50000, quotaRemaining: 49873, quotaResetsAt: Date }
+```
+
+## Options
+
+| Option | Default | |
+|---|---|---|
+| `apiKey` | `MARKBASE_API_KEY` | `null` forces keyless |
+| `baseUrl` | `https://api.markbase.co` | |
+| `timeout` | `30000` | ms before abort |
+| `maxRetries` | `2` | rate limits and 5xx |
+| `fetch` | global `fetch` | inject your own |
+
+## Not legal advice
+
+Clearance returns a first-pass screening signal over the federal register. It
+does not cover state trademarks, common-law rights, or the legal analysis of
+likelihood of confusion. Treat a clean result as "worth pursuing", not
+"cleared", and talk to a trademark attorney before adopting a name.
+
+## Also available
+
+- **[@radsoft/markbase-mcp](https://www.npmjs.com/package/@radsoft/markbase-mcp)** — MCP server, so an AI assistant can screen names directly
+- **[API docs](https://api.markbase.co/docs)** · **[OpenAPI spec](https://api.markbase.co/openapi.json)**
+
+## License
+
+MIT — a product of [Rad Soft](https://radsoftinc.com).

package/dist/client.d.ts

@@ -0,0 +1,65 @@
+import type { Trademark, SearchOptions, SearchResult, Suggestion, ClearanceResult, OwnerResult, BatchResult, AggregateField, AggregateResult, NiceClass, IndexInfo, RateLimitInfo, MarkStatus } from "./types.js";
+export interface MarkbaseOptions {
+    /**
+     * Get one free at https://markbase.co. Omitted falls back to
+     * `MARKBASE_API_KEY`; pass `null` to force the keyless tier even when that
+     * variable is set.
+     */
+    apiKey?: string | null;
+    baseUrl?: string;
+    /** Milliseconds before a request is aborted. Default 30s. */
+    timeout?: number;
+    /** Retries on 429 and 5xx, honouring the reset window. Default 2. */
+    maxRetries?: number;
+    fetch?: typeof globalThis.fetch;
+}
+/** Class codes are stored zero-padded; the API accepts either but we normalise. */
+export declare function padClass(v: string | number): string;
+/** Turn a numeric USPTO status code into something you can show a user. */
+export declare function statusOf(code: string | null | undefined): MarkStatus;
+/** USPTO dates are YYYYMMDD strings; this gives you a Date or null. */
+export declare function parseDate(d: string | null | undefined): Date | null;
+export declare class Markbase {
+    readonly baseUrl: string;
+    private readonly apiKey?;
+    private readonly timeout;
+    private readonly maxRetries;
+    private readonly fetchImpl;
+    /** Limits from the most recent response. Null until you've made a call. */
+    rateLimit: RateLimitInfo | null;
+    constructor(opts?: MarkbaseOptions | string);
+    private readLimits;
+    private request;
+    /** Typo-tolerant full-text search across 14M+ US trademarks. */
+    search(options: SearchOptions | string): Promise<SearchResult>;
+    /** Lightweight autocomplete, tuned for as-you-type latency. */
+    suggest(q: string, limit?: number): Promise<Suggestion[]>;
+    /** Full record for one mark. */
+    getTrademark(serialNumber: string): Promise<Trademark>;
+    /** Prosecution history — filing, publication, office actions, registration. */
+    getTimeline(serialNumber: string): Promise<unknown>;
+    /** Up to 50 marks in one request. Requires the Scale plan. */
+    getBatch(serialNumbers: string[]): Promise<BatchResult>;
+    /** Every mark held by an owner. */
+    byOwner(name: string, opts?: {
+        page?: number;
+        limit?: number;
+    }): Promise<OwnerResult>;
+    /**
+     * Screen a proposed name against the register, ranked by similarity.
+     * A first-pass signal, not legal advice — pass a class, since trademark
+     * rights are scoped to goods and services.
+     */
+    clearance(mark: string, opts?: {
+        trademarkClass?: string | number;
+        limit?: number;
+    }): Promise<ClearanceResult>;
+    /** Distribution counts across a facet. */
+    aggregate(by: AggregateField): Promise<AggregateResult>;
+    /** All 45 Nice classification classes. */
+    classes(): Promise<NiceClass[]>;
+    /** Index size and freshness. */
+    info(): Promise<IndexInfo>;
+    /** Walk every page of a search, yielding marks one at a time. */
+    paginate(options: SearchOptions, maxPages?: number): AsyncGenerator<Trademark>;
+}

package/dist/client.js

@@ -0,0 +1,222 @@
+import { MarkbaseError, AuthError, RateLimitError, PlanError, NotFoundError, } from "./errors.js";
+/** Class codes are stored zero-padded; the API accepts either but we normalise. */
+export function padClass(v) {
+    const s = String(v);
+    return /^\d+$/.test(s) ? s.padStart(3, "0") : s;
+}
+/** Turn a numeric USPTO status code into something you can show a user. */
+export function statusOf(code) {
+    if (!code)
+        return "unknown";
+    const n = parseInt(code, 10);
+    if (Number.isNaN(n))
+        return "unknown";
+    if (n >= 600 && n < 700)
+        return "dead";
+    if (n >= 710 && n < 720)
+        return "cancelled";
+    if (n >= 900)
+        return "expired";
+    if (n >= 800 || n === 700 || (n >= 730 && n < 740))
+        return "registered";
+    if (n < 600)
+        return "pending";
+    return "registered";
+}
+/** USPTO dates are YYYYMMDD strings; this gives you a Date or null. */
+export function parseDate(d) {
+    if (!d || d.length !== 8)
+        return null;
+    const iso = `${d.slice(0, 4)}-${d.slice(4, 6)}-${d.slice(6, 8)}`;
+    const parsed = new Date(iso);
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+export class Markbase {
+    baseUrl;
+    apiKey;
+    timeout;
+    maxRetries;
+    fetchImpl;
+    /** Limits from the most recent response. Null until you've made a call. */
+    rateLimit = null;
+    constructor(opts = {}) {
+        const o = typeof opts === "string" ? { apiKey: opts } : opts;
+        // null is an explicit "no key"; undefined means "look at the environment"
+        this.apiKey = o.apiKey === null ? undefined : (o.apiKey ?? process.env.MARKBASE_API_KEY);
+        this.baseUrl = (o.baseUrl ?? process.env.MARKBASE_API_URL ?? "https://api.markbase.co").replace(/\/$/, "");
+        this.timeout = o.timeout ?? 30_000;
+        this.maxRetries = o.maxRetries ?? 2;
+        this.fetchImpl = o.fetch ?? globalThis.fetch;
+    }
+    readLimits(h) {
+        const num = (v) => v == null || v === "unlimited" ? null : Number.isNaN(Number(v)) ? null : Number(v);
+        const reset = h.get("x-quota-reset");
+        this.rateLimit = {
+            plan: h.get("x-plan"),
+            rateLimit: num(h.get("x-ratelimit-limit")),
+            rateRemaining: num(h.get("x-ratelimit-remaining")),
+            quotaLimit: num(h.get("x-quota-limit")),
+            quotaRemaining: num(h.get("x-quota-remaining")),
+            quotaResetsAt: reset ? new Date(Number(reset) * 1000) : null,
+        };
+    }
+    async request(path, init) {
+        const url = new URL(this.baseUrl + path);
+        for (const [k, v] of Object.entries(init?.query ?? {})) {
+            if (v == null)
+                continue;
+            if (Array.isArray(v))
+                v.forEach((item) => url.searchParams.append(k, String(item)));
+            else
+                url.searchParams.set(k, String(v));
+        }
+        let lastErr;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+            const ctrl = new AbortController();
+            const timer = setTimeout(() => ctrl.abort(), this.timeout);
+            try {
+                const res = await this.fetchImpl(url, {
+                    ...init,
+                    signal: ctrl.signal,
+                    headers: {
+                        accept: "application/json",
+                        "user-agent": "markbase-node",
+                        ...(init?.body ? { "content-type": "application/json" } : {}),
+                        ...(this.apiKey ? { "x-api-key": this.apiKey } : {}),
+                        ...init?.headers,
+                    },
+                });
+                this.readLimits(res.headers);
+                if (res.ok)
+                    return (await res.json());
+                const body = await res.json().catch(() => ({}));
+                const message = body?.error ?? `Request failed (${res.status})`;
+                if (res.status === 401)
+                    throw new AuthError(message);
+                if (res.status === 403)
+                    throw new PlanError(message, body);
+                if (res.status === 404)
+                    throw new NotFoundError(message);
+                if (res.status === 429) {
+                    const isQuota = /quota/i.test(String(message));
+                    const resetsAt = this.rateLimit?.quotaResetsAt ?? null;
+                    // a monthly quota won't clear by waiting a few seconds, so only the
+                    // per-minute limit is worth retrying
+                    const retryAfterMs = isQuota ? null : 1000 * (attempt + 1) * 2;
+                    const err = new RateLimitError(message, isQuota ? "quota" : "rate", retryAfterMs, resetsAt, body);
+                    if (isQuota || attempt >= this.maxRetries)
+                        throw err;
+                    lastErr = err;
+                    await sleep(retryAfterMs);
+                    continue;
+                }
+                if (res.status >= 500 && attempt < this.maxRetries) {
+                    lastErr = new MarkbaseError(message, res.status, body);
+                    await sleep(1000 * (attempt + 1));
+                    continue;
+                }
+                throw new MarkbaseError(message, res.status, body);
+            }
+            catch (err) {
+                if (err instanceof MarkbaseError)
+                    throw err;
+                // network error or timeout — worth one more go
+                lastErr = err;
+                if (attempt >= this.maxRetries) {
+                    const msg = err?.name === "AbortError" ? `Request timed out after ${this.timeout}ms` : String(err);
+                    throw new MarkbaseError(msg, 0);
+                }
+                await sleep(1000 * (attempt + 1));
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        }
+        throw lastErr instanceof Error ? lastErr : new MarkbaseError("Request failed", 0);
+    }
+    /** Typo-tolerant full-text search across 14M+ US trademarks. */
+    search(options) {
+        const o = typeof options === "string" ? { q: options } : options;
+        const cls = o.trademarkClass;
+        return this.request("/search", {
+            query: {
+                q: o.q,
+                status_code: o.statusCode,
+                international_code: cls == null ? undefined : Array.isArray(cls) ? cls.map(padClass) : padClass(cls),
+                filing_date_from: o.filingDateFrom,
+                filing_date_to: o.filingDateTo,
+                owner_country: o.ownerCountry,
+                owner_state: o.ownerState,
+                sort: o.sort,
+                page: o.page,
+                limit: o.limit,
+                facets: o.facets ? "true" : undefined,
+            },
+        });
+    }
+    /** Lightweight autocomplete, tuned for as-you-type latency. */
+    async suggest(q, limit = 5) {
+        const r = await this.request("/suggest", { query: { q, limit } });
+        return r.suggestions;
+    }
+    /** Full record for one mark. */
+    getTrademark(serialNumber) {
+        return this.request(`/trademark/${encodeURIComponent(serialNumber)}`);
+    }
+    /** Prosecution history — filing, publication, office actions, registration. */
+    getTimeline(serialNumber) {
+        return this.request(`/trademark/${encodeURIComponent(serialNumber)}/timeline`);
+    }
+    /** Up to 50 marks in one request. Requires the Scale plan. */
+    getBatch(serialNumbers) {
+        return this.request("/trademark/batch", {
+            method: "POST",
+            body: JSON.stringify({ serial_numbers: serialNumbers }),
+        });
+    }
+    /** Every mark held by an owner. */
+    byOwner(name, opts = {}) {
+        return this.request("/owner", { query: { name, ...opts } });
+    }
+    /**
+     * Screen a proposed name against the register, ranked by similarity.
+     * A first-pass signal, not legal advice — pass a class, since trademark
+     * rights are scoped to goods and services.
+     */
+    clearance(mark, opts = {}) {
+        return this.request("/clearance", {
+            query: {
+                mark,
+                class: opts.trademarkClass == null ? undefined : padClass(opts.trademarkClass),
+                limit: opts.limit,
+            },
+        });
+    }
+    /** Distribution counts across a facet. */
+    aggregate(by) {
+        return this.request("/aggregate", { query: { by } });
+    }
+    /** All 45 Nice classification classes. */
+    async classes() {
+        const r = await this.request("/classes");
+        return r.classes;
+    }
+    /** Index size and freshness. */
+    info() {
+        return this.request("/info");
+    }
+    /** Walk every page of a search, yielding marks one at a time. */
+    async *paginate(options, maxPages = 10) {
+        const limit = options.limit ?? 100;
+        for (let page = options.page ?? 1; page < (options.page ?? 1) + maxPages; page++) {
+            const res = await this.search({ ...options, page, limit });
+            if (!res.hits.length)
+                return;
+            for (const hit of res.hits)
+                yield hit;
+            if (res.hits.length < limit)
+                return;
+        }
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,28 @@
+/** Any non-2xx response from the API. */
+export declare class MarkbaseError extends Error {
+    readonly status: number;
+    readonly body?: unknown | undefined;
+    constructor(message: string, status: number, body?: unknown | undefined);
+}
+/** The API key was missing or not recognised. */
+export declare class AuthError extends MarkbaseError {
+    constructor(message?: string);
+}
+/**
+ * Rate limit or monthly quota exhausted. `retryAfterMs` is populated for
+ * per-minute limits; a monthly quota sets `resetsAt` instead, and retrying
+ * before then will not help.
+ */
+export declare class RateLimitError extends MarkbaseError {
+    readonly kind: "rate" | "quota";
+    readonly retryAfterMs: number | null;
+    readonly resetsAt: Date | null;
+    constructor(message: string, kind: "rate" | "quota", retryAfterMs: number | null, resetsAt: Date | null, body?: unknown);
+}
+/** The plan doesn't include this endpoint (e.g. batch is Scale-only). */
+export declare class PlanError extends MarkbaseError {
+    constructor(message: string, body?: unknown);
+}
+export declare class NotFoundError extends MarkbaseError {
+    constructor(message?: string);
+}

package/dist/errors.js

@@ -0,0 +1,48 @@
+/** Any non-2xx response from the API. */
+export class MarkbaseError extends Error {
+    status;
+    body;
+    constructor(message, status, body) {
+        super(message);
+        this.status = status;
+        this.body = body;
+        this.name = "MarkbaseError";
+    }
+}
+/** The API key was missing or not recognised. */
+export class AuthError extends MarkbaseError {
+    constructor(message = "Invalid or missing API key") {
+        super(message, 401);
+        this.name = "AuthError";
+    }
+}
+/**
+ * Rate limit or monthly quota exhausted. `retryAfterMs` is populated for
+ * per-minute limits; a monthly quota sets `resetsAt` instead, and retrying
+ * before then will not help.
+ */
+export class RateLimitError extends MarkbaseError {
+    kind;
+    retryAfterMs;
+    resetsAt;
+    constructor(message, kind, retryAfterMs, resetsAt, body) {
+        super(message, 429, body);
+        this.kind = kind;
+        this.retryAfterMs = retryAfterMs;
+        this.resetsAt = resetsAt;
+        this.name = "RateLimitError";
+    }
+}
+/** The plan doesn't include this endpoint (e.g. batch is Scale-only). */
+export class PlanError extends MarkbaseError {
+    constructor(message, body) {
+        super(message, 403, body);
+        this.name = "PlanError";
+    }
+}
+export class NotFoundError extends MarkbaseError {
+    constructor(message = "Not found") {
+        super(message, 404);
+        this.name = "NotFoundError";
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { Markbase, padClass, statusOf, parseDate } from "./client.js";
+export type { MarkbaseOptions } from "./client.js";
+export * from "./types.js";
+export * from "./errors.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { Markbase, padClass, statusOf, parseDate } from "./client.js";
+export * from "./types.js";
+export * from "./errors.js";

package/dist/types.d.ts

@@ -0,0 +1,114 @@
+/** A USPTO trademark record. */
+export interface Trademark {
+    serial_number: string;
+    registration_number: string | null;
+    word_mark: string | null;
+    owner_name: string | null;
+    owner_city: string | null;
+    owner_state: string | null;
+    owner_country: string | null;
+    status_code: string | null;
+    filing_date: string | null;
+    registration_date: string | null;
+    international_codes: string[];
+    goods_services: string | null;
+    attorney_name: string | null;
+}
+/** Human-readable status derived from the numeric USPTO code. */
+export type MarkStatus = "pending" | "registered" | "dead" | "cancelled" | "expired" | "unknown";
+export type RiskLevel = "high" | "medium" | "low" | "none";
+export interface SearchOptions {
+    /** Free-text query. Typo-tolerant. Optional if a filter is given. */
+    q?: string;
+    /** USPTO status code, e.g. "800" for registered. */
+    statusCode?: string;
+    /** Nice class 1-45. Accepts 9 or "009". */
+    trademarkClass?: string | number | Array<string | number>;
+    /** YYYYMMDD */
+    filingDateFrom?: string;
+    filingDateTo?: string;
+    ownerCountry?: string;
+    ownerState?: string;
+    /** e.g. "filing_date:desc" */
+    sort?: string;
+    page?: number;
+    limit?: number;
+    /** Include facet distribution counts. Slightly slower. */
+    facets?: boolean;
+}
+export interface SearchResult {
+    query: string;
+    hits: Trademark[];
+    /** Capped at 1000 by the search engine — narrow with filters for a precise count. */
+    total_hits: number;
+    facets?: Record<string, Record<string, number>>;
+    page: number;
+    limit: number;
+    processing_time_ms: number;
+}
+export interface Suggestion {
+    serial_number: string;
+    word_mark: string | null;
+    owner_name: string | null;
+    status_code: string | null;
+}
+export interface ClearanceMatch extends Pick<Trademark, "serial_number" | "word_mark" | "owner_name" | "status_code" | "international_codes"> {
+    /** 0-1, higher means more similar to the proposed mark. */
+    similarity: number;
+    risk: RiskLevel;
+}
+export interface ClearanceResult {
+    mark: string;
+    class: string | null;
+    highest_risk: RiskLevel;
+    matches: ClearanceMatch[];
+}
+export interface OwnerResult {
+    owner: string;
+    hits: Trademark[];
+    total_hits: number;
+    page: number;
+    limit: number;
+}
+export interface BatchResult {
+    found: Trademark[];
+    not_found: string[];
+    count: number;
+}
+export type AggregateField = "class" | "status" | "country" | "drawing" | "year";
+export interface AggregateResult {
+    by: AggregateField;
+    buckets: Array<{
+        key: string;
+        count: number;
+    }>;
+}
+export interface NiceClass {
+    code: string;
+    title: string;
+}
+export interface IndexInfo {
+    total_documents: number;
+    indexing: boolean;
+    last_updated: string | null;
+    oldest_filing: {
+        serial_number: string;
+        filing_date: string | null;
+        word_mark: string | null;
+    } | null;
+    newest_filing: {
+        serial_number: string;
+        filing_date: string | null;
+        word_mark: string | null;
+    } | null;
+}
+/** Quota and rate-limit state, read from the response headers of the last call. */
+export interface RateLimitInfo {
+    plan: string | null;
+    /** null means unlimited. */
+    rateLimit: number | null;
+    rateRemaining: number | null;
+    quotaLimit: number | null;
+    quotaRemaining: number | null;
+    quotaResetsAt: Date | null;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@radsoft/markbase",
+  "version": "2026.8.1",
+  "description": "Official Node client for the Markbase USPTO trademark API — search, screen, and look up 14M+ US trademarks.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": ["dist"],
+  "keywords": [
+    "trademark",
+    "uspto",
+    "trademark-search",
+    "clearance",
+    "brand-name",
+    "markbase",
+    "api-client",
+    "sdk"
+  ],
+  "homepage": "https://markbase.co",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Rad-Soft/marked-api.git",
+    "directory": "sdk"
+  },
+  "publishConfig": { "access": "public" },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "bun run build"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "typescript": "^5.7.2"
+  }
+}