@neuraiproject/neurai-assets 1.7.1 → 1.7.2

package/README.md

@@ -1132,6 +1132,19 @@ remain available as `totalSats` / raw methods; never use a rounded display value
 as a new transaction input.
 
 
+## 1.7.2: CommonJS type declarations
+
+`require()` loads `dist/index.cjs`, but the package only published the ESM
+declarations (`index.d.ts`), so a CommonJS file compiled with
+`moduleResolution: "node16"` got `TS1471` and no types. The `require`
+condition now has its own declarations, `dist/index.d.cts`, written by the
+build from `index.d.ts` (both entry points export the same values, with
+`default === NeuraiAssets`). No runtime or API change. `npm run test:types`
+also compiles ESM, CommonJS and browser consumers against the declarations
+(NodeNext, Node16, Bundler; `skipLibCheck: false`), and `npm run
+test:package` checks the packed tarball in a clean project, with TypeScript
+4.7 too.
+
 ## 1.7.1: type declarations
 
 `index.d.ts` exported `AssetQueries` twice (`export class AssetQueries` plus

package/dist/index.d.cts

@@ -0,0 +1,500 @@
+/** Display units and protocol integers are distinct contracts. */
+export type DecimalAmount = number | string;
+export type RawAmount = bigint | number | string;
+
+export interface AssetAmountUtilities {
+  PROTOCOL_DECIMALS: 8;
+  PROTOCOL_SCALE: bigint;
+  MAX_MONEY_RAW: bigint;
+  assetAmountToRaw(value: DecimalAmount, units?: number | null, options?: { label?: string }): bigint;
+  xnaAmountToSats(value: DecimalAmount, options?: {
+    label?: string; allowNegative?: boolean; rounding?: 'exact' | 'ceil';
+  }): bigint;
+  formatRawAsDecimal(raw: bigint): string;
+  rawToDisplayAmount(raw: RawAmount): DecimalAmount;
+  rawToDisplayNumber(raw: bigint, label?: string): number;
+  toProtocolInteger(value: RawAmount, label?: string): bigint;
+  sumProtocolIntegers(items: Array<Record<string, unknown>>, field?: string, label?: string): bigint;
+  expandScientificNotation(text: string): string;
+  normalizeDecimalText(value: DecimalAmount, label: string): string;
+  scaleDecimalText(text: string, decimals: number, label: string, rounding?: 'exact' | 'ceil'): bigint;
+}
+
+/** @deprecated Uses legacy 10^units scaling and may round. Use utils.AssetAmount. */
+export interface LegacyAmountConverter {
+  new(): object;
+  toSatoshis(amount: number, units: number): number;
+  fromSatoshis(satoshis: number, units: number): number;
+  format(amount: number, units: number): string;
+  parse(formattedAmount: string): number;
+  getDecimalPlaces(amount: number): number;
+  adjustToUnits(amount: number, units: number): number;
+}
+
+/** Destination kind of an address or scriptPubKey. */
+export type AddressKind = 'p2pkh' | 'authscript' | 'pq' | 'ecdsa' | 'unknown';
+
+export interface FeeSizingVbytes {
+  readonly baseTxOverheadBytes: number;
+  readonly segwitMarkerVbytes: number;
+  readonly legacyInputVbytes: number;
+  readonly pqInputVbytes: number;
+  readonly ecdsaWitnessInputVbytes: number;
+  readonly legacyOutputBytes: number;
+  readonly witnessOutputBytes: number;
+  /** @deprecated Same as witnessOutputBytes. */
+  readonly pqOutputBytes: number;
+}
+
+export interface FeeSizingInput {
+  script?: string;
+  address?: string;
+}
+
+export type FeeSizingOutput = string | {
+  address?: string;
+  assetName?: string;
+  kind?: 'transfer' | 'owner' | 'issue' | 'reissue' | 'tag' | 'restriction' | 'globalRestriction' | 'verifier';
+  hasIpfs?: boolean;
+  ipfsHash?: string;
+  verifierString?: string;
+};
+
+export interface FeeSizingUtilities {
+  VBYTES: FeeSizingVbytes;
+  getAddressKind(address: string): AddressKind;
+  getScriptKind(scriptHex: string): AddressKind;
+  /** True for PQ v2 and generic AuthScript v1 addresses. */
+  isPQAddress(address: string): boolean;
+  /** True for OP_1 / OP_2 scriptPubKeys with a 32-byte program. */
+  isPQScript(scriptHex: string): boolean;
+  estimateInputVbytes(utxo: FeeSizingInput): number;
+  estimateOutputBytes(target: FeeSizingOutput): number;
+  estimateTransactionVbytes(inputs: FeeSizingInput[], outputs: FeeSizingOutput[]): number;
+  assetPayloadBytes(descriptor: FeeSizingOutput): number;
+  compactSizeBytes(n: number): number;
+}
+
+export interface AssetUtilities extends Record<string, unknown> {
+  AssetAmount: AssetAmountUtilities;
+  /** @deprecated Uses legacy scaling and may round. Use AssetAmount. */
+  AmountConverter: LegacyAmountConverter;
+  FeeSizing: FeeSizingUtilities;
+}
+
+export interface InsufficientFundsErrorInstance extends Error {
+  code: 'INSUFFICIENT_FUNDS';
+  required: DecimalAmount;
+  available: DecimalAmount;
+}
+
+export interface AssetErrors extends Record<string, unknown> {
+  InsufficientFundsError: new(message: string, required: DecimalAmount, available: DecimalAmount) => InsufficientFundsErrorInstance;
+}
+
+/**
+ * NIP-040 asset payload marker. The chain decides which one new asset
+ * outputs must carry; the node reports it as
+ * `getblockchaininfo.asset_marker`. Omit to let the builders ask the node
+ * (falls back to 'rvn' on nodes that do not report the field).
+ */
+export type AssetMarker = 'rvn' | 'xna';
+
+/**
+ * What to do when `getblockchaininfo` FAILS while resolving the marker.
+ *
+ * - `legacy-fallback` (default in 1.x): resolve `'rvn'`, as 1.4.x did.
+ * - `strict`: propagate the error. On a post-NIP-040 chain a guessed `'rvn'`
+ *   builds a transaction the node rejects, so "the node did not answer" must
+ *   not become "the node said rvn".
+ *
+ * A node that simply predates the field resolves `'rvn'` under both policies:
+ * that is an answer, not a failure.
+ */
+export type AssetMarkerPolicy = 'strict' | 'legacy-fallback';
+
+export interface NeuraiAssetsConfig {
+  network?: string;
+  addresses?: string[];
+  changeAddress?: string | null;
+  toAddress?: string | null;
+  assetMarker?: AssetMarker;
+  assetMarkerPolicy?: AssetMarkerPolicy;
+}
+
+/**
+ * @deprecated Since 1.5.0. Use {@link NeuraiAssetsBuildResult.createTransactionBuild},
+ * which is the exact shape `createFromOperation` accepts. Removed in 2.0.0.
+ */
+export type LegacyOperationType =
+  | 'ISSUE_ROOT'
+  | 'ISSUE_SUB'
+  | 'ISSUE_DEPIN'
+  | 'ISSUE_UNIQUE'
+  | 'ISSUE_QUALIFIER'
+  | 'ISSUE_SUB_QUALIFIER'
+  | 'ISSUE_RESTRICTED'
+  | 'REISSUE'
+  | 'REISSUE_RESTRICTED'
+  | 'TAG_ADDRESSES'
+  | 'UNTAG_ADDRESSES'
+  | 'FREEZE_ADDRESSES'
+  | 'UNFREEZE_ADDRESSES'
+  | 'FREEZE_ASSET'
+  | 'UNFREEZE_ASSET';
+
+/** @deprecated Alias kept for 1.x consumers. Use {@link LegacyOperationType}. */
+export type OperationType = LegacyOperationType;
+
+/**
+ * How `rawTx` was produced. `'rpc-node'`: the node's `createrawtransaction`.
+ * `'local-builder'`: built locally with `createFromOperation` — used by the
+ * reissue operations since 1.5.0, because the RPC's reissue objects cannot
+ * express "keep the current units" and reject any asset with units > 0.
+ */
+export type BuildStrategy = 'rpc-node' | 'local-builder';
+
+export interface BuildInput {
+  txid: string;
+  vout: number;
+  address: string;
+  satoshis: RawAmount;
+  assetName?: string;
+}
+
+/**
+ * @deprecated Since 1.5.0. Its `*Raw` fields carry DISPLAY amounts, its
+ * `TRANSFER` discriminant is not one `createFromOperation` accepts, and its
+ * `params` is an open record with no narrowing. Kept unchanged through 1.x for
+ * existing consumers; removed in 2.0.0. Use `createTransactionBuild`.
+ */
+export interface LocalRawBuild {
+  operationType: LegacyOperationType | 'TRANSFER';
+  /** Includes `assetMarker` (NIP-040) for createFromOperation >= 0.7.0. */
+  params: Record<string, unknown> & { assetMarker?: AssetMarker };
+}
+
+/** The canonical network labels the serializer understands. */
+export type CanonicalNetwork = 'xna' | 'xna-test';
+
+/** Outpoint reference, exactly as create-transaction consumes it. */
+export interface CanonicalInput {
+  txid: string;
+  vout: number;
+}
+
+/** An XNA payment output. */
+export interface CanonicalPayment {
+  address: string;
+  valueSats: bigint;
+}
+
+/** One asset transfer output. `amountRaw` is 10^8-scaled, never a display value. */
+export interface CanonicalTransfer {
+  address: string;
+  assetName: string;
+  amountRaw: bigint;
+  assetMarker?: AssetMarker;
+}
+
+/** Fields every canonical build carries. */
+export interface CanonicalParamsBase {
+  inputs: CanonicalInput[];
+  assetMarker: AssetMarker;
+}
+
+/** The XNA envelope shared by the operations that burn and/or return change. */
+export interface CanonicalXnaEnvelope {
+  burnAddress?: string;
+  burnAmountSats?: bigint;
+  xnaChangeAddress?: string;
+  xnaChangeSats?: bigint;
+}
+
+export interface CanonicalIssueParams extends CanonicalParamsBase, CanonicalXnaEnvelope {
+  toAddress: string;
+  assetName: string;
+  quantityRaw: bigint;
+  units?: number;
+  reissuable?: boolean;
+  ipfsHash?: string;
+  ownerTokenAddress?: string;
+}
+
+export interface CanonicalIssueSubParams extends CanonicalParamsBase, CanonicalXnaEnvelope {
+  toAddress: string;
+  assetName: string;
+  quantityRaw: bigint;
+  units?: number;
+  reissuable?: boolean;
+  ipfsHash?: string;
+  parentOwnerAddress?: string;
+}
+
+export interface CanonicalIssueDepinParams extends CanonicalParamsBase, CanonicalXnaEnvelope {
+  toAddress: string;
+  assetName: string;
+  quantityRaw: bigint;
+  ipfsHash?: string;
+  ownerTokenAddress?: string;
+  reissuable?: boolean;
+  /** Canonical label, so the serializer's mainnet DePIN guard actually runs. */
+  network: CanonicalNetwork;
+}
+
+export interface CanonicalIssueUniqueParams extends CanonicalParamsBase, CanonicalXnaEnvelope {
+  toAddress: string;
+  rootName: string;
+  assetTags: string[];
+  ipfsHashes?: Array<string | undefined>;
+  ownerTokenAddress?: string;
+}
+
+export interface CanonicalIssueQualifierParams extends CanonicalParamsBase, CanonicalXnaEnvelope {
+  toAddress: string;
+  assetName: string;
+  quantityRaw: bigint;
+  ipfsHash?: string;
+  rootChangeAddress?: string;
+  changeQuantityRaw?: bigint;
+}
+
+export interface CanonicalIssueRestrictedParams extends CanonicalParamsBase, CanonicalXnaEnvelope {
+  toAddress: string;
+  assetName: string;
+  quantityRaw: bigint;
+  verifierString: string;
+  units?: number;
+  reissuable?: boolean;
+  ipfsHash?: string;
+  ownerChangeAddress?: string;
+}
+
+export interface CanonicalReissueParams extends CanonicalParamsBase, CanonicalXnaEnvelope {
+  toAddress: string;
+  assetName: string;
+  quantityRaw: bigint;
+  /**
+   * Always omitted by this library: it has no API to change an asset's units,
+   * so its builds mean "keep the current ones", which the serializer encodes
+   * as `0xff`. Present in the type because create-transaction accepts it.
+   */
+  units?: number;
+  reissuable?: boolean;
+  ipfsHash?: string;
+  ownerChangeAddress?: string;
+  verifierString?: string;
+}
+
+export interface CanonicalTagParams extends CanonicalParamsBase {
+  qualifierName: string;
+  targetAddresses: string[];
+  burnAddress: string;
+  burnAmountSats: bigint;
+  xnaChangeAddress: string;
+  xnaChangeSats: bigint;
+  qualifierChangeAddress: string;
+  qualifierChangeAmountRaw: bigint;
+}
+
+export interface CanonicalFreezeAddressesParams extends CanonicalParamsBase {
+  assetName: string;
+  targetAddresses: string[];
+  ownerChangeAddress: string;
+  xnaChangeAddress?: string;
+  xnaChangeSats?: bigint;
+}
+
+export interface CanonicalFreezeAssetParams extends CanonicalParamsBase {
+  assetName: string;
+  ownerChangeAddress: string;
+  xnaChangeAddress?: string;
+  xnaChangeSats?: bigint;
+}
+
+export interface CanonicalStandardTransferParams extends CanonicalParamsBase {
+  payments: CanonicalPayment[];
+  transfers: CanonicalTransfer[];
+}
+
+export interface CanonicalDepinTransferParams extends CanonicalParamsBase {
+  transfers: CanonicalTransfer[];
+  /** Destination of the escorting `&X!` output, which the serializer emits itself. */
+  ownerChangeAddress: string;
+  xnaChangeAddress?: string;
+  xnaChangeSats?: bigint;
+  network: CanonicalNetwork;
+}
+
+/**
+ * The exact value `createFromOperation` accepts, with no adaptation:
+ *
+ * ```ts
+ * const result = await assets.transferAsset({ ... });
+ * const built = createFromOperation(result.createTransactionBuild);
+ * ```
+ *
+ * Discriminated on `operationType`, closed (no index signature), and every
+ * amount is a protocol integer.
+ */
+export type CreateTransactionBuild =
+  | { operationType: 'ISSUE_ROOT'; params: CanonicalIssueParams }
+  | { operationType: 'ISSUE_SUB'; params: CanonicalIssueSubParams }
+  | { operationType: 'ISSUE_DEPIN'; params: CanonicalIssueDepinParams }
+  | { operationType: 'ISSUE_UNIQUE'; params: CanonicalIssueUniqueParams }
+  | { operationType: 'ISSUE_QUALIFIER' | 'ISSUE_SUB_QUALIFIER'; params: CanonicalIssueQualifierParams }
+  | { operationType: 'ISSUE_RESTRICTED'; params: CanonicalIssueRestrictedParams }
+  | { operationType: 'REISSUE' | 'REISSUE_RESTRICTED'; params: CanonicalReissueParams }
+  | { operationType: 'TAG_ADDRESSES' | 'UNTAG_ADDRESSES'; params: CanonicalTagParams }
+  | { operationType: 'FREEZE_ADDRESSES' | 'UNFREEZE_ADDRESSES'; params: CanonicalFreezeAddressesParams }
+  | { operationType: 'FREEZE_ASSET' | 'UNFREEZE_ASSET'; params: CanonicalFreezeAssetParams }
+  | { operationType: 'STANDARD_TRANSFER'; params: CanonicalStandardTransferParams }
+  | { operationType: 'TRANSFER_DEPIN'; params: CanonicalDepinTransferParams };
+
+/** The discriminants this library exposes canonically. */
+export type CreateTransactionOperationType = CreateTransactionBuild['operationType'];
+
+export interface NeuraiAssetsBuildResult {
+  rawTx: string;
+  fee: number | string;
+  burnAmount: number;
+  network: string;
+  buildStrategy: BuildStrategy;
+  burnAddress: string | null;
+  changeAddress: string | null;
+  changeAmount: DecimalAmount | null;
+  operationType?: LegacyOperationType | 'TRANSFER';
+  /**
+   * Ready for `createFromOperation(...)` as-is. Always present on a successful
+   * build; narrow it with `operationType`.
+   */
+  createTransactionBuild: CreateTransactionBuild;
+  /** @deprecated Since 1.5.0; removed in 2.0.0. See {@link LocalRawBuild}. */
+  localRawBuild?: LocalRawBuild;
+  inputs: BuildInput[];
+  /**
+   * The `createrawtransaction` output envelope, in display amounts.
+   *
+   * Do NOT index these against `rawTx`'s vouts. They match on the `'rpc-node'`
+   * path, but not on `'local-builder'` (the reissue operations since 1.5.0):
+   * the node auto-generates the owner-token return while processing a reissue
+   * entry, so this envelope omits it, whereas the locally built `rawTx`
+   * carries it explicitly — three entries here against four vouts there.
+   * Both are valid; they are simply two descriptions of the same operation.
+   * Parse `rawTx` when you need the outputs the chain will see.
+   */
+  outputs: Array<Record<string, unknown>>;
+  utxos?: unknown[];
+  assetData?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+
+export interface DepinHolderEntry {
+  address: string;
+  amount?: number;
+  valid?: boolean;
+  [key: string]: unknown;
+}
+
+export interface DepinValidityResult {
+  assetName?: string;
+  address: string;
+  valid: boolean;
+  [key: string]: unknown;
+}
+
+declare class AssetQueries {
+  constructor(rpc: (method: string, params?: unknown[]) => Promise<unknown> | unknown);
+  getAssetData(assetName: string): Promise<Record<string, unknown>>;
+  listAssets(filter?: string, verbose?: boolean, count?: number, start?: number): Promise<unknown>;
+  listMyAssets(assetName?: string, verbose?: boolean, count?: number, start?: number, confs?: number): Promise<Record<string, unknown>>;
+  listAddressesByAsset(assetName: string, onlyCount?: boolean, count?: number, start?: number): Promise<unknown>;
+  listAssetBalancesByAddress(address: string, onlyTotal?: boolean, count?: number, start?: number): Promise<unknown>;
+  checkAddressTag(address: string, qualifierName: string): Promise<boolean>;
+  listTagsForAddress(address: string): Promise<string[]>;
+  listAddressesForTag(qualifierName: string): Promise<string[]>;
+  checkAddressRestriction(address: string, restrictedAssetName: string): Promise<boolean>;
+  isAddressFrozen(address: string, restrictedAssetName: string): Promise<boolean>;
+  checkGlobalRestriction(restrictedAssetName: string): Promise<boolean>;
+  getVerifierString(restrictedAssetName: string): Promise<string>;
+  isValidVerifierString(verifierString: string): Promise<boolean>;
+  getSnapshotRequest(assetName: string, blockHeight: number): Promise<Record<string, unknown>>;
+  cancelSnapshotRequest(assetName: string, blockHeight: number): Promise<boolean>;
+  listDepinHolders(assetName: string): Promise<DepinHolderEntry[]>;
+  checkDepinValidity(assetName: string, address: string): Promise<DepinValidityResult>;
+  assetExists(assetName: string): Promise<boolean>;
+  getAssetType(assetName: string): string;
+  getAssetCount(): Promise<number>;
+}
+
+declare class NeuraiAssets {
+  constructor(rpc: (method: string, params?: unknown[]) => Promise<unknown> | unknown, config?: NeuraiAssetsConfig);
+
+  rpc: (method: string, params?: unknown[]) => Promise<unknown> | unknown;
+  config: Required<NeuraiAssetsConfig>;
+  queries: AssetQueries;
+
+  updateConfig(config: Partial<NeuraiAssetsConfig>): void;
+
+  createRootAsset(params: Record<string, unknown>): Promise<NeuraiAssetsBuildResult>;
+  createSubAsset(params: Record<string, unknown>): Promise<NeuraiAssetsBuildResult>;
+  createDepinAsset(params: Record<string, unknown>): Promise<NeuraiAssetsBuildResult>;
+  reissueAsset(params: Record<string, unknown>): Promise<NeuraiAssetsBuildResult>;
+  transferAsset(params: Record<string, unknown>): Promise<NeuraiAssetsBuildResult>;
+  createUniqueAssets(params: Record<string, unknown>): Promise<NeuraiAssetsBuildResult>;
+  createQualifier(params: Record<string, unknown>): Promise<NeuraiAssetsBuildResult>;
+  tagAddresses(params: Record<string, unknown>): Promise<NeuraiAssetsBuildResult>;
+  untagAddresses(params: Record<string, unknown>): Promise<NeuraiAssetsBuildResult>;
+  createRestrictedAsset(params: Record<string, unknown>): Promise<NeuraiAssetsBuildResult>;
+  reissueRestrictedAsset(params: Record<string, unknown>): Promise<NeuraiAssetsBuildResult>;
+  freezeAddresses(params: Record<string, unknown>): Promise<NeuraiAssetsBuildResult>;
+  unfreezeAddresses(params: Record<string, unknown>): Promise<NeuraiAssetsBuildResult>;
+  freezeAssetGlobally(params: Record<string, unknown>): Promise<NeuraiAssetsBuildResult>;
+  unfreezeAssetGlobally(params: Record<string, unknown>): Promise<NeuraiAssetsBuildResult>;
+
+  getAssetData(assetName: string): Promise<Record<string, unknown>>;
+  listAssets(filter?: string, verbose?: boolean, count?: number, start?: number): Promise<unknown>;
+  listMyAssets(assetName?: string, verbose?: boolean, count?: number, start?: number, confs?: number): Promise<Record<string, unknown>>;
+  listAddressesByAsset(assetName: string, onlyCount?: boolean, count?: number, start?: number): Promise<unknown>;
+  listAssetBalancesByAddress(address: string, onlyTotal?: boolean, count?: number, start?: number): Promise<unknown>;
+  checkAddressTag(address: string, qualifierName: string): Promise<boolean>;
+  listTagsForAddress(address: string): Promise<string[]>;
+  listAddressesForTag(qualifierName: string): Promise<string[]>;
+  checkAddressRestriction(address: string, restrictedAssetName: string): Promise<boolean>;
+  isAddressFrozen(address: string, restrictedAssetName: string): Promise<boolean>;
+  checkGlobalRestriction(restrictedAssetName: string): Promise<boolean>;
+  getVerifierString(restrictedAssetName: string): Promise<string>;
+  isValidVerifierString(verifierString: string): Promise<boolean>;
+  getSnapshotRequest(assetName: string, blockHeight: number): Promise<Record<string, unknown>>;
+  cancelSnapshotRequest(assetName: string, blockHeight: number): Promise<boolean>;
+  listDepinHolders(assetName: string): Promise<DepinHolderEntry[]>;
+  checkDepinValidity(assetName: string, address: string): Promise<DepinValidityResult>;
+  assetExists(assetName: string): Promise<boolean>;
+  getAssetType(assetName: string): string;
+  getAssetCount(): Promise<number>;
+
+  static NeuraiAssets: typeof NeuraiAssets;
+  static AssetQueries: typeof AssetQueries;
+  static builders: Record<string, unknown>;
+  static constants: Record<string, unknown>;
+  static errors: AssetErrors;
+  static validators: Record<string, unknown>;
+  static utils: AssetUtilities;
+}
+
+declare const builders: Record<string, unknown>;
+declare const constants: Record<string, unknown>;
+declare const errors: AssetErrors;
+declare const validators: Record<string, unknown>;
+declare const utils: AssetUtilities;
+
+export default NeuraiAssets;
+export {
+  AssetQueries,
+  NeuraiAssets,
+  builders,
+  constants,
+  errors,
+  utils,
+  validators
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neuraiproject/neurai-assets",
-  "version": "1.7.1",
+  "version": "1.7.2",
   "description": "Non-custodial Neurai asset management library for JavaScript",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -9,9 +9,14 @@
   "types": "./index.d.ts",
   "exports": {
     ".": {
-      "types": "./index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
+      "import": {
+        "types": "./index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
     },
     "./browser": {
       "types": "./index.d.ts",
@@ -25,13 +30,14 @@
     "README.md"
   ],
   "scripts": {
-    "build": "rollup -c rollup.config.mjs",
+    "build": "rollup -c rollup.config.mjs && node scripts/write-cjs-declarations.mjs",
     "test": "npm run build && mocha ./tests/unit/**/*.test.js ./tests/integration/**/*.test.js ./tests/browser/**/*.test.js && npm run test:types",
     "test:unit": "mocha ./tests/unit/**/*.test.js",
     "test:integration": "mocha ./tests/integration/**/*.test.js",
     "test:browser": "npm run build && mocha ./tests/browser/**/*.test.js",
     "test:watch": "mocha --watch ./tests/**/*.test.js",
-    "test:types": "tsc -p tsconfig.types.json && tsc -p tsconfig.dts.json"
+    "test:types": "tsc -p tsconfig.types.json && tsc -p tsconfig.dts.json && tsc -p tsconfig.types-nodenext.json && tsc -p tsconfig.types-node16.json && tsc -p tsconfig.types-bundler.json",
+    "test:package": "npm run build && node scripts/check-package.mjs"
   },
   "repository": {
     "type": "git",