@decdn/client 0.0.0-stage → 0.1.0

package/dist/types/client.d.ts

@@ -0,0 +1,156 @@
+import { type Fetch } from "./http.js";
+import { type BundleManifest, type ManifestEntry } from "./manifest.js";
+import { LoopbackApi } from "./loopback.js";
+import { PointerApi, type PointerDomain } from "./pointer.js";
+import { type DecdnUri } from "./uri.js";
+/** Where the client runs and how it reaches the gateway. */
+export type Context = "public" | "loopback" | "site";
+/** `"auto"` verifies what can be verified; `true` refuses what cannot; `false` verifies nothing. */
+export type VerifyMode = "auto" | boolean;
+export interface OpenOptions {
+    /** The gateway's origin: `https://decdn.link`, or `http://127.0.0.1:8484` for a loopback gateway. */
+    gatewayUrl?: string;
+    /** The loopback gateway's token (`~/.decdn/gateway/token`). */
+    token?: string;
+    /** The host whose capability pays on a loopback gateway, sent as `x-decdn-host`. Required with `token`. */
+    host?: string;
+    /** The chain and registry pointers are signed for. Required by `pointer.set`. */
+    pointer?: PointerDomain;
+    /** The `fetch` to use. Default: the global one. */
+    fetch?: Fetch;
+    /** The default verification of `get`. Default `"auto"`. */
+    verify?: VerifyMode;
+    /** How many manifests the client keeps parsed, by hash. Default 64. */
+    manifestCacheSize?: number;
+}
+/** A byte window: `length` bytes from `offset`, or to the end without `length`. */
+export interface ByteRange {
+    offset: number;
+    length?: number;
+}
+export interface GetOptions {
+    range?: ByteRange;
+    signal?: AbortSignal;
+    verify?: VerifyMode;
+    /** Wait out one `Retry-After` on 402, 429 or 503 and try once more. */
+    retry?: boolean;
+}
+/** What `head` knows about content without fetching it. */
+export interface HeadInfo {
+    size?: number;
+    hash?: string;
+    contentType?: string;
+}
+/** What a URI names, once its manifest is read. */
+export interface Resolved {
+    kind: DecdnUri["kind"];
+    /** The URI's hash: of the blob, or of the bundle manifest. */
+    hash: string;
+    /** The manifest entry an entry URI names. */
+    entry?: ManifestEntry;
+    /** The bundle or entry on its site origin. */
+    siteUrl?: string;
+    /** The URI on the gateway's bare host (or under `/_decdn/` on a site). */
+    bareUrl: string;
+}
+/** The gateway's answer: a stream that ends with an error rather than `done` when its bytes fail verification. */
+export declare class DecdnResponse {
+    readonly status: number;
+    readonly headers: Headers;
+    readonly url: string;
+    readonly contentType: string;
+    readonly contentLength?: number;
+    readonly contentRange?: {
+        offset: number;
+        length: number;
+        size: number;
+    };
+    /**
+     * `true`: the body is hashed as it streams, and ends with `HASH_MISMATCH`
+     * instead of `done` unless it hashes to the hash that names it.
+     * `"skipped"`: the bytes cannot be verified (a range, a rewritten page, a
+     * bundle listing). `false`: verification was turned off.
+     */
+    readonly verified: boolean | "skipped";
+    readonly body: ReadableStream<Uint8Array>;
+    /** @internal */
+    constructor(response: Response, body: ReadableStream<Uint8Array>, verified: boolean | "skipped", contentType?: string);
+    /** The whole body. Rejects with `HASH_MISMATCH` or `TRUNCATED`. */
+    bytes(): Promise<Uint8Array>;
+    text(): Promise<string>;
+    json(): Promise<unknown>;
+}
+export declare class DecdnClient {
+    readonly context: Context;
+    /** Namespace pointers (public gateway). */
+    readonly pointer: PointerApi;
+    /** The delegate and capability API (loopback gateway). */
+    readonly loopback: LoopbackApi;
+    /** @internal */
+    readonly fetch: Fetch;
+    /** @internal The bare origin: the gateway URL's, or the site's own. */
+    readonly origin: string;
+    /** @internal */
+    readonly pointerDomain?: PointerDomain;
+    private readonly gateway?;
+    private readonly site?;
+    private readonly token?;
+    private readonly host?;
+    private readonly verify;
+    private readonly cacheSize;
+    private readonly manifests;
+    private constructor();
+    /**
+     * A client for the gateway at `gatewayUrl`, or, in a page served from a
+     * site origin (`[<ns>.]<hash32>.<host>`, or `<ns>.<host>` under the
+     * configured gateway), for that site. A loopback `gatewayUrl` opens the
+     * loopback gateway from any page; a page, which cannot send the token,
+     * reaches its delegate and capability API alone.
+     */
+    static open(opts?: OpenOptions): Promise<DecdnClient>;
+    /** @internal Headers every bare-host request carries. */
+    authHeaders(): Record<string, string>;
+    private parse;
+    /** The URI on the bare host, or under `/_decdn/` on a site. */
+    private bareUrl;
+    /** The site URL of a bundle or an entry. */
+    siteUrl(uri: string | DecdnUri): string;
+    /** The host a namespace's pointer serves at on a public gateway: `https://<ns>.<host>/`. */
+    namespaceUrl(namespace: bigint | number): string;
+    /** The hash a manifest call names, or the site's own. */
+    private manifestHash;
+    /** The bundle manifest a hash or URI names, parsed and verified; cached per client by hash. */
+    manifest(hashOrUri?: string | DecdnUri, signal?: AbortSignal): Promise<BundleManifest>;
+    /** The manifest entry `uri` names; `NOT_FOUND` when the bundle has none. */
+    private entryOf;
+    /** What `uri` names: for a bundle or an entry, after reading its manifest. */
+    resolve(uri: string | DecdnUri): Promise<Resolved>;
+    /** A request to the gateway; a non-2xx answer is thrown as a `DecdnError`. */
+    private request;
+    /** An entry by its own hash, as a blob: the bytes the manifest names, unrewritten. */
+    private entryBlobUrl;
+    /**
+     * Where an entry comes from, given its manifest entry (when verifying).
+     * `own` holds the query of a path on the site's own bundle: the site serves
+     * by path alone and leaves the query to the page, and its host already
+     * names the namespace.
+     */
+    private entryUrl;
+    private plan;
+    private planEntry;
+    /**
+     * Fetch what `uri` names: a `decdn:` URI, or on a site page a path of its
+     * own bundle. Verification follows `verify` (see {@link DecdnResponse.verified}).
+     */
+    get(uri: string | DecdnUri, opts?: GetOptions): Promise<DecdnResponse>;
+    /** A `GET` of `url`, once more after one `Retry-After` when `opts.retry` asks. */
+    private fetchRetrying;
+    /**
+     * What is known about `uri` without its bytes: on a public gateway from
+     * `HEAD`, elsewhere (where `HEAD` would cost a pull) from the manifest. A
+     * public `HEAD` of a raw blob whose size the gateway does not know yet
+     * pays for one chunk group, the proof of its size, and is refused or fails
+     * as its `GET` would be.
+     */
+    head(uri: string | DecdnUri): Promise<HeadInfo>;
+}

package/dist/types/errors.d.ts

@@ -0,0 +1,69 @@
+/** What went wrong, as a stable code a caller can branch on. */
+export type DecdnErrorCode = 
+/** 402: the gateway's allowance is spent, or the content does not fit what is left, or no capability covers the host. */
+"PAYMENT_REQUIRED"
+/** 503: the gateway's pool cannot pay. */
+ | "POOL_UNFUNDED"
+/** 404. */
+ | "NOT_FOUND"
+/** 416: the range starts past the end; `size` holds the entry's size. */
+ | "RANGE_NOT_SATISFIABLE"
+/** 401: the loopback token is missing or wrong. */
+ | "UNAUTHORIZED"
+/** 403. */
+ | "FORBIDDEN"
+/** 400, or a `decdn:` URI that does not parse. */
+ | "BAD_URI"
+/** 429. */
+ | "RATE_LIMITED"
+/** 502: the gateway's pull failed upstream. */
+ | "UPSTREAM"
+/** 413. */
+ | "PAYLOAD_TOO_LARGE"
+/** 409: a pointer `seq` that is not newer, or a capability already registered. */
+ | "CONFLICT"
+/** 422. */
+ | "UNPROCESSABLE"
+/** The bytes do not hash to the hash that names them. */
+ | "HASH_MISMATCH"
+/** The body is shorter or longer than declared, or the stream failed. */
+ | "TRUNCATED"
+/** A bundle manifest that does not parse. */
+ | "MALFORMED_MANIFEST"
+/** A `dcap1:` capability token that does not decode. */
+ | "BAD_CAPABILITY"
+/** The gateway could not be reached. */
+ | "NETWORK"
+/** The client is not set up for the call, or the call cannot be honoured as asked. */
+ | "CONFIG"
+/** A status the gateway contract does not name. */
+ | "HTTP";
+/** Fields a {@link DecdnError} may carry besides its code and message. */
+export interface DecdnErrorDetails {
+    /** The HTTP status, when the gateway answered. */
+    status?: number;
+    /** Seconds to wait before a retry, from `Retry-After` or the JSON body. */
+    retryAfterSecs?: number;
+    /** The canonical `decdn:` URI to fetch with a paying client instead. */
+    fallbackUri?: string;
+    /** The entry's size, on `RANGE_NOT_SATISFIABLE`. */
+    size?: number;
+    /** The highest stored `seq`, on a pointer `CONFLICT`. */
+    seq?: bigint;
+    /** The response body, as text. */
+    body?: string;
+    /** What caused this error. */
+    cause?: unknown;
+}
+/** Every failure the SDK reports. */
+export declare class DecdnError extends Error {
+    readonly name = "DecdnError";
+    readonly code: DecdnErrorCode;
+    readonly status?: number;
+    readonly retryAfterSecs?: number;
+    readonly fallbackUri?: string;
+    readonly size?: number;
+    readonly seq?: bigint;
+    readonly body?: string;
+    constructor(code: DecdnErrorCode, message: string, details?: DecdnErrorDetails);
+}

package/dist/types/hash.d.ts

@@ -0,0 +1,10 @@
+/** The BLAKE3 hash of `bytes`, as 64 lowercase hex characters. */
+export declare function blake3Hex(bytes: Uint8Array): string;
+/** An incremental BLAKE3 hasher, for bytes that arrive in chunks. */
+export interface Blake3Hasher {
+    update(chunk: Uint8Array): void;
+    /** The hash of every chunk so far, as 64 lowercase hex characters. */
+    hex(): string;
+}
+/** A new incremental BLAKE3 hasher. */
+export declare function createBlake3(): Blake3Hasher;

package/dist/types/hex.d.ts

@@ -0,0 +1,6 @@
+/** Lowercase hex of `bytes`. */
+export declare function toHex(bytes: Uint8Array): string;
+/** The bytes of an even-length hex string, or `undefined` if it is not hex. */
+export declare function fromHex(hex: string): Uint8Array | undefined;
+/** Whether `s` is a BLAKE3 hash spelled as 64 hex characters. */
+export declare function isHash(s: string): boolean;

package/dist/types/http.d.ts

@@ -0,0 +1,12 @@
+import { DecdnError } from "./errors.js";
+export type Fetch = typeof globalThis.fetch;
+/** `fetch`, with a failure to reach the gateway as `NETWORK` and an abort passed through. */
+export declare function send(fetch: Fetch, url: string, init: RequestInit): Promise<Response>;
+/** The error for a gateway answer that is not a success. Reads the body. */
+export declare function errorOf(response: Response): Promise<DecdnError>;
+/**
+ * `text` parsed as JSON with the integer values of `fields` read as `bigint`:
+ * the gateway writes u64 ids, caps and expiries as JSON numbers, which may
+ * exceed 2^53.
+ */
+export declare function parseWithBigInts(text: string, fields: string[]): unknown;

package/dist/types/index.d.ts

@@ -0,0 +1,9 @@
+export { DecdnError, type DecdnErrorCode, type DecdnErrorDetails, } from "./errors.js";
+export { formatUri, parseUri, SCHEME, type DecdnUri } from "./uri.js";
+export { base32ToHash, hashToBase32 } from "./base32.js";
+export { blake3Hex, createBlake3, type Blake3Hasher } from "./hash.js";
+export { MAX_MANIFEST_BYTES, parseManifest, type BundleManifest, type ManifestChunk, type ManifestEntry, } from "./manifest.js";
+export { parseCapability, type Capability } from "./capability.js";
+export { DecdnClient, DecdnResponse, type ByteRange, type Context, type GetOptions, type HeadInfo, type OpenOptions, type Resolved, type VerifyMode, } from "./client.js";
+export { PointerApi, pointerSigningHash, pointerTypedData, recoverPointerSigner, signPointer, type Pointer, type PointerDomain, type PointerSet, type PointerSigner, type PointerTypedData, type TypedDataSigner, } from "./pointer.js";
+export { LoopbackApi, type RegisteredCapability } from "./loopback.js";

package/dist/types/loopback.d.ts

@@ -0,0 +1,36 @@
+import type { DecdnClient } from "./client.js";
+/** A capability the gateway holds. */
+export interface RegisteredCapability {
+    signer: string;
+    pool: string;
+    scope: string;
+    /** The page origin that registered it, or `null` for the token holder. */
+    origin: string | null;
+    /** The spending cap, in USDC base units. */
+    cap: bigint;
+    /** Unix-seconds expiry. */
+    expiry: bigint;
+    /** Whether a pull found it spent. */
+    spent: boolean;
+}
+export declare class LoopbackApi {
+    private readonly client;
+    /** @internal */
+    constructor(client: DecdnClient);
+    private call;
+    /** A fresh delegate key the gateway holds for 15 minutes unless a capability claims it. */
+    delegate(): Promise<{
+        address: string;
+    }>;
+    /** Register `capability` (a `dcap1:` issued to a delegate) for `scope`: `example.com`, `*.example.com` or `*`. */
+    registerCapability(args: {
+        capability: string;
+        scope: string;
+    }): Promise<{
+        signer: string;
+        scope: string;
+        expiry: bigint;
+    }>;
+    /** The capabilities the gateway holds. Needs the token. */
+    capabilities(): Promise<RegisteredCapability[]>;
+}

package/dist/types/manifest.d.ts

@@ -0,0 +1,30 @@
+/** The largest manifest the gateway pulls, and the SDK reads (64 MiB). */
+export declare const MAX_MANIFEST_BYTES: number;
+/** One chunk of an entry: an independently addressed run of its bytes. */
+export interface ManifestChunk {
+    hash: string;
+    size: number;
+}
+/** One file of a bundle. */
+export interface ManifestEntry {
+    /** The entry's relative POSIX path: what a `decdn:<hash>/<path>` URI names. */
+    path: string;
+    /** The BLAKE3 hash of the whole file, 64 lowercase hex characters. */
+    hash: string;
+    /** The file's size in bytes, when the manifest declares it. */
+    size?: number;
+    /** The file's chunk decomposition, a dedup hint. */
+    chunks?: ManifestChunk[];
+}
+/** A parsed bundle manifest. */
+export interface BundleManifest {
+    /** The manifest blob's BLAKE3 hash: what `decdn:<hash>/` names. */
+    hash: string;
+    entries: ManifestEntry[];
+}
+/**
+ * Parse manifest bytes. With `expectedHash`, the bytes must hash to it first
+ * (`HASH_MISMATCH` otherwise). Anything that is not a v1 manifest is
+ * `MALFORMED_MANIFEST`.
+ */
+export declare function parseManifest(bytes: Uint8Array, expectedHash?: string): BundleManifest;

package/dist/types/mime.d.ts

@@ -0,0 +1,4 @@
+/** Whether a site rewrites the entry at `path`, so its bytes need not hash to the entry hash. */
+export declare function rewritten(path: string): boolean;
+/** The type a site serves the entry at `path` as: text in UTF-8, bytes for an unknown extension. */
+export declare function siteType(path: string): string;

package/dist/types/node.d.ts

@@ -0,0 +1,7 @@
+/** The loopback gateway's default data dir, `~/.decdn/gateway`. */
+export declare function defaultDataDir(): string;
+/**
+ * The token a loopback `decdn gateway` keeps in `<dataDir>/token` (mode 0600),
+ * for `DecdnClient.open({ token })`. `dataDir` is the gateway's `--data-dir`.
+ */
+export declare function readLoopbackToken(dataDir?: string): Promise<string>;

package/dist/types/pointer.d.ts

@@ -0,0 +1,82 @@
+import type { DecdnClient } from "./client.js";
+/** The chain a pointer is signed for: the EIP-712 domain of `PUT /_pointer`. */
+export interface PointerDomain {
+    chainId: bigint | number;
+    /** The `PublisherRegistry` contract address. */
+    publisherRegistry: string;
+}
+/** A pointer from a namespace to the bundle whose manifest hash is `root`. */
+export interface Pointer {
+    namespace: bigint;
+    /** The bundle's manifest hash, 64 hex characters. */
+    root: string;
+    seq: bigint;
+}
+/** The EIP-712 typed data of a pointer, in the shape viem's `signTypedData` takes. */
+export interface PointerTypedData {
+    domain: {
+        name: "decdn-pointer";
+        version: "1";
+        chainId: bigint;
+        verifyingContract: string;
+    };
+    types: {
+        Pointer: {
+            name: string;
+            type: string;
+        }[];
+    };
+    primaryType: "Pointer";
+    message: {
+        namespaceId: bigint;
+        root: string;
+        seq: bigint;
+    };
+}
+/** Anything that signs EIP-712 typed data: a viem account, or a wallet behind the same call shape. */
+export interface TypedDataSigner {
+    signTypedData(typedData: PointerTypedData): Promise<string>;
+}
+/** A signer: a typed-data signer, or a raw secp256k1 key (`0x` hex or bytes). */
+export type PointerSigner = TypedDataSigner | {
+    privateKey: string | Uint8Array;
+};
+/** @internal `value` as a bigint; `CONFIG` for a number that is not a safe integer. */
+export declare function integer(value: bigint | number, what: string): bigint;
+/** The typed data a wallet signs for `pointer`. */
+export declare function pointerTypedData(domain: PointerDomain, pointer: Pointer): PointerTypedData;
+/** The EIP-712 signing hash of `pointer`, `0x` + 64 hex. */
+export declare function pointerSigningHash(domain: PointerDomain, pointer: Pointer): string;
+/** Sign `pointer` for `domain` with `signer`. */
+export declare function signPointer(domain: PointerDomain, pointer: Pointer, signer: PointerSigner): Promise<string>;
+/** The lowercase address that signed `pointer` with `signature`; `UNPROCESSABLE` for a malformed or high-`s` one. */
+export declare function recoverPointerSigner(domain: PointerDomain, pointer: Pointer, signature: string): string;
+/** What `pointer.set` stored. */
+export interface PointerSet {
+    namespace: bigint;
+    /** The bundle's manifest hash. */
+    root: string;
+    seq: bigint;
+    /** The namespace's host on the gateway. */
+    url: string;
+}
+/** Namespace pointers on a public gateway. */
+export declare class PointerApi {
+    private readonly client;
+    /** @internal */
+    constructor(client: DecdnClient);
+    /**
+     * Sign a pointer from `namespace` to the bundle `root` (`decdn:<hash>/` or
+     * its manifest hash) and `PUT` it. `seq` defaults to the current Unix
+     * second; the gateway takes only a `seq` above the one it holds from the
+     * same signer. The signer must own the namespace on the `PublisherRegistry`
+     * of `open({ pointer })`.
+     */
+    set(args: {
+        namespace: bigint | number;
+        root: string;
+        seq?: bigint | number;
+        signer: PointerSigner;
+        signal?: AbortSignal;
+    }): Promise<PointerSet>;
+}

package/dist/types/uri.d.ts

@@ -0,0 +1,20 @@
+/** The scheme prefix of every `decdn:` URI. */
+export declare const SCHEME = "decdn:";
+/** A parsed `decdn:` URI. */
+export interface DecdnUri {
+    /** The BLAKE3 hash, 64 lowercase hex characters: of the blob, or of the bundle manifest. */
+    hash: string;
+    /** What the hash names: a raw blob, a whole bundle, or one entry of a bundle. */
+    kind: "blob" | "bundle" | "entry";
+    /** The decoded manifest path of an entry. */
+    path?: string;
+    /** The namespace routing hint, never `0n`. */
+    namespace?: bigint;
+}
+/**
+ * Parse a `decdn:` URI. Throws a {@link DecdnError} with code `BAD_URI` for
+ * anything the Rust client would refuse.
+ */
+export declare function parseUri(s: string): DecdnUri;
+/** The canonical string of `uri`: lowercase hex, uppercase `%XX` escapes. */
+export declare function formatUri(uri: DecdnUri): string;

package/dist/types/verify.d.ts

@@ -0,0 +1,14 @@
+export interface GuardOptions {
+    /** The hash the whole body must have, or `undefined` to skip the check. */
+    hash?: string;
+    /** The fewest bytes the body holds: the manifest's size, or Content-Length. */
+    length?: number;
+    /** The most bytes the body may hold: the manifest's size, or the window asked for. */
+    max?: number;
+    /** The request's signal: a read it aborts fails with its reason. */
+    signal?: AbortSignal;
+}
+/** `body`, guarded: a failed read is `TRUNCATED`, a short or long body `TRUNCATED`, a wrong hash `HASH_MISMATCH`. */
+export declare function guard(body: ReadableStream<Uint8Array> | null, opts: GuardOptions): ReadableStream<Uint8Array>;
+/** Every byte of `stream`, joined. */
+export declare function collect(stream: ReadableStream<Uint8Array>, limit?: number): Promise<Uint8Array>;

package/package.json

@@ -1,6 +1,100 @@
 {
   "name": "@decdn/client",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "TypeScript client for deCDN over a decdn gateway: verified fetches, bundles, loopback capabilities and namespace pointers.",
+  "license": "MIT OR Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/decdn/sdk-typescript.git"
+  },
+  "homepage": "https://github.com/decdn/sdk-typescript#readme",
+  "bugs": "https://github.com/decdn/sdk-typescript/issues",
+  "keywords": [
+    "decdn",
+    "cdn",
+    "blake3",
+    "content-addressed",
+    "gateway"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20.19"
+  },
+  "decdn": {
+    "gatewayFloor": "0.3.0"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./node": {
+      "node": {
+        "import": {
+          "types": "./dist/node.d.ts",
+          "default": "./dist/node.js"
+        },
+        "require": {
+          "types": "./dist/node.d.cts",
+          "default": "./dist/node.cjs"
+        }
+      },
+      "types": "./dist/node.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "lint-staged": {
+    "*.{ts,mts,cts,js,mjs,cjs}": [
+      "eslint --fix",
+      "prettier --write"
+    ],
+    "*.{json,md,yaml,yml}": [
+      "prettier --write"
+    ]
+  },
+  "dependencies": {
+    "@noble/curves": "^2.4.0",
+    "@noble/hashes": "^2.4.0"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.5",
+    "@commitlint/cli": "^20.5.3",
+    "@commitlint/config-conventional": "^20.5.3",
+    "@eslint/js": "^9.39.0",
+    "@types/node": "^24",
+    "@vitest/browser-playwright": "^5.0.5",
+    "esbuild": "^0.28.2",
+    "eslint": "^9.39.0",
+    "eslint-config-prettier": "^10.1.8",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.4.0",
+    "playwright": "^1.64.1",
+    "prettier": "^3.9.4",
+    "publint": "^0.3.25",
+    "typescript": "^6",
+    "typescript-eslint": "^8.72.0",
+    "vitest": "^5.0.5"
+  },
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "lint": "eslint . && prettier --check . && tsc --noEmit",
+    "format": "prettier --write .",
+    "test": "vitest run --project unit --project contract",
+    "test:contract": "vitest run --project contract",
+    "test:browser": "vitest run --project browser"
+  }
 }