@aryanduntley/pwa-debug 0.1.8 → 1.0.0

package/extension/page-world.js

@@ -1936,26 +1936,47 @@ var PwaDebugPageWorld = (function (exports) {
         ]);
         return actionOk('swipe', { defaultPrevented, detail: { direction: opts.direction, distance, steps } });
     };
-    /** One touchstart/touchend pair at a point; returns defaultPrevented. */
+    /**
+     * One tap at a point, in the order a phone browser produces it: pointer and
+     * touch phases, then the compatibility mouse events and `click` (which is what
+     * onClick handlers listen for). Synthetic touch events never make the browser
+     * emit that click itself, so we do. A page that calls preventDefault() on
+     * touchend is suppressing the click on purpose, so it is skipped then.
+     */
     const tapOnce = (el, c) => {
-        dispatchAll(el, [makeTouchEvent('touchstart', [makeTouch(el, c.x, c.y)])]);
-        return dispatchAll(el, [makeTouchEvent('touchend', [], [makeTouch(el, c.x, c.y)])]).defaultPrevented;
+        const at = { clientX: c.x, clientY: c.y };
+        const touch = { ...at, pointerType: 'touch' };
+        dispatchAll(el, [makePointerEvent('pointerdown', touch), makeTouchEvent('touchstart', [makeTouch(el, c.x, c.y)])]);
+        dispatchAll(el, [makePointerEvent('pointerup', touch)]);
+        const end = dispatchAll(el, [makeTouchEvent('touchend', [], [makeTouch(el, c.x, c.y)])]);
+        if (end.defaultPrevented)
+            return { defaultPrevented: true, clicked: false };
+        const clicked = dispatchAll(el, [
+            makeMouseEvent('mousedown', at),
+            makeMouseEvent('mouseup', at),
+            makeMouseEvent('click', at),
+        ]);
+        return { defaultPrevented: clicked.defaultPrevented, clicked: true };
     };
-    /** Tap an element (single touchstart/touchend at its center). */
+    /** Tap an element at its center: touch phases plus the click a real tap yields. */
     const tapElement = (el) => {
         if (!isElement$1(el))
             return actionFail('tap', 'target is not an element');
-        const defaultPrevented = tapOnce(el, centerOf(el));
-        return actionOk('tap', { defaultPrevented });
+        el.focus?.();
+        const r = tapOnce(el, centerOf(el));
+        return actionOk('tap', { defaultPrevented: r.defaultPrevented, detail: { clicked: r.clicked } });
     };
-    /** Double-tap an element (two touchstart/touchend pairs). */
+    /** Double-tap an element: two taps (each with its click) then dblclick. */
     const doubleTapElement = (el) => {
         if (!isElement$1(el))
             return actionFail('doubleTap', 'target is not an element');
+        el.focus?.();
         const c = centerOf(el);
-        tapOnce(el, c);
-        const defaultPrevented = tapOnce(el, c);
-        return actionOk('doubleTap', { defaultPrevented });
+        const first = tapOnce(el, c);
+        const second = tapOnce(el, c);
+        const clicked = first.clicked && second.clicked;
+        const dbl = clicked ? dispatchAll(el, [makeMouseEvent('dblclick', { clientX: c.x, clientY: c.y })]).defaultPrevented : false;
+        return actionOk('doubleTap', { defaultPrevented: second.defaultPrevented || dbl, detail: { clicked } });
     };
     /**
      * Long-press (async): touchstart, hold for `duration` ms so the page's
@@ -12472,6 +12493,11 @@ var PwaDebugPageWorld = (function (exports) {
         return shim;
     };
 
+    /**
+     * Window flag set by the extension page-world entry. The CDP entry reads it so
+     * it never installs a second capture set into a page the extension owns.
+     */
+    const EXTENSION_PAGE_WORLD_GUARD = '__pwaDebugPageWorldInstalled';
     const probeGlobals = () => {
         const w = window;
         return {
@@ -12523,39 +12549,23 @@ var PwaDebugPageWorld = (function (exports) {
         svelte: early.svelte || dom.svelte,
         redux: early.redux,
     });
-    const installBridgeListener = () => {
-        window.addEventListener('message', (event) => {
-            if (!isInboundCsToPage(event))
-                return;
-            dispatchPageRequest(event.data).then((response) => {
-                window.postMessage(response, window.location.origin);
-            }, (err) => {
-                console.warn('[pwa-debug/page] dispatchPageRequest rejected (should not happen):', err.message);
-            });
-        });
-    };
-    const installCaptures = (frame) => {
-        const emit = (event) => {
-            window.postMessage(encodeEvent(event), window.location.origin);
-        };
-        const kinds = {
-            console: typeof console !== 'undefined',
-            fetch: typeof globalThis.fetch === 'function',
-            xhr: typeof globalThis.XMLHttpRequest === 'function',
-            websocket: typeof globalThis.WebSocket === 'function',
-            dom_mutation: typeof MutationObserver !== 'undefined' &&
-                typeof document !== 'undefined',
-            lifecycle: typeof window !== 'undefined' &&
-                typeof document !== 'undefined' &&
-                typeof history?.pushState === 'function',
-            library_popup: typeof MutationObserver !== 'undefined' &&
-                typeof document !== 'undefined' &&
-                typeof Element !== 'undefined',
-            page_error: typeof window !== 'undefined' &&
-                typeof window.addEventListener === 'function',
-            sw_state: typeof navigator !== 'undefined' &&
-                navigator.serviceWorker !== undefined,
-        };
+    const detectKinds = () => ({
+        console: typeof console !== 'undefined',
+        fetch: typeof globalThis.fetch === 'function',
+        xhr: typeof globalThis.XMLHttpRequest === 'function',
+        websocket: typeof globalThis.WebSocket === 'function',
+        dom_mutation: typeof MutationObserver !== 'undefined' && typeof document !== 'undefined',
+        lifecycle: typeof window !== 'undefined' &&
+            typeof document !== 'undefined' &&
+            typeof history?.pushState === 'function',
+        library_popup: typeof MutationObserver !== 'undefined' &&
+            typeof document !== 'undefined' &&
+            typeof Element !== 'undefined',
+        page_error: typeof window !== 'undefined' && typeof window.addEventListener === 'function',
+        sw_state: typeof navigator !== 'undefined' && navigator.serviceWorker !== undefined,
+    });
+    const installCaptures = (emit, frame) => {
+        const kinds = detectKinds();
         const disposers = [
             installConsoleCapture(emit, frame),
             installFetchCapture(emit, frame),
@@ -12574,7 +12584,61 @@ var PwaDebugPageWorld = (function (exports) {
         };
         return { dispose, kinds };
     };
-    const INSTALL_GUARD = '__pwaDebugPageWorldInstalled';
+    const NOOP = () => undefined;
+    /**
+     * Start the page world. Transport-specific concerns (idempotency guard, how
+     * events leave, how requests arrive) belong to the entry point that calls this.
+     */
+    const bootPageWorld = (opts) => {
+        // Redux store capture is PASSIVE — read-only react-redux fiber-context
+        // discovery (see stores/redux/discover); we do not impersonate
+        // __REDUX_DEVTOOLS_EXTENSION_COMPOSE__ (that broke RTK apps).
+        //
+        // Zustand's devtools middleware calls __REDUX_DEVTOOLS_EXTENSION__.connect(...).
+        // With no real devtools present the shim installs a benign callable carrier
+        // that provides `.connect` (and no-ops if the real Redux DevTools owns it).
+        const zustandShim = installZustandDevtoolsShim(window);
+        setZustandShim(zustandShim);
+        opts.installRequestChannel();
+        const frame = computeFrameMeta();
+        const installed = opts.captures === false ? null : installCaptures(opts.emit, frame);
+        console.log('[pwa-debug/page] captures', installed ? 'installed' : 'skipped', {
+            frame,
+            kinds: installed?.kinds ?? null,
+        });
+        const early = probeGlobals();
+        console.log('[pwa-debug/page] world=MAIN, hooks(early)=', early);
+        const reportLate = () => {
+            console.log('[pwa-debug/page] hooks(post-load)=', merge(early, probeDom()));
+        };
+        if (document.readyState === 'loading') {
+            document.addEventListener('DOMContentLoaded', reportLate, { once: true });
+        }
+        else {
+            setTimeout(reportLate, 0);
+        }
+        return Object.freeze({
+            kinds: installed?.kinds ?? null,
+            dispose: installed?.dispose ?? NOOP,
+        });
+    };
+
+    // Extension transport: requests arrive from the content script as postMessage
+    // envelopes, and captured events leave the same way.
+    const installBridgeListener = () => {
+        window.addEventListener('message', (event) => {
+            if (!isInboundCsToPage(event))
+                return;
+            dispatchPageRequest(event.data).then((response) => {
+                window.postMessage(response, window.location.origin);
+            }, (err) => {
+                console.warn('[pwa-debug/page] dispatchPageRequest rejected (should not happen):', err.message);
+            });
+        });
+    };
+    const emit = (event) => {
+        window.postMessage(encodeEvent(event), window.location.origin);
+    };
     const bootstrap = () => {
         // Idempotency guard. page-world.js can run more than once in the same MAIN
         // world: the manifest injects it at document_start, and the SW self-heal
@@ -12587,40 +12651,13 @@ var PwaDebugPageWorld = (function (exports) {
         // on `window` and persists across the reload, so the re-injection no-ops here
         // and the (orphaned-but-functional) original listener stays the sole handler.
         const w = window;
-        if (w[INSTALL_GUARD])
+        if (w[EXTENSION_PAGE_WORLD_GUARD])
             return;
-        Object.defineProperty(window, INSTALL_GUARD, {
+        Object.defineProperty(window, EXTENSION_PAGE_WORLD_GUARD, {
             value: true,
             configurable: true,
         });
-        // Redux store capture is PASSIVE now — read-only react-redux fiber-context
-        // discovery (see stores/redux/discover). We no longer impersonate
-        // __REDUX_DEVTOOLS_EXTENSION_COMPOSE__, which used to break RTK apps by
-        // sitting in their store-creation path.
-        //
-        // Install the Zustand devtools-connect shim: zustand's devtools middleware
-        // calls __REDUX_DEVTOOLS_EXTENSION__.connect(...). With no real devtools and
-        // no Redux stub present, the shim installs a benign callable carrier that
-        // also provides `.connect` (and no-ops if the real Redux DevTools owns the
-        // hook).
-        const zustandShim = installZustandDevtoolsShim(window);
-        setZustandShim(zustandShim);
-        installBridgeListener();
-        const frame = computeFrameMeta();
-        const { kinds } = installCaptures(frame);
-        console.log('[pwa-debug/page] captures installed', { frame, kinds });
-        const early = probeGlobals();
-        console.log('[pwa-debug/page] world=MAIN, hooks(early)=', early);
-        const reportLate = () => {
-            const merged = merge(early, probeDom());
-            console.log('[pwa-debug/page] hooks(post-load)=', merged);
-        };
-        if (document.readyState === 'loading') {
-            document.addEventListener('DOMContentLoaded', reportLate, { once: true });
-        }
-        else {
-            setTimeout(reportLate, 0);
-        }
+        bootPageWorld({ emit, installRequestChannel: installBridgeListener });
     };
     bootstrap();
 

package/extension/service-worker.js

@@ -176,110 +176,6 @@ const dispatchToTabClassified = async (tabId, req, opts = {}) => {
     return { ok: true, response };
 };
 
-// SW-side navigation primitives — wraps chrome.tabs URL navigation so the request
-// router stays a thin orchestrator. SW-handled (NOT page-world): chrome.tabs is
-// only reachable in the extension service worker, and driving the tab to a new URL
-// is a browser action, not an in-page read. This is the pwa-debug counterpart to
-// chrome-devtools-mcp's navigate_page/new_page — it works through the loaded
-// extension on the user's real profile, with no CDP attach required.
-const DEFAULT_LOAD_TIMEOUT_MS = 10_000;
-// A bare javascript: URL would run script in the target page context on navigate;
-// reject it. Everything else (http(s), file:, about:, data:, chrome:, localhost
-// shorthand) is allowed — this is a debugging driver, not a sandbox.
-const JAVASCRIPT_SCHEME = /^javascript:/i;
-const HAS_SCHEME = /^[a-z][a-z0-9+.-]*:/i;
-/**
- * Normalize a caller-supplied URL: trim, reject empty / javascript:, and assume
- * https:// when no scheme is given (so `example.com` works). Returns null when the
- * input is unusable so the caller can surface a clear error.
- */
-const normalizeUrl = (raw) => {
-    const trimmed = raw.trim();
-    if (trimmed.length === 0)
-        return null;
-    if (JAVASCRIPT_SCHEME.test(trimmed))
-        return null;
-    return HAS_SCHEME.test(trimmed) ? trimmed : `https://${trimmed}`;
-};
-/** Active tab id in the last-focused window, or undefined when there is none. */
-const activeTabId = async () => {
-    const tabs = await chrome.tabs.query({ active: true, lastFocusedWindow: true });
-    return tabs[0]?.id;
-};
-/**
- * Resolve once the tab reports document 'complete', or 'timeout' after timeoutMs.
- * The onUpdated listener is added BEFORE the caller triggers the load so the
- * 'complete' event can't be missed; it is always removed and the timer cleared.
- */
-const waitForComplete = (tabId, timeoutMs) => new Promise((resolve) => {
-    let settled = false;
-    const settle = (outcome) => {
-        if (settled)
-            return;
-        settled = true;
-        chrome.tabs.onUpdated.removeListener(onUpdated);
-        clearTimeout(timer);
-        resolve(outcome);
-    };
-    const onUpdated = (id, info) => {
-        if (id === tabId && info.status === 'complete')
-            settle('complete');
-    };
-    const timer = setTimeout(() => settle('timeout'), timeoutMs);
-    chrome.tabs.onUpdated.addListener(onUpdated);
-});
-/**
- * Navigate the active (or given) tab to url and wait for it to finish loading.
- * Throws on an invalid url or when no tab can be resolved. The listener is armed
- * before chrome.tabs.update so the fresh load's 'complete' is observed.
- */
-const navigateTab = async (input) => {
-    const url = normalizeUrl(input.url);
-    if (url === null) {
-        throw new Error(`navigate: invalid or unsupported url: ${JSON.stringify(input.url)}`);
-    }
-    const tabId = input.tabId ?? (await activeTabId());
-    if (tabId === undefined) {
-        throw new Error('navigate: no active tab (open a tab or pass tab_id)');
-    }
-    const pending = waitForComplete(tabId, input.timeoutMs ?? DEFAULT_LOAD_TIMEOUT_MS);
-    const tab = await chrome.tabs.update(tabId, { url });
-    const outcome = await pending;
-    return {
-        tabId,
-        url,
-        ...(tab?.windowId !== undefined ? { windowId: tab.windowId } : {}),
-        status: outcome === 'complete' ? 'complete' : 'loading',
-    };
-};
-/**
- * Open a new tab at url and wait for it to finish loading. active defaults to
- * Chrome's behavior (foreground). Throws on an invalid url or when Chrome returns
- * no tab id.
- */
-const openNewTab = async (input) => {
-    const url = normalizeUrl(input.url);
-    if (url === null) {
-        throw new Error(`new_tab: invalid or unsupported url: ${JSON.stringify(input.url)}`);
-    }
-    const tab = await chrome.tabs.create({
-        url,
-        ...(input.active !== undefined ? { active: input.active } : {}),
-    });
-    const tabId = tab.id;
-    if (tabId === undefined) {
-        throw new Error('new_tab: chrome did not return a tab id');
-    }
-    const outcome = await waitForComplete(tabId, input.timeoutMs ?? DEFAULT_LOAD_TIMEOUT_MS);
-    return {
-        tabId,
-        url,
-        ...(tab.windowId !== undefined ? { windowId: tab.windowId } : {}),
-        status: outcome === 'complete' ? 'complete' : 'loading',
-        created: true,
-    };
-};
-
 const compilePatternList = (sources, fieldPathPrefix) => {
     if (sources === undefined || sources.length === 0) {
         return { ok: true, value: [] };
@@ -665,6 +561,206 @@ const ACTION_TOOL_SPECS = Object.freeze([
     { tool: 'pdl_pinch', action: 'pinch', params: [N('scale', true, 'target scale: >1 zoom in, <1 zoom out'), N('steps', false, 'touchmove steps (default 10)')], summary: 'Pinch-zoom on the located element with two touches.' },
 ]);
 
+// A bare javascript: URL would run script in the target page context on navigate;
+// reject it. Everything else (http(s), file:, about:, data:, chrome:, localhost
+// shorthand) is allowed — this is a debugging driver, not a sandbox.
+const JAVASCRIPT_SCHEME = /^javascript:/i;
+const HAS_SCHEME = /^[a-z][a-z0-9+.-]*:/i;
+/**
+ * Normalize a caller-supplied navigation URL: trim, reject empty / javascript:,
+ * and assume https:// when no scheme is given (so `example.com` works). Returns
+ * null when the input is unusable so the caller can surface a clear error.
+ * Shared by the extension (chrome.tabs) and the host (CDP Page.navigate) so both
+ * navigation paths accept exactly the same URLs.
+ */
+const normalizeUrl = (raw) => {
+    const trimmed = raw.trim();
+    if (trimmed.length === 0)
+        return null;
+    if (JAVASCRIPT_SCHEME.test(trimmed))
+        return null;
+    return HAS_SCHEME.test(trimmed) ? trimmed : `https://${trimmed}`;
+};
+
+const REGEX_SPECIALS = /[.+?^${}()|[\]\\]/g;
+const globToRegex = (pattern) => {
+    const escaped = pattern.replace(REGEX_SPECIALS, '\\$&').replace(/\*/g, '.*');
+    return new RegExp(`^${escaped}$`);
+};
+const matchesAnyGlob = (value, patterns) => patterns.some((p) => globToRegex(p).test(value));
+/**
+ * Raw captured-event kinds (6) -> M7 capture categories (4).
+ * The union side reflects the captured_event.ts kind discriminants.
+ */
+const KIND_MAP = Object.freeze({
+    console: 'console',
+    fetch: 'network',
+    xhr: 'network',
+    websocket: 'network',
+    dom_mutation: 'dom_mutations',
+    lifecycle: 'lifecycle',
+    // App service-worker lifecycle: its own capture category + host buffer.
+    sw_state: 'sw_state',
+    store_change: 'store_change',
+    replay: 'replay',
+    library_popup: 'library_popup',
+});
+const eventKindToCaptureKind = (rawKind) => KIND_MAP[rawKind] ?? null;
+const isKindEnabled = (rawKind, enabledKinds) => {
+    const ck = eventKindToCaptureKind(rawKind);
+    if (ck === null)
+        return true; // unknown raw kinds default-allow (future-compat)
+    return enabledKinds.includes(ck);
+};
+const isUrlAllowed = (url, allowlist, blocklist) => {
+    if (matchesAnyGlob(url, blocklist))
+        return false; // blocklist wins
+    if (allowlist.length === 0)
+        return false; // explicit opt-in model
+    return matchesAnyGlob(url, allowlist);
+};
+/**
+ * Pick the most-specific readControls entry whose glob pattern matches `url`.
+ * Specificity = longest pattern string; ties broken by lexicographic order of
+ * the pattern so the choice is deterministic. Returns undefined when no
+ * pattern matches (caller treats as no restriction).
+ */
+const pickMostSpecificReadControl = (url, controls) => {
+    let winnerPattern;
+    let winnerValue;
+    for (const [pattern, value] of Object.entries(controls)) {
+        if (!matchesAnyGlob(url, [pattern]))
+            continue;
+        if (winnerPattern === undefined) {
+            winnerPattern = pattern;
+            winnerValue = value;
+            continue;
+        }
+        if (pattern.length > winnerPattern.length ||
+            (pattern.length === winnerPattern.length && pattern < winnerPattern)) {
+            winnerPattern = pattern;
+            winnerValue = value;
+        }
+    }
+    return winnerValue;
+};
+/**
+ * True iff the resolved readControls entry permits the given CaptureKind.
+ * Missing flag = allowed (no restriction); explicit `false` denies. Undefined
+ * control (no matching readControls entry) = allowed.
+ */
+const isKindAllowedByReadControls = (kind, control) => control?.[kind] !== false;
+/**
+ * True iff the per-kind capture.filters predicate (if configured) accepts the
+ * event. No filter for the resolved kind => allow. compileSourceFilter ok:false
+ * (malformed regex despite the schema validator) => fail-open (allow) so a
+ * single bad filter cannot suppress all events of a kind.
+ */
+const passesCaptureFilter = (event, captureKind, filters) => {
+    const spec = filters[captureKind];
+    if (spec === undefined)
+        return true;
+    const compiled = compileSourceFilter(spec);
+    if (!compiled.ok)
+        return true;
+    return compiled.predicate(event);
+};
+const shouldCaptureEvent = (event, settings) => {
+    if (!isKindEnabled(event.kind, settings['capture.enabledKinds'])) {
+        return false;
+    }
+    if (!isUrlAllowed(event.frameUrl, settings['sites.allowlist'], settings['sites.blocklist'])) {
+        return false;
+    }
+    const captureKind = eventKindToCaptureKind(event.kind);
+    if (captureKind === null)
+        return true; // unknown raw kinds default-allow
+    const control = pickMostSpecificReadControl(event.frameUrl, settings['sites.readControls']);
+    if (!isKindAllowedByReadControls(captureKind, control))
+        return false;
+    return passesCaptureFilter(event, captureKind, settings['capture.filters']);
+};
+
+const DEFAULT_LOAD_TIMEOUT_MS = 10_000;
+/** Active tab id in the last-focused window, or undefined when there is none. */
+const activeTabId = async () => {
+    const tabs = await chrome.tabs.query({ active: true, lastFocusedWindow: true });
+    return tabs[0]?.id;
+};
+/**
+ * Resolve once the tab reports document 'complete', or 'timeout' after timeoutMs.
+ * The onUpdated listener is added BEFORE the caller triggers the load so the
+ * 'complete' event can't be missed; it is always removed and the timer cleared.
+ */
+const waitForComplete = (tabId, timeoutMs) => new Promise((resolve) => {
+    let settled = false;
+    const settle = (outcome) => {
+        if (settled)
+            return;
+        settled = true;
+        chrome.tabs.onUpdated.removeListener(onUpdated);
+        clearTimeout(timer);
+        resolve(outcome);
+    };
+    const onUpdated = (id, info) => {
+        if (id === tabId && info.status === 'complete')
+            settle('complete');
+    };
+    const timer = setTimeout(() => settle('timeout'), timeoutMs);
+    chrome.tabs.onUpdated.addListener(onUpdated);
+});
+/**
+ * Navigate the active (or given) tab to url and wait for it to finish loading.
+ * Throws on an invalid url or when no tab can be resolved. The listener is armed
+ * before chrome.tabs.update so the fresh load's 'complete' is observed.
+ */
+const navigateTab = async (input) => {
+    const url = normalizeUrl(input.url);
+    if (url === null) {
+        throw new Error(`navigate: invalid or unsupported url: ${JSON.stringify(input.url)}`);
+    }
+    const tabId = input.tabId ?? (await activeTabId());
+    if (tabId === undefined) {
+        throw new Error('navigate: no active tab (open a tab or pass tab_id)');
+    }
+    const pending = waitForComplete(tabId, input.timeoutMs ?? DEFAULT_LOAD_TIMEOUT_MS);
+    const tab = await chrome.tabs.update(tabId, { url });
+    const outcome = await pending;
+    return {
+        tabId,
+        url,
+        ...(tab?.windowId !== undefined ? { windowId: tab.windowId } : {}),
+        status: outcome === 'complete' ? 'complete' : 'loading',
+    };
+};
+/**
+ * Open a new tab at url and wait for it to finish loading. active defaults to
+ * Chrome's behavior (foreground). Throws on an invalid url or when Chrome returns
+ * no tab id.
+ */
+const openNewTab = async (input) => {
+    const url = normalizeUrl(input.url);
+    if (url === null) {
+        throw new Error(`new_tab: invalid or unsupported url: ${JSON.stringify(input.url)}`);
+    }
+    const tab = await chrome.tabs.create({
+        url,
+        ...(input.active !== undefined ? { active: input.active } : {}),
+    });
+    const tabId = tab.id;
+    if (tabId === undefined) {
+        throw new Error('new_tab: chrome did not return a tab id');
+    }
+    const outcome = await waitForComplete(tabId, input.timeoutMs ?? DEFAULT_LOAD_TIMEOUT_MS);
+    return {
+        tabId,
+        url,
+        ...(tab.windowId !== undefined ? { windowId: tab.windowId } : {}),
+        status: outcome === 'complete' ? 'complete' : 'loading',
+        created: true,
+    };
+};
+
 const isSwRequestEnvelope = (m) => {
     if (m === null || typeof m !== 'object')
         return false;
@@ -2175,105 +2271,6 @@ const createSettingsCache = () => {
     return { getSetting, getAll, applySnapshot, applyChange };
 };
 
-const REGEX_SPECIALS = /[.+?^${}()|[\]\\]/g;
-const globToRegex = (pattern) => {
-    const escaped = pattern.replace(REGEX_SPECIALS, '\\$&').replace(/\*/g, '.*');
-    return new RegExp(`^${escaped}$`);
-};
-const matchesAnyGlob = (value, patterns) => patterns.some((p) => globToRegex(p).test(value));
-/**
- * Raw captured-event kinds (6) -> M7 capture categories (4).
- * The union side reflects the captured_event.ts kind discriminants.
- */
-const KIND_MAP = Object.freeze({
-    console: 'console',
-    fetch: 'network',
-    xhr: 'network',
-    websocket: 'network',
-    dom_mutation: 'dom_mutations',
-    lifecycle: 'lifecycle',
-    // App service-worker lifecycle: its own capture category + host buffer.
-    sw_state: 'sw_state',
-    store_change: 'store_change',
-    replay: 'replay',
-    library_popup: 'library_popup',
-});
-const eventKindToCaptureKind = (rawKind) => KIND_MAP[rawKind] ?? null;
-const isKindEnabled = (rawKind, enabledKinds) => {
-    const ck = eventKindToCaptureKind(rawKind);
-    if (ck === null)
-        return true; // unknown raw kinds default-allow (future-compat)
-    return enabledKinds.includes(ck);
-};
-const isUrlAllowed = (url, allowlist, blocklist) => {
-    if (matchesAnyGlob(url, blocklist))
-        return false; // blocklist wins
-    if (allowlist.length === 0)
-        return false; // explicit opt-in model
-    return matchesAnyGlob(url, allowlist);
-};
-/**
- * Pick the most-specific readControls entry whose glob pattern matches `url`.
- * Specificity = longest pattern string; ties broken by lexicographic order of
- * the pattern so the choice is deterministic. Returns undefined when no
- * pattern matches (caller treats as no restriction).
- */
-const pickMostSpecificReadControl = (url, controls) => {
-    let winnerPattern;
-    let winnerValue;
-    for (const [pattern, value] of Object.entries(controls)) {
-        if (!matchesAnyGlob(url, [pattern]))
-            continue;
-        if (winnerPattern === undefined) {
-            winnerPattern = pattern;
-            winnerValue = value;
-            continue;
-        }
-        if (pattern.length > winnerPattern.length ||
-            (pattern.length === winnerPattern.length && pattern < winnerPattern)) {
-            winnerPattern = pattern;
-            winnerValue = value;
-        }
-    }
-    return winnerValue;
-};
-/**
- * True iff the resolved readControls entry permits the given CaptureKind.
- * Missing flag = allowed (no restriction); explicit `false` denies. Undefined
- * control (no matching readControls entry) = allowed.
- */
-const isKindAllowedByReadControls = (kind, control) => control?.[kind] !== false;
-/**
- * True iff the per-kind capture.filters predicate (if configured) accepts the
- * event. No filter for the resolved kind => allow. compileSourceFilter ok:false
- * (malformed regex despite the schema validator) => fail-open (allow) so a
- * single bad filter cannot suppress all events of a kind.
- */
-const passesCaptureFilter = (event, captureKind, filters) => {
-    const spec = filters[captureKind];
-    if (spec === undefined)
-        return true;
-    const compiled = compileSourceFilter(spec);
-    if (!compiled.ok)
-        return true;
-    return compiled.predicate(event);
-};
-const shouldCaptureEvent = (event, settings) => {
-    if (!isKindEnabled(event.kind, settings['capture.enabledKinds'])) {
-        return false;
-    }
-    if (!isUrlAllowed(event.frameUrl, settings['sites.allowlist'], settings['sites.blocklist'])) {
-        return false;
-    }
-    const captureKind = eventKindToCaptureKind(event.kind);
-    if (captureKind === null)
-        return true; // unknown raw kinds default-allow
-    const control = pickMostSpecificReadControl(event.frameUrl, settings['sites.readControls']);
-    if (!isKindAllowedByReadControls(captureKind, control))
-        return false;
-    return passesCaptureFilter(event, captureKind, settings['capture.filters']);
-};
-
 const isSettingsEventMessage = (msg) => {
     if (msg === null || typeof msg !== 'object')
         return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aryanduntley/pwa-debug",
-  "version": "0.1.8",
+  "version": "1.0.0",
   "private": false,
   "license": "MIT",
   "type": "module",
@@ -63,8 +63,8 @@
     "@types/winreg": "^1.2.36",
     "rollup": "^4.27.4",
     "tslib": "^2.8.1",
-    "@pwa-debug/extension": "0.1.8",
-    "@pwa-debug/shared": "0.1.8"
+    "@pwa-debug/extension": "1.0.0",
+    "@pwa-debug/shared": "1.0.0"
   },
   "scripts": {
     "typecheck": "tsc --noEmit",