node-avo-inspector 2.0.0-beta.1 → 2.0.0

package/dist/eventSpec/EventValidator.js

@@ -2,52 +2,365 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventValidator = void 0;
 const safe_regex2_1 = require("safe-regex2");
+const AvoInspector_1 = require("../AvoInspector");
+// Validation covers a property (depth 0) and the properties of an object or of each object in
+// a list (depth 1); deeper objects are not checked, as in the web and Android SDKs.
+const MAX_CHILD_DEPTH = 2;
+// Compiled patterns and parsed allowed-value lists, keyed by their wire string. Both come from
+// the tracking plan, so they stay few; the bound only guards a long-lived process against a
+// plan that keeps changing. null marks a pattern that was skipped (unsafe or invalid).
+const MAX_CACHED_CONSTRAINTS = 1000;
+// Validation runs synchronously on the track path, so a value past these bounds is not
+// checked: a list with more items, or a string longer than this against a regex (safe-regex2
+// rejects exponential patterns, not quadratic ones).
+const MAX_VALIDATED_LIST_ITEMS = 1000;
+const MAX_REGEX_INPUT_LENGTH = 10000;
+const regexCache = new Map();
+const allowedValuesCache = new Map();
+/**
+ * Checks event property values against the value constraints of an event spec: pinned values,
+ * allowed values, regex patterns and min/max ranges, on a property and on the properties of an
+ * object (or of each object in a list).
+ *
+ * Each constraint applies to the tracking-plan event IDs (base event and variants) the spec
+ * lists for it, so a value can pass for one variant and fail for another. Types and required
+ * properties are not checked here; Avo compares the reported schema with the plan for those.
+ */
 class EventValidator {
     /**
-     * Validates event properties against the spec.
-     * Returns per-property validation results with bandwidth optimization:
-     * passedEventIds is returned only when strictly smaller than failedEventIds.
+     * Returns one result per property that failed for at least one event ID, or whose object
+     * properties did. Properties the spec has no constraints for are left out.
      */
-    validate(spec, eventProperties, eventId) {
+    validate(spec, eventSchema, rawEventProperties) {
+        const constraintsByName = collectConstraintsByName(spec.events);
         const results = [];
-        const eventPropMap = new Map();
-        for (const prop of eventProperties) {
-            eventPropMap.set(prop.propertyName, prop);
-        }
-        for (const specProp of spec.properties) {
-            const actualProp = eventPropMap.get(specProp.propertyName);
-            let passed = false;
-            if (actualProp) {
-                // Type check
-                passed = actualProp.propertyType === specProp.propertyType;
-                // Regex check (only if type passed, regex is defined, and value is available)
-                if (passed && specProp.regex && actualProp.propertyValue !== undefined) {
-                    if (!(0, safe_regex2_1.default)(specProp.regex)) {
-                        console.warn(`[Avo Inspector] Warning: Unsafe regex pattern skipped for property "${specProp.propertyName}": ${specProp.regex}`);
-                    }
-                    else {
-                        try {
-                            const re = new RegExp(specProp.regex);
-                            passed = re.test(actualProp.propertyValue);
-                        }
-                        catch (e) {
-                            console.warn(`[Avo Inspector] Warning: Invalid regex pattern for property "${specProp.propertyName}": ${specProp.regex}`);
-                        }
-                    }
-                }
+        for (const { propertyName } of eventSchema) {
+            const constraints = constraintsByName.get(propertyName);
+            if (constraints === undefined) {
+                continue;
             }
-            const result = {
-                propertyName: specProp.propertyName,
-                failedEventIds: passed ? [] : [eventId],
-                passedEventIds: passed ? [eventId] : [],
-            };
-            // Bandwidth optimization: return passedEventIds only when strictly smaller than failedEventIds
-            if (result.passedEventIds.length >= result.failedEventIds.length) {
-                result.passedEventIds = [];
+            const value = rawEventProperties ? ownValue(rawEventProperties, propertyName) : undefined;
+            const outcome = validateProperty(value, constraints, 0);
+            if (outcome !== null) {
+                results.push(Object.assign({ propertyName }, outcome));
             }
-            results.push(result);
         }
         return results;
     }
 }
 exports.EventValidator = EventValidator;
+// =============================================================================
+// Constraints across events
+// =============================================================================
+/**
+ * One lookup of constraints per property name across every event in the spec. Name mapping
+ * can match several events; each constraint keeps its own event IDs, so merging is a union.
+ */
+function collectConstraintsByName(events) {
+    const result = new Map();
+    for (const event of events) {
+        for (const name of Object.keys(event.props)) {
+            const constraints = event.props[name];
+            const existing = result.get(name);
+            result.set(name, existing === undefined ? constraints : mergeConstraints(existing, constraints));
+        }
+    }
+    return result;
+}
+function mergeConstraints(a, b) {
+    const merged = {
+        type: a.type,
+        // A missing value fails only where every matching event requires the property.
+        required: a.required && b.required,
+    };
+    if (a.isList || b.isList) {
+        merged.isList = true;
+    }
+    const pinnedValues = mergeIdMappings(a.pinnedValues, b.pinnedValues);
+    if (pinnedValues) {
+        merged.pinnedValues = pinnedValues;
+    }
+    const allowedValues = mergeIdMappings(a.allowedValues, b.allowedValues);
+    if (allowedValues) {
+        merged.allowedValues = allowedValues;
+    }
+    const regexPatterns = mergeIdMappings(a.regexPatterns, b.regexPatterns);
+    if (regexPatterns) {
+        merged.regexPatterns = regexPatterns;
+    }
+    const minMaxRanges = mergeIdMappings(a.minMaxRanges, b.minMaxRanges);
+    if (minMaxRanges) {
+        merged.minMaxRanges = minMaxRanges;
+    }
+    if (a.children || b.children) {
+        const children = Object.create(null);
+        for (const source of [a.children, b.children]) {
+            if (!source) {
+                continue;
+            }
+            for (const name of Object.keys(source)) {
+                const existing = children[name];
+                children[name] = existing === undefined ? source[name] : mergeConstraints(existing, source[name]);
+            }
+        }
+        merged.children = children;
+    }
+    return merged;
+}
+function mergeIdMappings(a, b) {
+    if (!a || !b) {
+        return a !== null && a !== void 0 ? a : b;
+    }
+    const merged = Object.create(null);
+    for (const source of [a, b]) {
+        for (const key of Object.keys(source)) {
+            const ids = merged[key];
+            merged[key] = ids === undefined ? source[key] : Array.from(new Set([...ids, ...source[key]]));
+        }
+    }
+    return merged;
+}
+// =============================================================================
+// Validation
+// =============================================================================
+function validateProperty(value, constraints, depth) {
+    if (depth >= MAX_CHILD_DEPTH) {
+        return null;
+    }
+    if (constraints.isList) {
+        return validateList(value, constraints, depth);
+    }
+    if (constraints.children) {
+        return validateObject(value, constraints.children, depth);
+    }
+    // An optional property sent as null or undefined has no value to check.
+    if ((value === null || value === undefined) && !constraints.required) {
+        return null;
+    }
+    return outcomeOf(checkValue(value, constraints, new Set()));
+}
+/**
+ * A list of objects is checked property by property across every item: an event ID fails a
+ * child property when any item's value fails it. A list of primitives is checked item by item.
+ * A value that is not an array is not checked (its type is reported in the schema).
+ */
+function validateList(value, constraints, depth) {
+    if (!Array.isArray(value)) {
+        return null;
+    }
+    if (value.length > MAX_VALIDATED_LIST_ITEMS) {
+        if (AvoInspector_1.AvoInspector.shouldLog) {
+            console.warn(`[Avo Inspector] Warning: List of ${value.length} items not validated (limit ${MAX_VALIDATED_LIST_ITEMS})`);
+        }
+        return null;
+    }
+    if (constraints.children) {
+        const children = Object.create(null);
+        let failed = false;
+        for (const name of Object.keys(constraints.children)) {
+            const failedIds = new Set();
+            for (const item of value) {
+                const outcome = validateProperty(childValue(item, name), constraints.children[name], depth + 1);
+                if (outcome !== null) {
+                    outcome.failedEventIds.forEach((id) => failedIds.add(id));
+                }
+            }
+            const outcome = outcomeOf(failedIds);
+            if (outcome !== null) {
+                children[name] = outcome;
+                failed = true;
+            }
+        }
+        return failed ? { failedEventIds: [], children } : null;
+    }
+    const failedIds = new Set();
+    for (const item of value) {
+        checkValue(item, constraints, failedIds);
+    }
+    return outcomeOf(failedIds);
+}
+function validateObject(value, childConstraints, depth) {
+    const children = Object.create(null);
+    let failed = false;
+    for (const name of Object.keys(childConstraints)) {
+        const outcome = validateProperty(childValue(value, name), childConstraints[name], depth + 1);
+        if (outcome !== null) {
+            children[name] = outcome;
+            failed = true;
+        }
+    }
+    return failed ? { failedEventIds: [], children } : null;
+}
+function outcomeOf(failedIds) {
+    return failedIds.size > 0 ? { failedEventIds: Array.from(failedIds) } : null;
+}
+// A property of a plain object (null-prototype included); anything else has none.
+function childValue(container, name) {
+    if (container === null || typeof container !== "object" || Array.isArray(container)) {
+        return undefined;
+    }
+    return ownValue(container, name);
+}
+// Own properties only, so "constructor" or "toString" never reads a prototype method.
+function ownValue(container, name) {
+    return Object.prototype.hasOwnProperty.call(container, name) ? container[name] : undefined;
+}
+/** Adds to failedIds the event IDs whose constraints the value breaks. */
+function checkValue(value, constraints, failedIds) {
+    if (constraints.pinnedValues || constraints.allowedValues) {
+        const actual = comparableString(value);
+        if (constraints.pinnedValues) {
+            checkPinnedValues(actual, constraints.pinnedValues, failedIds);
+        }
+        if (constraints.allowedValues) {
+            checkAllowedValues(actual, constraints.allowedValues, failedIds);
+        }
+    }
+    if (constraints.regexPatterns) {
+        checkRegexPatterns(value, constraints.regexPatterns, failedIds);
+    }
+    if (constraints.minMaxRanges) {
+        checkMinMaxRanges(value, constraints.minMaxRanges, failedIds);
+    }
+    return failedIds;
+}
+function addAll(ids, failedIds) {
+    for (const id of ids) {
+        failedIds.add(id);
+    }
+}
+/**
+ * The string a value is compared as against pinned and allowed values: String() for a
+ * primitive, JSON for an object or list. A value with neither (a cyclic object, a throwing
+ * toJSON or toString) falls back to its tag, e.g. "[object Object]".
+ */
+function comparableString(value) {
+    if (value !== null && typeof value === "object") {
+        try {
+            const json = JSON.stringify(value);
+            if (json !== undefined) {
+                return json;
+            }
+        }
+        catch (e) {
+            // Falls through to String().
+        }
+    }
+    try {
+        return String(value);
+    }
+    catch (e) {
+        return Object.prototype.toString.call(value);
+    }
+}
+function checkPinnedValues(actual, pinnedValues, failedIds) {
+    for (const pinned of Object.keys(pinnedValues)) {
+        if (actual !== pinned) {
+            addAll(pinnedValues[pinned], failedIds);
+        }
+    }
+}
+function checkAllowedValues(actual, allowedValues, failedIds) {
+    for (const json of Object.keys(allowedValues)) {
+        const allowed = parseAllowedValues(json);
+        // A list that is not a JSON array of strings is skipped: nothing fails it.
+        if (allowed !== null && !allowed.has(actual)) {
+            addAll(allowedValues[json], failedIds);
+        }
+    }
+}
+function checkRegexPatterns(value, regexPatterns, failedIds) {
+    if (typeof value === "string" && value.length > MAX_REGEX_INPUT_LENGTH) {
+        if (AvoInspector_1.AvoInspector.shouldLog) {
+            console.warn(`[Avo Inspector] Warning: String of ${value.length} characters not checked against regex patterns (limit ${MAX_REGEX_INPUT_LENGTH})`);
+        }
+        return;
+    }
+    for (const pattern of Object.keys(regexPatterns)) {
+        // Only a string can match; an unsafe or invalid pattern is skipped (nothing fails it).
+        if (typeof value !== "string") {
+            addAll(regexPatterns[pattern], failedIds);
+            continue;
+        }
+        const regex = compileRegex(pattern);
+        if (regex !== null && !regex.test(value)) {
+            addAll(regexPatterns[pattern], failedIds);
+        }
+    }
+}
+/**
+ * "min,max" with either bound possibly empty: "0," has no maximum, ",100" no minimum. Only a
+ * number (or bigint) can be in range; NaN never is. A range that does not parse is skipped.
+ */
+function checkMinMaxRanges(value, minMaxRanges, failedIds) {
+    const actual = typeof value === "number" ? value : typeof value === "bigint" ? Number(value) : NaN;
+    for (const range of Object.keys(minMaxRanges)) {
+        const bounds = parseRange(range);
+        if (bounds === null) {
+            if (AvoInspector_1.AvoInspector.shouldLog) {
+                console.warn(`[Avo Inspector] Warning: Invalid min/max range skipped: ${range}`);
+            }
+            continue;
+        }
+        if (Number.isNaN(actual) || actual < bounds.min || actual > bounds.max) {
+            addAll(minMaxRanges[range], failedIds);
+        }
+    }
+}
+function parseRange(range) {
+    const parts = range.split(",");
+    if (parts.length !== 2) {
+        return null;
+    }
+    const [minPart, maxPart] = parts.map((part) => part.trim());
+    const min = minPart === "" ? -Infinity : Number(minPart);
+    const max = maxPart === "" ? Infinity : Number(maxPart);
+    return Number.isNaN(min) || Number.isNaN(max) ? null : { min, max };
+}
+function parseAllowedValues(json) {
+    const cached = allowedValuesCache.get(json);
+    if (cached !== undefined) {
+        return cached;
+    }
+    let allowed = null;
+    try {
+        const parsed = JSON.parse(json);
+        if (Array.isArray(parsed) && parsed.every((item) => typeof item === "string")) {
+            allowed = new Set(parsed);
+        }
+    }
+    catch (e) {
+        // Left null: skipped below.
+    }
+    if (allowed === null && AvoInspector_1.AvoInspector.shouldLog) {
+        console.warn(`[Avo Inspector] Warning: Invalid allowed values skipped: ${json}`);
+    }
+    cacheConstraint(allowedValuesCache, json, allowed);
+    return allowed;
+}
+function compileRegex(pattern) {
+    const cached = regexCache.get(pattern);
+    if (cached !== undefined) {
+        return cached;
+    }
+    let regex = null;
+    if (!(0, safe_regex2_1.default)(pattern)) {
+        console.warn(`[Avo Inspector] Warning: Unsafe regex pattern skipped: ${pattern}`);
+    }
+    else {
+        try {
+            regex = new RegExp(pattern);
+        }
+        catch (e) {
+            console.warn(`[Avo Inspector] Warning: Invalid regex pattern skipped: ${pattern}`);
+        }
+    }
+    cacheConstraint(regexCache, pattern, regex);
+    return regex;
+}
+function cacheConstraint(cache, key, value) {
+    if (cache.size >= MAX_CACHED_CONSTRAINTS) {
+        cache.clear();
+    }
+    cache.set(key, value);
+}

package/dist/index.d.ts

@@ -1,2 +1,4 @@
 export { AvoInspector } from "./AvoInspector";
+export type { InspectorEvent } from "./AvoInspector";
 export { AvoInspectorEnv } from "./AvoInspectorEnv";
+export { VERSION, SPEC_VERSION } from "./AvoInspectorVersion";

package/dist/index.js

@@ -1,7 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AvoInspectorEnv = exports.AvoInspector = void 0;
+exports.SPEC_VERSION = exports.VERSION = exports.AvoInspectorEnv = exports.AvoInspector = void 0;
 var AvoInspector_1 = require("./AvoInspector");
 Object.defineProperty(exports, "AvoInspector", { enumerable: true, get: function () { return AvoInspector_1.AvoInspector; } });
 var AvoInspectorEnv_1 = require("./AvoInspectorEnv");
 Object.defineProperty(exports, "AvoInspectorEnv", { enumerable: true, get: function () { return AvoInspectorEnv_1.AvoInspectorEnv; } });
+var AvoInspectorVersion_1 = require("./AvoInspectorVersion");
+Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return AvoInspectorVersion_1.VERSION; } });
+Object.defineProperty(exports, "SPEC_VERSION", { enumerable: true, get: function () { return AvoInspectorVersion_1.SPEC_VERSION; } });

package/dist/utils.d.ts

@@ -1,3 +1,31 @@
+/** True for null, undefined, or a string that is empty after trimming. */
 declare const isValueEmpty: (value: string | null | undefined) => boolean;
+/**
+ * Structural equality, within the schema extraction limits: objects and lists nested more
+ * than 10 levels deep, past the 10,000th compared in one call, or past 10,000 compared
+ * properties, are treated as not equal (unless they are the same reference), so a huge
+ * payload cannot overflow the stack or block. Binary data is compared by its bytes, never
+ * enumerated.
+ */
 declare function deepEquals(x: any, y: any): boolean;
-export { isValueEmpty, deepEquals };
+/** A schema as printed in debug logs: `{`, one `\t"name": "type"` per property (`;`-separated), `}`. */
+declare const formatSchema: (schema: Array<{
+    propertyName: string;
+    propertyType: string;
+}>) => string;
+/** Trims a gateway option value; anything that is not a non-blank string is absent. */
+declare const normalizeOption: (value: unknown) => string | undefined;
+/**
+ * No control character (Unicode Cc: C0, DEL, C1) may reach a header value; CR, LF and NUL
+ * would split or end the header field. Tab is the one exception: it is valid in a value.
+ */
+declare const hasHeaderControlChar: (value: string) => boolean;
+/** Node sends header values as Latin-1 and throws synchronously on anything above U+00FF. */
+declare const hasNonLatin1Char: (value: string) => boolean;
+/**
+ * Milliseconds from a monotonic clock (process.hrtime): only differences are meaningful, and
+ * they never jump with wall-clock changes. Shared by the deduplicator, AvoLog and the exit
+ * drain deadline.
+ */
+declare const monotonicNowMs: () => number;
+export { monotonicNowMs, isValueEmpty, deepEquals, formatSchema, normalizeOption, hasHeaderControlChar, hasNonLatin1Char };

package/dist/utils.js

@@ -1,26 +1,73 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isValueEmpty = void 0;
+exports.hasNonLatin1Char = exports.hasHeaderControlChar = exports.normalizeOption = exports.formatSchema = exports.isValueEmpty = exports.monotonicNowMs = void 0;
 exports.deepEquals = deepEquals;
+/** True for null, undefined, or a string that is empty after trimming. */
 const isValueEmpty = (value) => {
     return value === null || value === undefined || value.trim().length == 0;
 };
 exports.isValueEmpty = isValueEmpty;
+// The schema extraction limits: deepEquals expands no deeper and no more than this.
+const DEEP_EQUALS_MAX_DEPTH = 10;
+const DEEP_EQUALS_MAX_EXPANSIONS = 10000;
+const DEEP_EQUALS_MAX_PROPERTIES = 10000;
+// Binary data (an ArrayBuffer view, ArrayBuffer or SharedArrayBuffer) as bytes, or null.
+const binaryBytes = (value) => {
+    if (ArrayBuffer.isView(value)) {
+        return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    }
+    const tag = Object.prototype.toString.call(value);
+    return tag === "[object ArrayBuffer]" || tag === "[object SharedArrayBuffer]" ? new Uint8Array(value) : null;
+};
+const sameBytes = (a, b) => a.byteLength === b.byteLength && Buffer.compare(a, b) === 0;
+/**
+ * Structural equality, within the schema extraction limits: objects and lists nested more
+ * than 10 levels deep, past the 10,000th compared in one call, or past 10,000 compared
+ * properties, are treated as not equal (unless they are the same reference), so a huge
+ * payload cannot overflow the stack or block. Binary data is compared by its bytes, never
+ * enumerated.
+ */
 function deepEquals(x, y) {
+    return deepEqualsWithin(x, y, 0, new Map(), { expansions: 0, properties: 0 });
+}
+// `comparing` holds the object pairs already compared, so cyclic structures terminate: a
+// pair met again is assumed equal (its other properties are still compared where it was
+// first met).
+function deepEqualsWithin(x, y, depth, comparing, budget) {
     if (x === y) {
         return true;
     }
-    if (!(x instanceof Object) || !(y instanceof Object)) {
+    // typeof, not instanceof Object: a null-prototype object is not an instance of Object.
+    if (x === null || y === null || typeof x !== "object" || typeof y !== "object") {
         return false;
     }
-    if (x.constructor !== y.constructor) {
+    if (Object.getPrototypeOf(x) !== Object.getPrototypeOf(y)) {
         return false;
     }
-    for (var p in x) {
-        if (!x.hasOwnProperty(p)) {
-            continue;
+    const xBytes = binaryBytes(x);
+    if (xBytes !== null) {
+        const yBytes = binaryBytes(y);
+        return yBytes !== null && sameBytes(xBytes, yBytes);
+    }
+    let partners = comparing.get(x);
+    if (partners && partners.has(y)) {
+        return true;
+    }
+    if (depth >= DEEP_EQUALS_MAX_DEPTH || budget.expansions >= DEEP_EQUALS_MAX_EXPANSIONS) {
+        return false;
+    }
+    budget.expansions++;
+    if (!partners) {
+        partners = new Set();
+        comparing.set(x, partners);
+    }
+    partners.add(y);
+    // hasOwn, not x.hasOwnProperty: user objects may lack the method or shadow it.
+    for (const p of Object.keys(x)) {
+        if (++budget.properties > DEEP_EQUALS_MAX_PROPERTIES) {
+            return false;
         }
-        if (!y.hasOwnProperty(p)) {
+        if (!hasOwn(y, p)) {
             return false;
         }
         if (x[p] === y[p]) {
@@ -29,14 +76,43 @@ function deepEquals(x, y) {
         if (typeof x[p] !== "object") {
             return false;
         }
-        if (!deepEquals(x[p], y[p])) {
+        if (!deepEqualsWithin(x[p], y[p], depth + 1, comparing, budget)) {
             return false;
         }
     }
-    for (p in y) {
-        if (y.hasOwnProperty(p) && !x.hasOwnProperty(p)) {
+    for (const p of Object.keys(y)) {
+        if (!hasOwn(x, p)) {
             return false;
         }
     }
     return true;
 }
+/** A schema as printed in debug logs: `{`, one `\t"name": "type"` per property (`;`-separated), `}`. */
+const formatSchema = (schema) => "{\n" + schema.map((p) => '\t"' + p.propertyName + '": "' + p.propertyType + '"').join(";\n") + "\n}";
+exports.formatSchema = formatSchema;
+const hasOwn = (object, key) => Object.prototype.hasOwnProperty.call(object, key);
+/** Trims a gateway option value; anything that is not a non-blank string is absent. */
+const normalizeOption = (value) => {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+};
+exports.normalizeOption = normalizeOption;
+/**
+ * No control character (Unicode Cc: C0, DEL, C1) may reach a header value; CR, LF and NUL
+ * would split or end the header field. Tab is the one exception: it is valid in a value.
+ */
+const hasHeaderControlChar = (value) => /[\u0000-\u0008\u000A-\u001F\u007F-\u009F]/.test(value);
+exports.hasHeaderControlChar = hasHeaderControlChar;
+/** Node sends header values as Latin-1 and throws synchronously on anything above U+00FF. */
+const hasNonLatin1Char = (value) => /[^\u0000-\u00FF]/.test(value);
+exports.hasNonLatin1Char = hasNonLatin1Char;
+/**
+ * Milliseconds from a monotonic clock (process.hrtime): only differences are meaningful, and
+ * they never jump with wall-clock changes. Shared by the deduplicator, AvoLog and the exit
+ * drain deadline.
+ */
+const monotonicNowMs = () => Number(process.hrtime.bigint()) / 1e6;
+exports.monotonicNowMs = monotonicNowMs;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-avo-inspector",
-  "version": "2.0.0-beta.1",
+  "version": "2.0.0",
   "description": "Avo Inspector for Node.js",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -24,6 +24,7 @@
   "homepage": "https://github.com/avohq/node-avo-inspector#readme",
   "scripts": {
     "build": "tsc --outDir dist",
+    "prepack": "rm -rf dist && npm run build",
     "test": "jest",
     "typecheck": "tsc --noEmit"
   },