zapo-js 0.3.0 → 1.0.0

package/dist/types/util/bytes.d.ts

@@ -11,9 +11,19 @@ export declare function bytesToHex(value: Uint8Array): string;
  * Decodes a hex string to a Uint8Array
  */
 export declare function hexToBytes(value: string): Uint8Array;
+/** Encodes a Uint8Array to a standard padded base64 string. */
 export declare function bytesToBase64(value: Uint8Array): string;
+/**
+ * Decodes a standard padded base64 string to a Uint8Array. Throws on invalid
+ * characters or a length that is not a multiple of 4.
+ */
 export declare function base64ToBytes(value: string): Uint8Array;
-export declare function base64ToBytesChecked(value: string, field: string, requireNonEmpty?: boolean): Uint8Array;
+export declare function base64ToBytesChecked(value: string, field: string): Uint8Array;
+/**
+ * Decodes a base64url-encoded value to a Uint8Array, restoring padding and
+ * the `+`/`/` alphabet first. Throws with a `missing ${field}` message when
+ * `value` is empty/undefined.
+ */
 export declare function decodeBase64Url(value: string | undefined, field: string): Uint8Array;
 export declare function assertByteLength(value: Uint8Array, expectedLength: number, errorMessage: string): void;
 export declare function decodeProtoBytes(value: Uint8Array | string | null | undefined, field: string): Uint8Array;
@@ -21,13 +31,38 @@ export declare function decodeProtoBytes(value: Uint8Array | string | null | und
  * Encodes a Uint8Array to a base64url string (URL-safe, no padding)
  */
 export declare function bytesToBase64UrlSafe(value: Uint8Array): string;
+/** Concatenates an array of Uint8Arrays into a single new Uint8Array. */
 export declare function concatBytes(parts: readonly Uint8Array[]): Uint8Array;
+/**
+ * Returns a zero-copy `Uint8Array` view over the input. Subclasses of
+ * `Uint8Array` (Node `Buffer`) are wrapped in a plain view; `ArrayBuffer`/
+ * `ArrayBufferView` get a view over their backing buffer. Use at system
+ * boundaries (WebCrypto / Node crypto / WebSocket results) – not on values
+ * that are already plain `Uint8Array`.
+ */
 export declare function toBytesView(value: Uint8Array | ArrayBuffer | ArrayBufferView): Uint8Array;
+/**
+ * Normalizes an arbitrary stream chunk (string / Uint8Array / ArrayBuffer /
+ * ArrayBufferView) to a Uint8Array. Throws on unsupported types.
+ */
 export declare function toChunkBytes(chunk: unknown): Uint8Array;
+/**
+ * Constant-time, JIT-resistant equality over `Uint8Array`s. Required for
+ * MAC/HMAC/signature comparisons (use {@link uint8Equal} for non-secret data).
+ */
 export declare function uint8TimingSafeEqual(left: Uint8Array, right: Uint8Array): boolean;
+/**
+ * XOR-accumulated equality over `Uint8Array`s. Suitable for non-secret data
+ * (e.g. identity key match). Use {@link uint8TimingSafeEqual} for MAC checks.
+ */
 export declare function uint8Equal(a: Uint8Array, b: Uint8Array): boolean;
 export declare function removeAt<T>(items: readonly T[], index: number): T[];
 export declare function intToBytes(byteLength: number, value: number): Uint8Array;
+/**
+ * Drains a Node `Readable` stream into a single Uint8Array. When
+ * `options.maxBytes` is set, the stream is destroyed and the promise rejects
+ * once the limit is exceeded.
+ */
 export declare function readAllBytes(stream: Readable, options?: {
     readonly maxBytes?: number;
 }): Promise<Uint8Array>;

package/dist/types/util/clock.d.ts

@@ -0,0 +1,6 @@
+export type GetClockSkewMs = () => number | null | undefined;
+export interface ServerClock {
+    nowMs(): number;
+    nowSeconds(): number;
+}
+export declare function createServerClock(getClockSkewMs: GetClockSkewMs): ServerClock;

package/dist/types/util/coercion.d.ts

@@ -1,8 +1,33 @@
+/**
+ * Coerces `value` to a safe-integer/finite number, accepting `number` and
+ * `bigint` inputs. Throws with a `${field}`-suffixed message on any other type.
+ */
 export declare function asNumber(value: unknown, field: string): number;
+/** Optional variant of {@link asNumber}; returns `undefined` when input is nullish. */
 export declare function asOptionalNumber(value: unknown, field?: string): number | undefined;
+/** Asserts that `value` is a string. Throws with a `${field}`-suffixed message otherwise. */
 export declare function asString(value: unknown, field: string): string;
+/** Optional variant of {@link asString}; returns `undefined` when input is nullish. */
 export declare function asOptionalString(value: unknown, field?: string): string | undefined;
+/**
+ * Coerces `value` to a Uint8Array view, accepting `Uint8Array`, `ArrayBuffer`,
+ * and any `ArrayBufferView`. Throws with a `${field}`-suffixed message otherwise.
+ */
 export declare function asBytes(value: unknown, field: string): Uint8Array;
+/** Optional variant of {@link asBytes}; returns `undefined` when input is nullish. */
 export declare function asOptionalBytes(value: unknown, field?: string): Uint8Array | undefined;
+/** Returns `undefined` when `value` is nullish, otherwise `Boolean(value)`. */
 export declare function toBoolOrUndef(value: unknown): boolean | undefined;
+/**
+ * Returns `value` when it is a positive safe-integer, `fallback` when it is
+ * undefined, and throws otherwise.
+ */
 export declare function resolvePositive(value: number | undefined, fallback: number, name: string): number;
+/**
+ * Lenient variants for parsing external JSON payloads (GraphQL responses,
+ * Mex notifications) where fields may be missing, empty, or arrive as the
+ * wrong primitive. Return null instead of throwing.
+ */
+export declare function tryAsString(value: unknown): string | null;
+export declare function tryAsNumber(value: unknown): number | null;
+export declare function tryAsRecord(value: unknown): Readonly<Record<string, unknown>> | null;

package/dist/types/util/collections.d.ts

@@ -1,3 +1,11 @@
 export declare function resolveCleanupIntervalMs(ttlMs: number, maxIntervalMs?: number): number;
+export interface PeriodicCleanupHandle {
+    readonly destroy: () => void;
+}
+export declare function createPeriodicCleanup(ttlMs: number, run: () => void): PeriodicCleanupHandle;
+/**
+ * Returns a validated positive-safe-integer query limit, falling back to
+ * `defaultLimit` when `limit` is undefined. Throws on invalid input.
+ */
 export declare function normalizeQueryLimit(limit: number | undefined, defaultLimit: number): number;
 export declare function setBoundedMapEntry<K, V>(map: Map<K, V>, key: K, value: V, maxEntries: number, onEvict?: (key: K, value: V) => void): void;

package/dist/types/util/index.d.ts

@@ -1,5 +1,5 @@
-export { bytesToHex, hexToBytes, toBytesView, uint8Equal } from './bytes';
+export { base64ToBytes, bytesToBase64, bytesToBase64UrlSafe, bytesToHex, decodeBase64Url, hexToBytes, TEXT_DECODER, toBytesView, uint8Equal } from './bytes';
 export { asBytes, asNumber, asOptionalBytes, asOptionalNumber, asOptionalString, asString, resolvePositive, toBoolOrUndef } from './coercion';
 export { normalizeQueryLimit } from './collections';
-export { toSafeNumber } from './primitives';
+export { toError, toSafeNumber } from './primitives';
 export { isBunRuntime } from './runtime';

package/dist/types/util/primitives.d.ts

@@ -1,4 +1,14 @@
+/**
+ * Normalizes an unknown thrown value into an `Error` – `Error` instances are
+ * returned unchanged, strings/numbers are wrapped, and objects with `message`
+ * or `code` fields are mapped to readable messages. Use in `catch` blocks
+ * before logging.
+ */
 export declare function toError(value: unknown): Error;
+/**
+ * Coerces a `number` or `{ toNumber() }` (protobufjs `Long`) to a finite
+ * safe-integer. Throws on missing/non-numeric/out-of-range inputs.
+ */
 export declare function toSafeNumber(value: number | {
     toNumber?: () => number;
 } | null | undefined, field: string): number;
@@ -7,3 +17,4 @@ export declare function longToNumber(value: number | {
 } | null | undefined): number;
 export declare function normalizeNonNegativeInteger(value: number | undefined, fallback: number): number;
 export declare function parseOptionalInt(value: string | undefined): number | undefined;
+export declare function parseOptionalSignedInt(value: string | undefined): number | undefined;

package/dist/types/util/runtime.d.ts

@@ -1,2 +1,7 @@
+/**
+ * Returns a human-friendly OS name (`Windows` / `Mac OS` / `Linux`) for the
+ * current process, falling back to `process.platform` for other OSes.
+ */
 export declare function getRuntimeOsDisplayName(): string;
+/** Returns `true` when running under the Bun runtime. */
 export declare function isBunRuntime(): boolean;

package/dist/types/version-spec.d.ts

@@ -0,0 +1 @@
+export { WA_VERSION } from '../spec/version';

package/dist/util/async.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.delay = delay;
+/**
+ * Returns a Promise that resolves after `ms` milliseconds. Thin wrapper over
+ * `setTimeout` for use in `await` chains.
+ */
 function delay(ms) {
     return new Promise((resolve) => {
         setTimeout(resolve, ms);

package/dist/util/bytes.js

@@ -82,9 +82,14 @@ function hexToBytes(value) {
     }
     return out;
 }
+/** Encodes a Uint8Array to a standard padded base64 string. */
 function bytesToBase64(value) {
     return encodeBase64(value, BASE64_CHARS, true);
 }
+/**
+ * Decodes a standard padded base64 string to a Uint8Array. Throws on invalid
+ * characters or a length that is not a multiple of 4.
+ */
 function base64ToBytes(value) {
     const len = value.length;
     if (len === 0)
@@ -124,12 +129,17 @@ function base64ToBytes(value) {
     }
     return out;
 }
-function base64ToBytesChecked(value, field, requireNonEmpty = true) {
-    if (requireNonEmpty && value.length === 0) {
+function base64ToBytesChecked(value, field) {
+    if (value.length === 0) {
         throw new Error(`invalid base64 payload for ${field}`);
     }
     return base64ToBytes(value);
 }
+/**
+ * Decodes a base64url-encoded value to a Uint8Array, restoring padding and
+ * the `+`/`/` alphabet first. Throws with a `missing ${field}` message when
+ * `value` is empty/undefined.
+ */
 function decodeBase64Url(value, field) {
     if (!value) {
         throw new Error(`missing ${field}`);
@@ -209,6 +219,7 @@ function encodeBase64(value, alphabet, pad) {
     }
     return out.join('');
 }
+/** Concatenates an array of Uint8Arrays into a single new Uint8Array. */
 function concatBytes(parts) {
     let total = 0;
     for (let i = 0; i < parts.length; i += 1) {
@@ -222,6 +233,13 @@ function concatBytes(parts) {
     }
     return out;
 }
+/**
+ * Returns a zero-copy `Uint8Array` view over the input. Subclasses of
+ * `Uint8Array` (Node `Buffer`) are wrapped in a plain view; `ArrayBuffer`/
+ * `ArrayBufferView` get a view over their backing buffer. Use at system
+ * boundaries (WebCrypto / Node crypto / WebSocket results) – not on values
+ * that are already plain `Uint8Array`.
+ */
 function toBytesView(value) {
     if (value instanceof Uint8Array) {
         return value.constructor === Uint8Array
@@ -233,6 +251,10 @@ function toBytesView(value) {
     }
     return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
 }
+/**
+ * Normalizes an arbitrary stream chunk (string / Uint8Array / ArrayBuffer /
+ * ArrayBufferView) to a Uint8Array. Throws on unsupported types.
+ */
 function toChunkBytes(chunk) {
     if (typeof chunk === 'string') {
         return exports.TEXT_ENCODER.encode(chunk);
@@ -242,12 +264,20 @@ function toChunkBytes(chunk) {
     }
     throw new Error(`unsupported stream chunk type: ${typeof chunk}`);
 }
+/**
+ * Constant-time, JIT-resistant equality over `Uint8Array`s. Required for
+ * MAC/HMAC/signature comparisons (use {@link uint8Equal} for non-secret data).
+ */
 function uint8TimingSafeEqual(left, right) {
     if (left.byteLength !== right.byteLength) {
         return false;
     }
     return (0, node_crypto_1.timingSafeEqual)(left, right);
 }
+/**
+ * XOR-accumulated equality over `Uint8Array`s. Suitable for non-secret data
+ * (e.g. identity key match). Use {@link uint8TimingSafeEqual} for MAC checks.
+ */
 function uint8Equal(a, b) {
     if (a.length !== b.length) {
         return false;
@@ -290,6 +320,11 @@ function intToBytes(byteLength, value) {
     }
     return out;
 }
+/**
+ * Drains a Node `Readable` stream into a single Uint8Array. When
+ * `options.maxBytes` is set, the stream is destroyed and the promise rejects
+ * once the limit is exceeded.
+ */
 async function readAllBytes(stream, options = {}) {
     const maxBytes = options.maxBytes;
     if (maxBytes !== undefined && (!Number.isSafeInteger(maxBytes) || maxBytes < 0)) {

package/dist/util/clock.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServerClock = createServerClock;
+function createServerClock(getClockSkewMs) {
+    return {
+        nowMs() {
+            const skewMs = getClockSkewMs();
+            const nowMs = Date.now();
+            return Number.isFinite(skewMs) ? nowMs + skewMs : nowMs;
+        },
+        nowSeconds() {
+            const skewMs = getClockSkewMs();
+            const nowMs = Date.now();
+            const correctedMs = Number.isFinite(skewMs) ? nowMs + skewMs : nowMs;
+            return Math.floor(correctedMs / 1000);
+        }
+    };
+}

package/dist/util/coercion.js

@@ -8,47 +8,67 @@ exports.asBytes = asBytes;
 exports.asOptionalBytes = asOptionalBytes;
 exports.toBoolOrUndef = toBoolOrUndef;
 exports.resolvePositive = resolvePositive;
+exports.tryAsString = tryAsString;
+exports.tryAsNumber = tryAsNumber;
+exports.tryAsRecord = tryAsRecord;
 const bytes_1 = require("./bytes");
 const primitives_1 = require("./primitives");
+/**
+ * Coerces `value` to a safe-integer/finite number, accepting `number` and
+ * `bigint` inputs. Throws with a `${field}`-suffixed message on any other type.
+ */
 function asNumber(value, field) {
-    if (typeof value === 'bigint') {
-        return (0, primitives_1.toSafeNumber)(Number(value), field);
-    }
     if (typeof value === 'number') {
         return (0, primitives_1.toSafeNumber)(value, field);
     }
+    if (typeof value === 'bigint') {
+        return (0, primitives_1.toSafeNumber)(Number(value), field);
+    }
     throw new Error(`invalid number value for ${field}`);
 }
+/** Optional variant of {@link asNumber}; returns `undefined` when input is nullish. */
 function asOptionalNumber(value, field = 'optional number') {
     if (value === null || value === undefined)
         return undefined;
     return asNumber(value, field);
 }
+/** Asserts that `value` is a string. Throws with a `${field}`-suffixed message otherwise. */
 function asString(value, field) {
     if (typeof value === 'string') {
         return value;
     }
     throw new Error(`invalid string value for ${field}`);
 }
+/** Optional variant of {@link asString}; returns `undefined` when input is nullish. */
 function asOptionalString(value, field = 'optional string') {
     if (value === null || value === undefined)
         return undefined;
     return asString(value, field);
 }
+/**
+ * Coerces `value` to a Uint8Array view, accepting `Uint8Array`, `ArrayBuffer`,
+ * and any `ArrayBufferView`. Throws with a `${field}`-suffixed message otherwise.
+ */
 function asBytes(value, field) {
     if (value instanceof Uint8Array || value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
         return (0, bytes_1.toBytesView)(value);
     }
     throw new Error(`invalid bytes value for ${field}`);
 }
+/** Optional variant of {@link asBytes}; returns `undefined` when input is nullish. */
 function asOptionalBytes(value, field = 'optional bytes') {
     if (value === null || value === undefined)
         return undefined;
     return asBytes(value, field);
 }
+/** Returns `undefined` when `value` is nullish, otherwise `Boolean(value)`. */
 function toBoolOrUndef(value) {
     return value === null || value === undefined ? undefined : Boolean(value);
 }
+/**
+ * Returns `value` when it is a positive safe-integer, `fallback` when it is
+ * undefined, and throws otherwise.
+ */
 function resolvePositive(value, fallback, name) {
     if (value === undefined)
         return fallback;
@@ -56,3 +76,28 @@ function resolvePositive(value, fallback, name) {
         return value;
     throw new Error(`${name} must be a positive safe integer`);
 }
+/**
+ * Lenient variants for parsing external JSON payloads (GraphQL responses,
+ * Mex notifications) where fields may be missing, empty, or arrive as the
+ * wrong primitive. Return null instead of throwing.
+ */
+function tryAsString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+function tryAsNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value === 'string') {
+        const normalized = value.trim();
+        if (normalized.length === 0)
+            return null;
+        const parsed = Number(normalized);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+function tryAsRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}

package/dist/util/collections.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveCleanupIntervalMs = resolveCleanupIntervalMs;
+exports.createPeriodicCleanup = createPeriodicCleanup;
 exports.normalizeQueryLimit = normalizeQueryLimit;
 exports.setBoundedMapEntry = setBoundedMapEntry;
 function resolveCleanupIntervalMs(ttlMs, maxIntervalMs = 60000) {
@@ -9,6 +10,17 @@ function resolveCleanupIntervalMs(ttlMs, maxIntervalMs = 60000) {
     }
     return Math.min(maxIntervalMs, Math.floor(ttlMs / 2));
 }
+function createPeriodicCleanup(ttlMs, run) {
+    const timer = setInterval(run, resolveCleanupIntervalMs(ttlMs));
+    timer.unref?.();
+    return {
+        destroy: () => clearInterval(timer)
+    };
+}
+/**
+ * Returns a validated positive-safe-integer query limit, falling back to
+ * `defaultLimit` when `limit` is undefined. Throws on invalid input.
+ */
 function normalizeQueryLimit(limit, defaultLimit) {
     if (limit === undefined) {
         return defaultLimit;

package/dist/util/index.js

@@ -1,9 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isBunRuntime = exports.toSafeNumber = exports.normalizeQueryLimit = exports.toBoolOrUndef = exports.resolvePositive = exports.asString = exports.asOptionalString = exports.asOptionalNumber = exports.asOptionalBytes = exports.asNumber = exports.asBytes = exports.uint8Equal = exports.toBytesView = exports.hexToBytes = exports.bytesToHex = void 0;
+exports.isBunRuntime = exports.toSafeNumber = exports.toError = exports.normalizeQueryLimit = exports.toBoolOrUndef = exports.resolvePositive = exports.asString = exports.asOptionalString = exports.asOptionalNumber = exports.asOptionalBytes = exports.asNumber = exports.asBytes = exports.uint8Equal = exports.toBytesView = exports.TEXT_DECODER = exports.hexToBytes = exports.decodeBase64Url = exports.bytesToHex = exports.bytesToBase64UrlSafe = exports.bytesToBase64 = exports.base64ToBytes = void 0;
 var bytes_1 = require("./bytes");
+Object.defineProperty(exports, "base64ToBytes", { enumerable: true, get: function () { return bytes_1.base64ToBytes; } });
+Object.defineProperty(exports, "bytesToBase64", { enumerable: true, get: function () { return bytes_1.bytesToBase64; } });
+Object.defineProperty(exports, "bytesToBase64UrlSafe", { enumerable: true, get: function () { return bytes_1.bytesToBase64UrlSafe; } });
 Object.defineProperty(exports, "bytesToHex", { enumerable: true, get: function () { return bytes_1.bytesToHex; } });
+Object.defineProperty(exports, "decodeBase64Url", { enumerable: true, get: function () { return bytes_1.decodeBase64Url; } });
 Object.defineProperty(exports, "hexToBytes", { enumerable: true, get: function () { return bytes_1.hexToBytes; } });
+Object.defineProperty(exports, "TEXT_DECODER", { enumerable: true, get: function () { return bytes_1.TEXT_DECODER; } });
 Object.defineProperty(exports, "toBytesView", { enumerable: true, get: function () { return bytes_1.toBytesView; } });
 Object.defineProperty(exports, "uint8Equal", { enumerable: true, get: function () { return bytes_1.uint8Equal; } });
 var coercion_1 = require("./coercion");
@@ -18,6 +23,7 @@ Object.defineProperty(exports, "toBoolOrUndef", { enumerable: true, get: functio
 var collections_1 = require("./collections");
 Object.defineProperty(exports, "normalizeQueryLimit", { enumerable: true, get: function () { return collections_1.normalizeQueryLimit; } });
 var primitives_1 = require("./primitives");
+Object.defineProperty(exports, "toError", { enumerable: true, get: function () { return primitives_1.toError; } });
 Object.defineProperty(exports, "toSafeNumber", { enumerable: true, get: function () { return primitives_1.toSafeNumber; } });
 var runtime_1 = require("./runtime");
 Object.defineProperty(exports, "isBunRuntime", { enumerable: true, get: function () { return runtime_1.isBunRuntime; } });

package/dist/util/primitives.js

@@ -5,7 +5,15 @@ exports.toSafeNumber = toSafeNumber;
 exports.longToNumber = longToNumber;
 exports.normalizeNonNegativeInteger = normalizeNonNegativeInteger;
 exports.parseOptionalInt = parseOptionalInt;
+exports.parseOptionalSignedInt = parseOptionalSignedInt;
 const DIGITS_ONLY_RE = /^\d+$/;
+const SIGNED_DIGITS_RE = /^-?\d+$/;
+/**
+ * Normalizes an unknown thrown value into an `Error` – `Error` instances are
+ * returned unchanged, strings/numbers are wrapped, and objects with `message`
+ * or `code` fields are mapped to readable messages. Use in `catch` blocks
+ * before logging.
+ */
 function toError(value) {
     if (value instanceof Error)
         return value;
@@ -32,6 +40,10 @@ function assertSafeInteger(value, field, nullishBehavior) {
     const prefix = nullishBehavior === 'throw' ? `invalid ${field}` : 'invalid long numeric value';
     throw new Error(`${prefix}: ${value}`);
 }
+/**
+ * Coerces a `number` or `{ toNumber() }` (protobufjs `Long`) to a finite
+ * safe-integer. Throws on missing/non-numeric/out-of-range inputs.
+ */
 function toSafeNumber(value, field) {
     if (value === null || value === undefined)
         throw new Error(`missing ${field}`);
@@ -63,3 +75,11 @@ function parseOptionalInt(value) {
         return undefined;
     return parseStrictUnsignedInt(value);
 }
+function parseOptionalSignedInt(value) {
+    if (!value)
+        return undefined;
+    if (!SIGNED_DIGITS_RE.test(value))
+        return undefined;
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) ? parsed : undefined;
+}

package/dist/util/runtime.js

@@ -2,6 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRuntimeOsDisplayName = getRuntimeOsDisplayName;
 exports.isBunRuntime = isBunRuntime;
+/**
+ * Returns a human-friendly OS name (`Windows` / `Mac OS` / `Linux`) for the
+ * current process, falling back to `process.platform` for other OSes.
+ */
 function getRuntimeOsDisplayName() {
     switch (process.platform) {
         case 'win32':
@@ -14,6 +18,7 @@ function getRuntimeOsDisplayName() {
             return process.platform;
     }
 }
+/** Returns `true` when running under the Bun runtime. */
 function isBunRuntime() {
     return typeof globalThis.Bun !== 'undefined';
 }

package/dist/version-spec.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WA_VERSION = void 0;
+var version_1 = require("../spec/version");
+Object.defineProperty(exports, "WA_VERSION", { enumerable: true, get: function () { return version_1.WA_VERSION; } });

package/package.json

@@ -1,7 +1,9 @@
 {
     "name": "zapo-js",
-    "version": "0.3.0",
+    "version": "1.0.0",
     "description": "High-performance WhatsApp Web TypeScript library",
+    "license": "MIT",
+    "author": "vinikjkkj <contact@vinicius.email> (https://github.com/vinikjkkj)",
     "funding": {
         "type": "github",
         "url": "https://github.com/sponsors/vinikjkkj"
@@ -99,8 +101,15 @@
     },
     "files": [
         "dist",
-        "proto/index.js",
-        "proto/index.d.ts",
+        "spec/proto/index.js",
+        "spec/proto/index.d.ts",
+        "spec/mex/index.js",
+        "spec/mex/index.d.ts",
+        "spec/appstate/index.js",
+        "spec/appstate/index.d.ts",
+        "spec/version/version.json",
+        "spec/version/index.js",
+        "spec/version/index.d.ts",
         "scripts/check-node-version.cjs"
     ],
     "workspaces": [
@@ -111,6 +120,7 @@
     },
     "scripts": {
         "preinstall": "node ./scripts/check-node-version.cjs",
+        "prepack": "npm run build",
         "changeset": "changeset",
         "changeset:status": "changeset status --verbose",
         "version:packages": "changeset version",
@@ -119,7 +129,7 @@
         "build:cjs": "tsc -p tsconfig.build.cjs.json && tsc-alias -p tsconfig.build.cjs.json",
         "build:esm": "tsc -p tsconfig.build.esm.json && tsc-alias -p tsconfig.build.esm.json",
         "build:types": "tsc -p tsconfig.build.types.json && tsc-alias -p tsconfig.build.types.json",
-        "build:esm:finalize": "node ./scripts/finalize-esm-build.cjs",
+        "build:esm:finalize": "node ./scripts/finalize-esm-build.cjs --proto-bridge",
         "build": "npm run clean && npm run build:cjs && npm run build:esm && npm run build:types && npm run build:esm:finalize",
         "build:packages": "turbo run build",
         "proto:generate": "node ./scripts/generate-proto.cjs",
@@ -140,7 +150,10 @@
         "test:coverage": "npm run test:structure && c8 --all --include \"src/**/*.ts\" --exclude \"src/**/*.d.ts\" --exclude \"src/**/__tests__/**\" --exclude \"src/**/types.ts\" --exclude \"src/store/contracts/**/*.ts\" --reporter text --reporter html --reporter lcov node --import tsx --test --test-skip-pattern \"\\\\[flow\\\\]\" \"src/**/__tests__/**/*.test.ts\"",
         "test:coverage:open": "node -e \"require('node:child_process').execSync(process.platform === 'win32' ? 'start coverage\\\\index.html' : process.platform === 'darwin' ? 'open coverage/index.html' : 'xdg-open coverage/index.html', { stdio: 'inherit' })\"",
         "typecheck": "tsc -p tsconfig.json --noEmit",
+        "typecheck:examples": "tsc -p examples/tsconfig.json",
+        "typecheck:bench": "tsc -p bench/tsconfig.json",
         "typecheck:packages": "turbo run typecheck",
+        "typecheck:all": "npm run typecheck && npm run typecheck:examples && npm run typecheck:bench && npm run typecheck:packages",
         "lint": "eslint . --ext .ts,.js,.cjs",
         "lint:fix": "eslint . --ext .ts,.js,.cjs --fix",
         "format": "prettier . --write",
@@ -150,7 +163,7 @@
         "argo-codec": "^0.2.1",
         "pino": "^9.0.0",
         "pino-pretty": "^13.0.0",
-        "ws": "^8.18.3"
+        "ws": "^8.20.1"
     },
     "peerDependenciesMeta": {
         "argo-codec": {
@@ -171,7 +184,7 @@
         "@types/node": "^22.13.14",
         "@types/ws": "^8.18.1",
         "@typescript-eslint/parser": "^8.56.1",
-        "@vinikjkkj/eslint-config": "^1.0.0",
+        "@vinikjkkj/eslint-config": "1.0.2",
         "argo-codec": "^0.2.1",
         "better-sqlite3": "^12.6.2",
         "c8": "^11.0.0",
@@ -184,9 +197,20 @@
         "prettier": "^3.8.1",
         "tsc-alias": "^1.8.16",
         "tsx": "^4.20.6",
-        "turbo": "^2.8.20",
+        "turbo": "^2.9.14",
         "typescript": "^5.7.3",
         "typescript-eslint": "^8.56.1",
-        "ws": "^8.18.3"
+        "ws": "^8.20.1"
+    },
+    "overrides": {
+        "ws": "^8.20.1",
+        "qs": "6.15.2",
+        "flatted": "^3.4.2",
+        "picomatch@<2.3.2": "2.3.2",
+        "picomatch@4": "^4.0.4",
+        "brace-expansion@1": "1.1.13",
+        "brace-expansion@2": "^2.0.3",
+        "brace-expansion@4": "^4.0.2",
+        "brace-expansion@5": "^5.0.6"
     }
 }