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

package/.github/workflows/claude.yml

@@ -1,55 +0,0 @@
-name: Claude Code
-
-on:
-  issue_comment:
-    types: [created]
-  pull_request_review_comment:
-    types: [created]
-  pull_request_review:
-    types: [submitted]
-  issues:
-    types: [opened, assigned]
-
-jobs:
-  claude:
-    if: |
-      (
-        github.event_name == 'issue_comment' &&
-        contains(github.event.comment.body || '', '@claude') &&
-        contains(fromJSON('["OWNER","MEMBER","COLLABORATOR"]'), github.event.comment.author_association)
-      ) ||
-      (
-        github.event_name == 'pull_request_review_comment' &&
-        contains(github.event.comment.body || '', '@claude') &&
-        contains(fromJSON('["OWNER","MEMBER","COLLABORATOR"]'), github.event.comment.author_association)
-      ) ||
-      (
-        github.event_name == 'pull_request_review' &&
-        contains(github.event.review.body || '', '@claude') &&
-        contains(fromJSON('["OWNER","MEMBER","COLLABORATOR"]'), github.event.review.author_association)
-      ) ||
-      (
-        github.event_name == 'issues' &&
-        contains(github.event.issue.body || '', '@claude') &&
-        contains(fromJSON('["OWNER","MEMBER","COLLABORATOR"]'), github.event.issue.author_association)
-      )
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      pull-requests: write
-      issues: write
-      id-token: write
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
-        with:
-          fetch-depth: 1
-
-      - name: Run Claude Code
-        uses: anthropics/claude-code-action@673eb13aa77026be5c507eda12322c1a58b80f0b # v1
-        with:
-          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
-          plugin_marketplaces: |
-            https://github.com/anthropics/claude-code.git
-          plugins: |
-            code-review@claude-code-plugins

package/dist/__tests__/TestAvoEncryption.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/TestAvoEncryption.js

@@ -1,288 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const crypto = require("crypto");
-const AvoEncryption_1 = require("../AvoEncryption");
-const AvoNetworkCallsHandler_1 = require("../AvoNetworkCallsHandler");
-const AvoInspectorEnv_1 = require("../AvoInspectorEnv");
-const AvoGuid_1 = require("../AvoGuid");
-const constants_1 = require("./constants");
-// Generate a test key pair for encryption tests
-function generateTestKeyPair() {
-    const ecdh = crypto.createECDH("prime256v1");
-    ecdh.generateKeys();
-    return {
-        publicKey: ecdh.getPublicKey("hex"),
-        privateKey: ecdh.getPrivateKey(),
-        ecdh,
-    };
-}
-function parseWireFormat(encryptedBase64) {
-    const wire = Buffer.from(encryptedBase64, "base64");
-    return {
-        version: wire[0],
-        ephemeralPubKey: wire.subarray(1, 66),
-        iv: wire.subarray(66, 82),
-        authTag: wire.subarray(82, 98),
-        ciphertext: wire.subarray(98),
-        wire,
-    };
-}
-describe("AvoEncryption", () => {
-    describe("shouldEncrypt", () => {
-        const dummyHexKey = "deadbeef";
-        test("dev + key => true", () => {
-            expect(AvoEncryption_1.AvoEncryption.shouldEncrypt(AvoInspectorEnv_1.AvoInspectorEnv.Dev, dummyHexKey)).toBe(true);
-        });
-        test("staging + key => true", () => {
-            expect(AvoEncryption_1.AvoEncryption.shouldEncrypt(AvoInspectorEnv_1.AvoInspectorEnv.Staging, dummyHexKey)).toBe(true);
-        });
-        test("prod + key => false", () => {
-            expect(AvoEncryption_1.AvoEncryption.shouldEncrypt(AvoInspectorEnv_1.AvoInspectorEnv.Prod, dummyHexKey)).toBe(false);
-        });
-        test("dev + null => false", () => {
-            expect(AvoEncryption_1.AvoEncryption.shouldEncrypt(AvoInspectorEnv_1.AvoInspectorEnv.Dev, undefined)).toBe(false);
-        });
-        test("dev + empty string => false", () => {
-            expect(AvoEncryption_1.AvoEncryption.shouldEncrypt(AvoInspectorEnv_1.AvoInspectorEnv.Dev, "")).toBe(false);
-        });
-    });
-    describe("wire format", () => {
-        const testKeyPair = generateTestKeyPair();
-        test("base64Decode(output).length >= 99", () => {
-            const encrypted = AvoEncryption_1.AvoEncryption.encryptValue("hello", testKeyPair.publicKey);
-            expect(encrypted).not.toBeNull();
-            const decoded = Buffer.from(encrypted, "base64");
-            // 1 (version) + 65 (ephemeral pubkey) + 16 (IV) + 16 (auth tag) + ciphertext >= 1
-            expect(decoded.length).toBeGreaterThanOrEqual(99);
-        });
-        test("output[0] == 0x00 (version byte)", () => {
-            const encrypted = AvoEncryption_1.AvoEncryption.encryptValue("hello", testKeyPair.publicKey);
-            const decoded = Buffer.from(encrypted, "base64");
-            expect(decoded[0]).toBe(0x00);
-        });
-        test("output[1] == 0x04 (uncompressed pubkey marker)", () => {
-            const encrypted = AvoEncryption_1.AvoEncryption.encryptValue("hello", testKeyPair.publicKey);
-            const decoded = Buffer.from(encrypted, "base64");
-            expect(decoded[1]).toBe(0x04);
-        });
-        test("ephemeral public key is 65 bytes (uncompressed)", () => {
-            const encrypted = AvoEncryption_1.AvoEncryption.encryptValue("test data", testKeyPair.publicKey);
-            const decoded = Buffer.from(encrypted, "base64");
-            // bytes 1..65 are the ephemeral public key
-            const ephemeralPubKey = decoded.subarray(1, 66);
-            expect(ephemeralPubKey.length).toBe(65);
-            expect(ephemeralPubKey[0]).toBe(0x04); // uncompressed marker
-        });
-    });
-    describe("round-trip encrypt/decrypt", () => {
-        test("can decrypt back to original plaintext", () => {
-            const ecdh = crypto.createECDH("prime256v1");
-            ecdh.generateKeys();
-            const recipientPubKeyHex = ecdh.getPublicKey("hex");
-            const plaintext = "Hello, encryption!";
-            const encrypted = AvoEncryption_1.AvoEncryption.encryptValue(plaintext, recipientPubKeyHex);
-            expect(encrypted).not.toBeNull();
-            // Decrypt: parse wire format
-            const { version, ephemeralPubKey, iv, authTag, ciphertext } = parseWireFormat(encrypted);
-            expect(version).toBe(0x00);
-            // Compute shared secret the same way
-            const sharedSecret = ecdh.computeSecret(ephemeralPubKey);
-            const aesKey = crypto.createHash("sha256").update(sharedSecret).digest();
-            const decipher = crypto.createDecipheriv("aes-256-gcm", aesKey, iv, {
-                authTagLength: 16,
-            });
-            decipher.setAuthTag(authTag);
-            let decrypted = decipher.update(ciphertext);
-            decrypted = Buffer.concat([decrypted, decipher.final()]);
-            expect(decrypted.toString("utf8")).toBe(plaintext);
-        });
-        test("different encryptions of same value produce different ciphertext", () => {
-            const ecdh = crypto.createECDH("prime256v1");
-            ecdh.generateKeys();
-            const pubKey = ecdh.getPublicKey("hex");
-            const enc1 = AvoEncryption_1.AvoEncryption.encryptValue("same", pubKey);
-            const enc2 = AvoEncryption_1.AvoEncryption.encryptValue("same", pubKey);
-            // Ephemeral keys differ each time, so output differs
-            expect(enc1).not.toBe(enc2);
-        });
-    });
-    describe("encryption failure handling", () => {
-        test("returns null and warns on invalid key", () => {
-            const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => { });
-            const result = AvoEncryption_1.AvoEncryption.encryptValue("hello", "not-a-valid-hex-key");
-            expect(result).toBeNull();
-            expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("[Avo Inspector] Warning:"));
-            warnSpy.mockRestore();
-        });
-    });
-    describe("isListType", () => {
-        test("detects list types", () => {
-            expect(AvoEncryption_1.AvoEncryption.isListType("list(string)")).toBe(true);
-            expect(AvoEncryption_1.AvoEncryption.isListType("list(int)")).toBe(true);
-            expect(AvoEncryption_1.AvoEncryption.isListType("list(object)")).toBe(true);
-        });
-        test("non-list types return false", () => {
-            expect(AvoEncryption_1.AvoEncryption.isListType("string")).toBe(false);
-            expect(AvoEncryption_1.AvoEncryption.isListType("int")).toBe(false);
-            expect(AvoEncryption_1.AvoEncryption.isListType("object")).toBe(false);
-        });
-    });
-});
-describe("AvoNetworkCallsHandler encryption integration", () => {
-    const inspectorVersion = process.env.npm_package_version || "";
-    beforeEach(() => {
-        const now = new Date();
-        // @ts-ignore
-        jest.spyOn(global, "Date").mockImplementation(() => now);
-        jest
-            .spyOn(AvoGuid_1.AvoGuid, "newGuid")
-            .mockImplementation(() => constants_1.mockedReturns.GUID);
-    });
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-    test("publicEncryptionKey included in base body when non-null and non-empty", () => {
-        const pubKey = "deadbeef";
-        const handler = new AvoNetworkCallsHandler_1.AvoNetworkCallsHandler("api-key", AvoInspectorEnv_1.AvoInspectorEnv.Dev, "app", "1.0", inspectorVersion, pubKey);
-        const body = handler.bodyForEventSchemaCall("anon-id", "test-event", [{ propertyName: "prop1", propertyType: "string" }], null, null);
-        expect(body.publicEncryptionKey).toBe(pubKey);
-    });
-    test("publicEncryptionKey NOT included in base body when null", () => {
-        const handler = new AvoNetworkCallsHandler_1.AvoNetworkCallsHandler("api-key", AvoInspectorEnv_1.AvoInspectorEnv.Dev, "app", "1.0", inspectorVersion, undefined);
-        const body = handler.bodyForEventSchemaCall("anon-id", "test-event", [{ propertyName: "prop1", propertyType: "string" }], null, null);
-        expect(body.publicEncryptionKey).toBeUndefined();
-    });
-    test("publicEncryptionKey NOT included in base body when empty string", () => {
-        const handler = new AvoNetworkCallsHandler_1.AvoNetworkCallsHandler("api-key", AvoInspectorEnv_1.AvoInspectorEnv.Dev, "app", "1.0", inspectorVersion, "");
-        const body = handler.bodyForEventSchemaCall("anon-id", "test-event", [{ propertyName: "prop1", propertyType: "string" }], null, null);
-        expect(body.publicEncryptionKey).toBeUndefined();
-    });
-    test("dev env with key: properties are encrypted with encryptedPropertyValue", () => {
-        const ecdh = crypto.createECDH("prime256v1");
-        ecdh.generateKeys();
-        const pubKey = ecdh.getPublicKey("hex");
-        const handler = new AvoNetworkCallsHandler_1.AvoNetworkCallsHandler("api-key", AvoInspectorEnv_1.AvoInspectorEnv.Dev, "app", "1.0", inspectorVersion, pubKey);
-        const body = handler.bodyForEventSchemaCall("anon-id", "test-event", [{ propertyName: "username", propertyType: "string" }], null, null, { username: "alice" });
-        // Should have encryptedPropertyValue alongside propertyType
-        expect(body.eventProperties.length).toBe(1);
-        expect(body.eventProperties[0].propertyName).toBe("username");
-        expect(body.eventProperties[0].encryptedPropertyValue).toBeDefined();
-        expect(body.eventProperties[0].propertyType).toBe("string");
-    });
-    test("prod env: no encryptedPropertyValue, propertyType kept as-is", () => {
-        const ecdh = crypto.createECDH("prime256v1");
-        ecdh.generateKeys();
-        const pubKey = ecdh.getPublicKey("hex");
-        const handler = new AvoNetworkCallsHandler_1.AvoNetworkCallsHandler("api-key", AvoInspectorEnv_1.AvoInspectorEnv.Prod, "app", "1.0", inspectorVersion, pubKey);
-        const body = handler.bodyForEventSchemaCall("anon-id", "test-event", [{ propertyName: "username", propertyType: "string" }], null, null);
-        expect(body.eventProperties.length).toBe(1);
-        expect(body.eventProperties[0].propertyType).toBe("string");
-        expect(body.eventProperties[0].encryptedPropertyValue).toBeUndefined();
-    });
-    test("list-type properties are omitted entirely when encryption is active", () => {
-        const ecdh = crypto.createECDH("prime256v1");
-        ecdh.generateKeys();
-        const pubKey = ecdh.getPublicKey("hex");
-        const handler = new AvoNetworkCallsHandler_1.AvoNetworkCallsHandler("api-key", AvoInspectorEnv_1.AvoInspectorEnv.Dev, "app", "1.0", inspectorVersion, pubKey);
-        const body = handler.bodyForEventSchemaCall("anon-id", "test-event", [
-            { propertyName: "name", propertyType: "string" },
-            { propertyName: "tags", propertyType: "list(string)" },
-            { propertyName: "scores", propertyType: "list(int)" },
-        ], null, null, { name: "Alice", tags: ["a", "b"], scores: [1, 2] });
-        // List types should be omitted
-        expect(body.eventProperties.length).toBe(1);
-        expect(body.eventProperties[0].propertyName).toBe("name");
-    });
-    test("encryption failure: property is omitted, warning logged", () => {
-        const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => { });
-        const handler = new AvoNetworkCallsHandler_1.AvoNetworkCallsHandler("api-key", AvoInspectorEnv_1.AvoInspectorEnv.Dev, "app", "1.0", inspectorVersion, "invalid-key-that-will-fail");
-        const body = handler.bodyForEventSchemaCall("anon-id", "test-event", [{ propertyName: "prop1", propertyType: "string" }], null, null, { prop1: "hello" });
-        // Property should be omitted on failure
-        expect(body.eventProperties.length).toBe(0);
-        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("[Avo Inspector] Warning:"));
-        warnSpy.mockRestore();
-    });
-    test("non-string value (number) is JSON.stringify'd before encryption", () => {
-        const ecdh = crypto.createECDH("prime256v1");
-        ecdh.generateKeys();
-        const pubKey = ecdh.getPublicKey("hex");
-        const handler = new AvoNetworkCallsHandler_1.AvoNetworkCallsHandler("api-key", AvoInspectorEnv_1.AvoInspectorEnv.Dev, "app", "1.0", inspectorVersion, pubKey);
-        const body = handler.bodyForEventSchemaCall("anon-id", "test-event", [{ propertyName: "count", propertyType: "int" }], null, null, { count: 42 });
-        expect(body.eventProperties.length).toBe(1);
-        const encryptedValue = body.eventProperties[0].encryptedPropertyValue;
-        expect(encryptedValue).toBeDefined();
-        // Decrypt and verify the value is the JSON-stringified number "42"
-        const { ephemeralPubKey, iv, authTag, ciphertext } = parseWireFormat(encryptedValue);
-        const sharedSecret = ecdh.computeSecret(ephemeralPubKey);
-        const aesKey = crypto.createHash("sha256").update(sharedSecret).digest();
-        const decipher = crypto.createDecipheriv("aes-256-gcm", aesKey, iv, {
-            authTagLength: 16,
-        });
-        decipher.setAuthTag(authTag);
-        let decrypted = decipher.update(ciphertext);
-        decrypted = Buffer.concat([decrypted, decipher.final()]);
-        expect(decrypted.toString("utf8")).toBe("42");
-    });
-    test("missing property in rawEventProperties encrypts 'null' instead of crashing", () => {
-        const ecdh = crypto.createECDH("prime256v1");
-        ecdh.generateKeys();
-        const pubKey = ecdh.getPublicKey("hex");
-        const handler = new AvoNetworkCallsHandler_1.AvoNetworkCallsHandler("api-key", AvoInspectorEnv_1.AvoInspectorEnv.Dev, "app", "1.0", inspectorVersion, pubKey);
-        // Schema says "missing_prop" exists, but rawEventProperties does NOT have it
-        const body = handler.bodyForEventSchemaCall("anon-id", "test-event", [{ propertyName: "missing_prop", propertyType: "string" }], null, null, { other_prop: "value" });
-        expect(body.eventProperties.length).toBe(1);
-        const encryptedValue = body.eventProperties[0].encryptedPropertyValue;
-        expect(encryptedValue).toBeDefined();
-        // Decrypt and verify the value is "null"
-        const { ephemeralPubKey, iv, authTag, ciphertext } = parseWireFormat(encryptedValue);
-        const sharedSecret = ecdh.computeSecret(ephemeralPubKey);
-        const aesKey = crypto.createHash("sha256").update(sharedSecret).digest();
-        const decipher = crypto.createDecipheriv("aes-256-gcm", aesKey, iv, {
-            authTagLength: 16,
-        });
-        decipher.setAuthTag(authTag);
-        let decrypted = decipher.update(ciphertext);
-        decrypted = Buffer.concat([decrypted, decipher.final()]);
-        expect(decrypted.toString("utf8")).toBe("null");
-    });
-    test("children are preserved in encrypted property output", () => {
-        const ecdh = crypto.createECDH("prime256v1");
-        ecdh.generateKeys();
-        const pubKey = ecdh.getPublicKey("hex");
-        const handler = new AvoNetworkCallsHandler_1.AvoNetworkCallsHandler("api-key", AvoInspectorEnv_1.AvoInspectorEnv.Dev, "app", "1.0", inspectorVersion, pubKey);
-        const children = [
-            { propertyName: "street", propertyType: "string" },
-            { propertyName: "zip", propertyType: "int" },
-        ];
-        const body = handler.bodyForEventSchemaCall("anon-id", "test-event", [{ propertyName: "address", propertyType: "object", children }], null, null, { address: { street: "123 Main St", zip: 12345 } });
-        expect(body.eventProperties.length).toBe(1);
-        const prop = body.eventProperties[0];
-        expect(prop.propertyName).toBe("address");
-        expect(prop.encryptedPropertyValue).toBeDefined();
-        expect(prop.children).toEqual(children);
-    });
-    test("cross-SDK interop: encrypted wire format structure is correct", () => {
-        const ecdh = crypto.createECDH("prime256v1");
-        ecdh.generateKeys();
-        const pubKey = ecdh.getPublicKey("hex");
-        const handler = new AvoNetworkCallsHandler_1.AvoNetworkCallsHandler("api-key", AvoInspectorEnv_1.AvoInspectorEnv.Dev, "app", "1.0", inspectorVersion, pubKey);
-        const body = handler.bodyForEventSchemaCall("anon-id", "test-event", [{ propertyName: "email", propertyType: "string" }], null, null, { email: "user@example.com" });
-        const encryptedValue = body.eventProperties[0].encryptedPropertyValue;
-        expect(encryptedValue).toBeDefined();
-        const { version, ephemeralPubKey, iv, authTag, ciphertext, wire } = parseWireFormat(encryptedValue);
-        // Verify wire format: [0x00][65-byte ephemeral pubkey][16-byte IV][16-byte auth tag][ciphertext]
-        expect(wire.length).toBeGreaterThanOrEqual(99);
-        expect(version).toBe(0x00); // version
-        expect(ephemeralPubKey[0]).toBe(0x04); // uncompressed pubkey marker
-        // Verify we can decrypt it
-        const sharedSecret = ecdh.computeSecret(ephemeralPubKey);
-        const aesKey = crypto.createHash("sha256").update(sharedSecret).digest();
-        const decipher = crypto.createDecipheriv("aes-256-gcm", aesKey, iv, {
-            authTagLength: 16,
-        });
-        decipher.setAuthTag(authTag);
-        let decrypted = decipher.update(ciphertext);
-        decrypted = Buffer.concat([decrypted, decipher.final()]);
-        expect(decrypted.toString("utf8")).toBe('"user@example.com"');
-    });
-});

package/dist/__tests__/TestAvoEventSpecCache.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/TestAvoEventSpecCache.js

@@ -1,194 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const AvoEventSpecCache_1 = require("../eventSpec/AvoEventSpecCache");
-function makeSpec(eventName) {
-    return {
-        eventSpec: {
-            eventName,
-            properties: [{ propertyName: "prop1", propertyType: "string" }],
-        },
-        metadata: {
-            schemaId: "schema1",
-            branchId: "branch1",
-            latestActionId: "action1",
-            sourceId: "source1",
-        },
-    };
-}
-describe("AvoEventSpecCache", () => {
-    let cache;
-    beforeEach(() => {
-        cache = new AvoEventSpecCache_1.AvoEventSpecCache();
-        jest.useFakeTimers();
-    });
-    afterEach(() => {
-        jest.useRealTimers();
-    });
-    test("returns undefined for cache miss", () => {
-        expect(cache.get("nonexistent")).toBeUndefined();
-    });
-    test("stores and retrieves a value", () => {
-        const spec = makeSpec("click");
-        cache.set("key1", spec);
-        expect(cache.get("key1")).toEqual(spec);
-    });
-    test("stores and retrieves null responses", () => {
-        const nullSpec = {
-            eventSpec: null,
-            metadata: {
-                schemaId: "s1",
-                branchId: "b1",
-                latestActionId: "a1",
-                sourceId: "src1",
-            },
-        };
-        cache.set("null-key", nullSpec);
-        expect(cache.get("null-key")).toEqual(nullSpec);
-    });
-    test("TTL eviction: entries older than 60s removed on next sweep", () => {
-        cache.set("old-key", makeSpec("old"));
-        // Advance time by 61 seconds
-        jest.advanceTimersByTime(61000);
-        // Trigger sweep by performing enough operations
-        for (let i = 0; i < 50; i++) {
-            cache.set(`sweep-${i}`, makeSpec(`sweep-${i}`));
-        }
-        expect(cache.get("old-key")).toBeUndefined();
-    });
-    test("per-entry eviction: entries retrieved 50+ times evicted on next get", () => {
-        cache.set("hot-key", makeSpec("hot"));
-        // Access 49 times - should still be present
-        for (let i = 0; i < 49; i++) {
-            expect(cache.get("hot-key")).toBeDefined();
-        }
-        // The 50th access should trigger eviction
-        expect(cache.get("hot-key")).toBeUndefined();
-    });
-    test("LRU eviction when size > 50", () => {
-        // Fill cache with 50 entries. Each set() creates an entry with
-        // lastAccessed = Date.now(). We advance the fake clock by 1ms between
-        // sets so every entry has a distinct timestamp.
-        // The 50th set triggers evictLRU(), which removes the entry with the
-        // oldest lastAccessed — that is entry-0 (set at t=0).
-        for (let i = 0; i < 50; i++) {
-            cache.set(`entry-${i}`, makeSpec(`event-${i}`));
-            jest.advanceTimersByTime(1);
-        }
-        // entry-0 was the oldest when evictLRU() fired on the 50th set,
-        // so it should have been removed.
-        expect(cache.get("entry-0")).toBeUndefined();
-        // Touch entry-1 via get() — this updates its lastAccessed to "now",
-        // making it the most-recently-accessed entry and protecting it from
-        // the next eviction.
-        expect(cache.get("entry-1")).toBeDefined();
-        jest.advanceTimersByTime(1);
-        // Add two more entries to push the cache over 50 again.
-        // Each set that crosses the 50-entry threshold triggers evictLRU().
-        cache.set("entry-50", makeSpec("event-50"));
-        jest.advanceTimersByTime(1);
-        cache.set("entry-51", makeSpec("event-51"));
-        // entry-2 was never touched after its initial set(), so it had the
-        // oldest lastAccessed among remaining entries — evictLRU() removes it.
-        expect(cache.get("entry-2")).toBeUndefined();
-        // entry-1 survives because get() above refreshed its lastAccessed,
-        // so it was NOT the oldest entry when eviction fired.
-        expect(cache.get("entry-1")).toBeDefined();
-        // entry-51 was just inserted, so it is definitely still present.
-        expect(cache.get("entry-51")).toBeDefined();
-    });
-    test("global rotation evicts LRU entry every 50 operations", () => {
-        // Add entries with distinct timestamps
-        for (let i = 0; i < 49; i++) {
-            cache.set(`entry-${i}`, makeSpec(`event-${i}`));
-            jest.advanceTimersByTime(1);
-        }
-        // The 50th set triggers global rotation, evicting the LRU entry (entry-0)
-        cache.set("entry-49", makeSpec("event-49"));
-        expect(cache.get("entry-0")).toBeUndefined();
-        expect(cache.get("entry-49")).toBeDefined();
-    });
-    test("flush on empty cache is a no-op", () => {
-        // Just verify no crash
-        cache.flush();
-        expect(cache.get("anything")).toBeUndefined();
-    });
-    test("flush clears all entries", () => {
-        cache.set("a", makeSpec("a"));
-        cache.set("b", makeSpec("b"));
-        cache.flush();
-        expect(cache.get("a")).toBeUndefined();
-        expect(cache.get("b")).toBeUndefined();
-    });
-    test("key format uses null-byte delimiter", () => {
-        const key = AvoEventSpecCache_1.AvoEventSpecCache.makeKey("myApi", "stream1", "click");
-        expect(key).toBe("myApi\0stream1\0click");
-    });
-    describe("contains()", () => {
-        test("returns true for a valid cached entry", () => {
-            cache.set("k1", makeSpec("click"));
-            expect(cache.contains("k1")).toBe(true);
-        });
-        test("returns false for a missing key", () => {
-            expect(cache.contains("nonexistent")).toBe(false);
-        });
-        test("returns false after TTL expiry", () => {
-            cache.set("ttl-key", makeSpec("click"));
-            jest.advanceTimersByTime(61000);
-            expect(cache.contains("ttl-key")).toBe(false);
-        });
-        test("returns false after access count exhaustion", () => {
-            cache.set("hot-key", makeSpec("hot"));
-            // Access 49 times via get to increment eventCount to 49
-            for (let i = 0; i < 49; i++) {
-                cache.get("hot-key");
-            }
-            // eventCount is now 49; contains() checks >= 50, so still false at 49
-            // but the 50th get() returned undefined and deleted the entry
-            // Actually the 50th get increments to 50 and evicts, so after 49 gets
-            // eventCount is 49. The next get (50th) increments to 50 and evicts.
-            // contains() checks >= MAX_EVENT_COUNT without incrementing, so at 49 it's true.
-            // We need one more get to push it to 50.
-            expect(cache.get("hot-key")).toBeUndefined(); // 50th access evicts
-            expect(cache.contains("hot-key")).toBe(false);
-        });
-    });
-    describe("upsert/overwrite", () => {
-        test("setting the same key twice overwrites the previous value", () => {
-            const spec1 = makeSpec("first");
-            const spec2 = makeSpec("second");
-            cache.set("dup-key", spec1);
-            expect(cache.get("dup-key")).toEqual(spec1);
-            cache.set("dup-key", spec2);
-            expect(cache.get("dup-key")).toEqual(spec2);
-        });
-        test("overwrite resets timestamp", () => {
-            cache.set("ts-key", makeSpec("event"));
-            // Advance time close to TTL
-            jest.advanceTimersByTime(55000);
-            // Overwrite — should reset the timestamp
-            cache.set("ts-key", makeSpec("event-v2"));
-            // Advance another 10s (total 65s since first set, but only 10s since overwrite)
-            jest.advanceTimersByTime(10000);
-            expect(cache.get("ts-key")).toBeDefined();
-        });
-        test("overwrite resets eventCount", () => {
-            cache.set("count-key", makeSpec("event"));
-            // Access 48 times to bring eventCount close to limit
-            for (let i = 0; i < 48; i++) {
-                cache.get("count-key");
-            }
-            // Overwrite — should reset eventCount to 0
-            cache.set("count-key", makeSpec("event-v2"));
-            // Should be able to access again without hitting the limit
-            expect(cache.get("count-key")).toBeDefined();
-            expect(cache.get("count-key")).toBeDefined();
-        });
-    });
-    describe("makeKey delimiter collision", () => {
-        test("makeKey with null-byte delimiter prevents colon collisions", () => {
-            const key1 = AvoEventSpecCache_1.AvoEventSpecCache.makeKey("a:b", "c", "d");
-            const key2 = AvoEventSpecCache_1.AvoEventSpecCache.makeKey("a", "b:c", "d");
-            expect(key1).not.toBe(key2);
-        });
-    });
-});

package/dist/__tests__/TestAvoEventSpecFetcher.d.ts

@@ -1 +0,0 @@
-export {};