@sixtyninecommerce/admin 0.6.0 → 0.8.0

package/dist/tax/index.d.ts

@@ -0,0 +1,128 @@
+import { type Page, type Transport } from '@sixtyninecommerce/core';
+import type { Call } from '../types.js';
+/**
+ * The mapping used when no mapping names the country the money is taxed in.
+ *
+ * A real row, not an absence: it is set and removed through the same two
+ * methods as any country's, so "this class says nothing about Germany" and
+ * "this class charges Germany the fallback" are different states rather than
+ * the same one read two ways.
+ */
+export declare const TAX_CLASS_FALLBACK_COUNTRY = "*";
+/** As much of a Vendure tax category as a mapping projects. */
+export interface TaxClassTaxCategory {
+    id: string;
+    name: string;
+    /** True for a category the store's own tax setup treats as the default. */
+    isDefault: boolean;
+}
+/** One country's answer for one class. */
+export interface TaxClassMapping {
+    /** ISO 3166-1 alpha-2, upper case — or `*`, the fallback. */
+    countryCode: string;
+    taxCategoryId: string;
+    taxCategory: TaxClassTaxCategory;
+}
+/**
+ * A store's own name for how something is taxed — `standard`, `reduced`,
+ * `zero-rated` (spec §8.6).
+ *
+ * Tax categories and their rates are platform-wide, shared by every store on
+ * the platform. The class is this store's indirection in front of them: the
+ * store owns the key and the label, and the mappings say which global category
+ * prices it in which country.
+ */
+export interface TaxClass {
+    id: string;
+    /**
+     * Kebab-case handle, unique in this store. The identity: it is what
+     * `ProductVariant.customFields.taxClassKey` carries, what a surcharge names,
+     * and what `tax_class.changed` puts on the event bus.
+     */
+    key: string;
+    label: string;
+    mappings: TaxClassMapping[];
+}
+/**
+ * Create a class, or re-label the one that already carries the key.
+ *
+ * There is NO rename. The key is stored on product variants and held by every
+ * consumer that has seen a `tax_class.changed`, so a merchant who wants a
+ * different key creates one and deletes the old — in that order, because the
+ * delete is refused while variants still carry it.
+ */
+export interface UpsertTaxClassInput {
+    /** Kebab-case, 1–64 characters (`INVALID_TAX_CLASS_KEY` otherwise). */
+    key: string;
+    label: string;
+}
+/**
+ * The store's tax classes and the country mappings that price them (spec §8.6).
+ *
+ * Reading needs `ReadSettings`, writing `UpdateSettings` — deliberately NOT the
+ * tax-category permissions, which govern the platform-wide table every store
+ * shares. Everything is scoped to the channel the client is on: another store's
+ * class is invisible to `get`, unwritable by `mappings.set`, and reported as
+ * absent by `delete`.
+ *
+ * **Coded refusals**, delivered as GraphQL errors with `extensions.code`:
+ * `TAX_CLASS_NOT_FOUND` (→ `NotFoundError`), which is also the answer for a
+ * class belonging to another store; `TAX_CLASS_KEY_TAKEN` (→ `ConflictError`),
+ * which a caller meets only by losing a race with a concurrent create;
+ * `TAX_CLASS_IN_USE` (→ `ConflictError`) on a delete while product variants
+ * still carry the key; `TAX_CLASS_UNMAPPED` (→ `ValidationError`) when
+ * something asks a class to price money in a country it says nothing about, and
+ * `TAX_CLASS_RATE_MISSING` (→ `ValidationError`) when it IS mapped but that
+ * category has no rate in the zone the money is taxed in;
+ * `TAX_CATEGORY_NOT_FOUND` (→ `NotFoundError`); and
+ * `INVALID_TAX_CLASS_KEY` / `INVALID_TAX_CLASS_LABEL` /
+ * `INVALID_TAX_CLASS_COUNTRY` (→ `ValidationError`).
+ */
+export interface TaxClassesModule {
+    /**
+     * Every class of this store, by key.
+     *
+     * A `Page` because every list in this SDK is one (spec §9.2), not because
+     * this query pages: `taxClasses` answers the complete array, so the page is
+     * always the last one and `total` is its length. If the endpoint ever grows a
+     * cursor, consumers walking it with `.next()` or `for await` keep working.
+     */
+    list(options?: Call): Promise<Page<TaxClass>>;
+    /**
+     * One class, or null when this store has none with that key — including a key
+     * that belongs to another store. A key that is not kebab-case at all is a
+     * different answer: it is refused with `INVALID_TAX_CLASS_KEY` rather than
+     * reported as absent.
+     */
+    get(key: string, options?: Call): Promise<TaxClass | null>;
+    upsert(input: UpsertTaxClassInput, options?: Call): Promise<TaxClass>;
+    /**
+     * True when a class was removed, false when there was none — so a repeated
+     * delete is not an error. A malformed key is still refused with
+     * `INVALID_TAX_CLASS_KEY`, and a class product variants still carry with
+     * `TAX_CLASS_IN_USE`.
+     */
+    delete(key: string, options?: Call): Promise<boolean>;
+}
+/** The country → tax category table of one class. */
+export interface TaxMappingsModule {
+    /**
+     * Point one country — or {@link TAX_CLASS_FALLBACK_COUNTRY} — at a tax
+     * category, replacing that country's mapping if it had one. Country codes are
+     * stored upper case; `nl` and `NL` are the same mapping.
+     */
+    set(key: string, countryCode: string, taxCategoryId: string, options?: Call): Promise<TaxClass>;
+    /** Drop one country's mapping. Silent when there was none. */
+    remove(key: string, countryCode: string, options?: Call): Promise<TaxClass>;
+}
+export interface TaxModule {
+    classes: TaxClassesModule;
+    mappings: TaxMappingsModule;
+}
+export declare const TAX_CLASSES_QUERY = "\n  query TaxClasses {\n    taxClasses { \n  id\n  key\n  label\n  mappings {\n    countryCode\n    taxCategoryId\n    taxCategory {\n      id\n      name\n      isDefault\n    }\n  }\n }\n  }\n";
+export declare const TAX_CLASS_QUERY = "\n  query TaxClass($key: String!) {\n    taxClass(key: $key) { \n  id\n  key\n  label\n  mappings {\n    countryCode\n    taxCategoryId\n    taxCategory {\n      id\n      name\n      isDefault\n    }\n  }\n }\n  }\n";
+export declare const UPSERT_TAX_CLASS_MUTATION = "\n  mutation UpsertTaxClass($input: UpsertTaxClassInput!) {\n    upsertTaxClass(input: $input) { \n  id\n  key\n  label\n  mappings {\n    countryCode\n    taxCategoryId\n    taxCategory {\n      id\n      name\n      isDefault\n    }\n  }\n }\n  }\n";
+export declare const DELETE_TAX_CLASS_MUTATION = "\n  mutation DeleteTaxClass($key: String!) {\n    deleteTaxClass(key: $key)\n  }\n";
+export declare const SET_TAX_CLASS_MAPPING_MUTATION = "\n  mutation SetTaxClassMapping($key: String!, $countryCode: String!, $taxCategoryId: ID!) {\n    setTaxClassMapping(key: $key, countryCode: $countryCode, taxCategoryId: $taxCategoryId) {\n      \n  id\n  key\n  label\n  mappings {\n    countryCode\n    taxCategoryId\n    taxCategory {\n      id\n      name\n      isDefault\n    }\n  }\n\n    }\n  }\n";
+export declare const REMOVE_TAX_CLASS_MAPPING_MUTATION = "\n  mutation RemoveTaxClassMapping($key: String!, $countryCode: String!) {\n    removeTaxClassMapping(key: $key, countryCode: $countryCode) { \n  id\n  key\n  label\n  mappings {\n    countryCode\n    taxCategoryId\n    taxCategory {\n      id\n      name\n      isDefault\n    }\n  }\n }\n  }\n";
+export declare function createTaxModule(transport: Transport): TaxModule;

package/dist/tax/index.js

@@ -0,0 +1,101 @@
+import { createPage } from '@sixtyninecommerce/core';
+/**
+ * The mapping used when no mapping names the country the money is taxed in.
+ *
+ * A real row, not an absence: it is set and removed through the same two
+ * methods as any country's, so "this class says nothing about Germany" and
+ * "this class charges Germany the fallback" are different states rather than
+ * the same one read two ways.
+ */
+export const TAX_CLASS_FALLBACK_COUNTRY = '*';
+const TAX_CLASS_FIELDS = /* GraphQL */ `
+  id
+  key
+  label
+  mappings {
+    countryCode
+    taxCategoryId
+    taxCategory {
+      id
+      name
+      isDefault
+    }
+  }
+`;
+export const TAX_CLASSES_QUERY = /* GraphQL */ `
+  query TaxClasses {
+    taxClasses { ${TAX_CLASS_FIELDS} }
+  }
+`;
+export const TAX_CLASS_QUERY = /* GraphQL */ `
+  query TaxClass($key: String!) {
+    taxClass(key: $key) { ${TAX_CLASS_FIELDS} }
+  }
+`;
+export const UPSERT_TAX_CLASS_MUTATION = /* GraphQL */ `
+  mutation UpsertTaxClass($input: UpsertTaxClassInput!) {
+    upsertTaxClass(input: $input) { ${TAX_CLASS_FIELDS} }
+  }
+`;
+export const DELETE_TAX_CLASS_MUTATION = /* GraphQL */ `
+  mutation DeleteTaxClass($key: String!) {
+    deleteTaxClass(key: $key)
+  }
+`;
+export const SET_TAX_CLASS_MAPPING_MUTATION = /* GraphQL */ `
+  mutation SetTaxClassMapping($key: String!, $countryCode: String!, $taxCategoryId: ID!) {
+    setTaxClassMapping(key: $key, countryCode: $countryCode, taxCategoryId: $taxCategoryId) {
+      ${TAX_CLASS_FIELDS}
+    }
+  }
+`;
+export const REMOVE_TAX_CLASS_MAPPING_MUTATION = /* GraphQL */ `
+  mutation RemoveTaxClassMapping($key: String!, $countryCode: String!) {
+    removeTaxClassMapping(key: $key, countryCode: $countryCode) { ${TAX_CLASS_FIELDS} }
+  }
+`;
+export function createTaxModule(transport) {
+    return {
+        classes: {
+            async list(options) {
+                const data = await transport.graphql({ api: 'admin', query: TAX_CLASSES_QUERY }, options);
+                const items = data.taxClasses;
+                return createPage(items, { nextCursor: null, hasNext: false, total: items.length }, () => {
+                    // Unreachable while `hasNext` is false — `Page.next()` short-circuits
+                    // — and a rejection rather than a silent re-fetch if that changes.
+                    throw new Error('taxClasses returns a complete list; there is no next page');
+                });
+            },
+            async get(key, options) {
+                const data = await transport.graphql({ api: 'admin', query: TAX_CLASS_QUERY, variables: { key } }, options);
+                return data.taxClass;
+            },
+            async upsert(input, options) {
+                const data = await transport.graphql({ api: 'admin', query: UPSERT_TAX_CLASS_MUTATION, variables: { input } }, options);
+                return data.upsertTaxClass;
+            },
+            async delete(key, options) {
+                const data = await transport.graphql({ api: 'admin', query: DELETE_TAX_CLASS_MUTATION, variables: { key } }, options);
+                return data.deleteTaxClass;
+            },
+        },
+        mappings: {
+            async set(key, countryCode, taxCategoryId, options) {
+                const data = await transport.graphql({
+                    api: 'admin',
+                    query: SET_TAX_CLASS_MAPPING_MUTATION,
+                    variables: { key, countryCode, taxCategoryId },
+                }, options);
+                return data.setTaxClassMapping;
+            },
+            async remove(key, countryCode, options) {
+                const data = await transport.graphql({
+                    api: 'admin',
+                    query: REMOVE_TAX_CLASS_MAPPING_MUTATION,
+                    variables: { key, countryCode },
+                }, options);
+                return data.removeTaxClassMapping;
+            },
+        },
+    };
+}

package/dist/tenant/capabilities.d.ts

@@ -68,6 +68,21 @@ export interface CapabilityManifest {
      * apps work has not written.
      */
     installedApps: never[];
+    /**
+     * The `aud` an app assertion must carry to be exchanged at this deployment —
+     * its public Vendure origin. Copy it VERBATIM into the claim; re-deriving it
+     * from a URL you hold is the drift the platform compares against as a plain
+     * string. `createAppCredential` already does this for you, so this member is
+     * for a caller signing assertions by hand.
+     *
+     * Camelised from the wire's `assertion_audience`, like every other member
+     * here. `null` means the plugins service cannot state one — which does NOT
+     * mean the exchange accepts an assertion without `aud`, since the two run as
+     * separate deployment resources; ask the operator rather than omitting it.
+     *
+     * Optional because a platform older than this field simply does not send it.
+     */
+    assertionAudience?: string | null;
     /** A member added after this SDK release arrives camelised and untouched. */
     [extra: string]: unknown;
 }

package/dist/types.d.ts

@@ -2,9 +2,26 @@ import type { ChannelInfo, TenantContext, TenantScope } from '@sixtyninecommerce
 /** Per-call options every admin method accepts (spec §9.2). */
 export interface Call {
     /**
-     * Sent as `Idempotency-Key` on a REST write, and ignored on a GraphQL one —
-     * the Admin API has no header for it, so an `apiTokens.*` write is never
-     * deduplicated and a repeat is a second write.
+     * Sent as `Idempotency-Key` on a REST write. On a GraphQL one it is sent as
+     * an ARGUMENT — the Admin API has no header for it — and only the mutations
+     * that declare one act on it. Today those are the money mutations
+     * `payments.record`, `orders.park`, `orders.settle` and all three
+     * `orders.surcharges.*`, plus `payments.providers.completeOnboarding` and
+     * `payments.providers.terminals.provision`. Repeating one under the same key
+     * returns the first call's result instead of moving the money again; a
+     * DIFFERENT request under the same key is refused with
+     * `IDEMPOTENCY_CONFLICT`.
+     *
+     * Two deliberate exceptions on that list. `customers.erase` takes a key but
+     * RECORDS it for provenance rather than keying on it: that mutation is
+     * idempotent on the customer itself, which is the stronger key. And
+     * `payments.providers.startOnboarding` takes none at all, because its
+     * response carries a link that can be single-use and a stored response is
+     * re-served for 24 hours.
+     *
+     * Everything else — `apiTokens.*` and the rest of the GraphQL surface —
+     * still sends the key and acts on nothing, so a repeat there is a second
+     * write.
      *
      * On REST, three of this SDK's writes are deduplicated by the service itself:
      * `content.forms.upsertBySlug` (`PUT /forms/by-slug/:slug`),

package/dist/uploads/index.d.ts

@@ -0,0 +1,146 @@
+import { type Transport } from '@sixtyninecommerce/core';
+import type { Call } from '../types.js';
+/**
+ * What an upload is for. It decides which permission stages it and who may
+ * consume it.
+ *
+ * `asset` is the only purpose today. `bulk` and `document` arrive with the
+ * calls that consume them, each with its own storage decision — everything
+ * staged currently lands in the public asset bucket, which is right for a media
+ * asset and not for a customer export or an order attachment.
+ */
+export type UploadPurpose = 'asset';
+export type UploadStatus = 'staged' | 'consumed' | 'expired';
+export interface StagedUpload {
+    id: string;
+    purpose: UploadPurpose;
+    status: UploadStatus;
+    mimeType: string;
+    /**
+     * The EXACT size the signature was computed for, as a string.
+     *
+     * A string because it is a 64-bit column and a JSON number is a double; use
+     * `Number(...)` if you need arithmetic, which is exact below 2^53.
+     */
+    sizeBytes: string;
+    /** The label you gave the file. It is never part of the object's location. */
+    filename: string | null;
+    /** When the RESERVATION lapses. After this nothing will accept the upload. */
+    expiresAt: string;
+    consumedAt: string | null;
+    createdAt: string;
+}
+export interface StagedUploadTicket extends StagedUpload {
+    /** PUT the bytes here. Single use. */
+    url: string;
+    method: 'PUT';
+    /**
+     * Send ALL of these, spelled exactly like this. They are part of the
+     * signature, so storage refuses a PUT that omits or changes one.
+     */
+    headers: Record<string, string>;
+    /**
+     * When the URL stops working — at most {@link StagedUpload.expiresAt}, and
+     * less than it when you re-staged an upload that was already running down.
+     */
+    urlExpiresAt: string;
+}
+export interface StageUploadInput {
+    purpose: UploadPurpose;
+    /** Checked against the platform allow-list and bound into the signature. */
+    mimeType: string;
+    /**
+     * The EXACT number of bytes you will send — not a maximum.
+     *
+     * A presigned PUT can only pin a precise `Content-Length`; there is no way to
+     * sign an upper bound. Storage refuses any other length, so this must be the
+     * real size of the body (`blob.size`, `buffer.length`, `stat.size`).
+     */
+    size: number;
+    /**
+     * Your own handle for this upload, making the call repeatable.
+     *
+     * Required. Staging is the call that hands out a URL, and a dropped response
+     * on it is the ordinary failure: without a token every retry would reserve
+     * another place and leave an object nobody ever claims. Staging twice with
+     * the same token returns the SAME upload; staging DIFFERENT terms under it is
+     * refused with `UPLOAD_TOKEN_CONFLICT`.
+     */
+    clientToken: string;
+    /** A label for humans. It never reaches the object's location. */
+    filename?: string;
+}
+/**
+ * Bytes this SDK knows how to PUT. A `Blob` in any modern runtime, or a
+ * `Uint8Array`/`ArrayBuffer` from Node.
+ */
+export type UploadBody = Blob | ArrayBuffer | ArrayBufferView;
+export interface ClaimAsAssetInput {
+    /** Place the asset in this CMS asset folder. */
+    folderId?: string;
+    altText?: string;
+}
+/**
+ * Signed direct-to-storage uploads (spec §6.11).
+ *
+ * **The shape of it.** You say what you are uploading; the platform decides
+ * WHERE it goes and signs exactly that. You never see or choose a path. The
+ * three steps are `stage` (reserve and get a URL), `put` (send the bytes
+ * straight to storage — they do not pass through the platform), and a consuming
+ * call that takes the upload's id.
+ *
+ * ```ts
+ * const bytes = await readFile('hero.png');
+ * const ticket = await admin.uploads.stage({
+ *   purpose: 'asset',
+ *   mimeType: 'image/png',
+ *   size: bytes.length,
+ *   clientToken: crypto.randomUUID(),
+ *   filename: 'hero.png',
+ * });
+ * await admin.uploads.put(ticket, bytes);
+ * const asset = await admin.uploads.claimAsAsset(ticket.id, { altText: 'Our hero' });
+ * ```
+ *
+ * **The size is exact.** `size` is the byte count storage will accept and no
+ * other — not a ceiling. Sending a different number of bytes fails at storage
+ * with a signature error, so compute it from the body you are about to send.
+ *
+ * **One use, and a window scaled to the size.** A URL writes one object, once.
+ * The reservation lasts at least fifteen minutes, and longer for a large file —
+ * enough to send it at about 1 Mbit/s — because a window too short to upload in
+ * would expire between the PUT and the claim. `expiresAt` is the reservation;
+ * `urlExpiresAt` is the signature, and never outlives it. An upload nobody
+ * consumes expires and its bytes are deleted.
+ *
+ * **It is yours alone.** An upload is visible and usable only to the principal
+ * that staged it, on the store it was staged for. Anything else answers
+ * `UPLOAD_NOT_FOUND` — the same answer as an id that never existed.
+ *
+ * **Browsers need CORS.** `put` sends a cross-origin PUT to the object store,
+ * which requires CORS rules on the bucket that this platform does not
+ * configure. Server-side callers are unaffected.
+ */
+export interface UploadsModule {
+    /** Reserve a place and get a signed URL to PUT one file to. */
+    stage(input: StageUploadInput, options?: Call): Promise<StagedUploadTicket>;
+    /**
+     * Send the bytes to storage using the ticket's URL and headers.
+     *
+     * It does NOT go through the platform and carries none of your credentials —
+     * the URL is the authorisation. Resolves on a 2xx and throws the store's
+     * status otherwise.
+     */
+    put(ticket: StagedUploadTicket, body: UploadBody): Promise<void>;
+    /** One upload's state. Unknown, or another principal's, is `UPLOAD_NOT_FOUND`. */
+    get(id: string, options?: Call): Promise<StagedUpload>;
+    /**
+     * Turn a staged upload into a CMS asset.
+     *
+     * This is the consuming call: it verifies the object is there and is what was
+     * signed, spends the upload, and ingests the bytes. An upload can be consumed
+     * once — a second call is `UPLOAD_ALREADY_CONSUMED`.
+     */
+    claimAsAsset(id: string, input?: ClaimAsAssetInput, options?: Call): Promise<unknown>;
+}
+export declare function createUploadsModule(transport: Transport, fetchImpl: typeof globalThis.fetch): UploadsModule;

package/dist/uploads/index.js

@@ -0,0 +1,72 @@
+import { PLATFORM_PASSTHROUGH_KEYS, ValidationError, } from '@sixtyninecommerce/core';
+/**
+ * `headers` carries the exact header NAMES a signature was computed over.
+ *
+ * Case-converting them would rewrite `content-type` to `contentType`, and the
+ * PUT would then go out without the header storage is checking for — a
+ * signature failure that looks like a credential problem and is not.
+ */
+const PRESERVE = new Set([...PLATFORM_PASSTHROUGH_KEYS, 'headers']);
+export function createUploadsModule(transport, fetchImpl) {
+    return {
+        async stage(input, options) {
+            if (!Number.isSafeInteger(input.size) || input.size < 1) {
+                // Refused here rather than sent: a fractional or negative size would be
+                // rejected by the service as a validation failure whose message is
+                // about a field the caller did not type, and `size: NaN` from a missing
+                // `blob.size` is the way this goes wrong in practice.
+                throw new ValidationError({
+                    code: 'UPLOAD_SIZE_INVALID',
+                    message: `size must be the exact whole number of bytes you will upload; received ${String(input.size)}.`,
+                    status: 400,
+                    service: 'plugins',
+                });
+            }
+            return await transport.rest('plugins', {
+                method: 'POST',
+                path: '/uploads/stage',
+                body: {
+                    purpose: input.purpose,
+                    mime_type: input.mimeType,
+                    size_bytes: input.size,
+                    client_token: input.clientToken,
+                    ...(input.filename === undefined ? {} : { filename: input.filename }),
+                },
+            }, { ...options, preserveKeys: PRESERVE });
+        },
+        async put(ticket, body) {
+            const response = await fetchImpl(ticket.url, {
+                method: ticket.method,
+                // Exactly what was signed, and nothing else. An extra header is
+                // harmless, but a MISSING or altered one is a signature failure.
+                headers: { ...ticket.headers },
+                body: body,
+            });
+            if (!response.ok) {
+                const detail = await response.text().catch(() => '');
+                throw new ValidationError({
+                    code: 'UPLOAD_PUT_REFUSED',
+                    message: `The object store refused the upload (HTTP ${String(response.status)}). The commonest causes are a body whose length is not the \`size\` this upload was staged for, ` +
+                        `a changed \`content-type\`, and a URL that has expired.${detail ? ` Store said: ${detail.slice(0, 300)}` : ''}`,
+                    status: response.status,
+                    service: 'plugins',
+                });
+            }
+        },
+        async get(id, options) {
+            return await transport.rest('plugins', { method: 'GET', path: `/uploads/${encodeURIComponent(id)}` }, { ...options, preserveKeys: PRESERVE });
+        },
+        async claimAsAsset(id, input, options) {
+            const body = await transport.rest('cms', {
+                method: 'POST',
+                path: '/assets/from-staged',
+                body: {
+                    staged_upload_id: id,
+                    ...(input?.folderId === undefined ? {} : { folder_id: input.folderId }),
+                    ...(input?.altText === undefined ? {} : { alt_text: input.altText }),
+                },
+            }, options);
+            return body.data;
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sixtyninecommerce/admin",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Back-office SDK for sixtynine-commerce: every capability of the platform as a method",
   "homepage": "https://github.com/SIXTYNINE-digital/sixtynine-commerce-engine/tree/main/packages/admin-client#readme",
   "repository": {
@@ -33,7 +33,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@sixtyninecommerce/core": "^0.3.0"
+    "@sixtyninecommerce/core": "^0.4.0"
   },
   "devDependencies": {
     "@types/node": "22.19.7",
@@ -41,7 +41,7 @@
     "vitest": "4.1.6"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
     "dev": "tsc -p tsconfig.build.json --watch",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",