@tindalabs/shield 0.1.0

package/dist/core/mediator/handlers/extensionEventHandlers.js

@@ -0,0 +1,140 @@
+import { ProtectionEventType } from "../protection-event";
+import { isEventType } from "../eventDataTypes";
+import { AbstractEventHandler } from "./abstractEventHandler";
+/**
+ * Handler for browser extension detection events
+ */
+export class BrowserExtensionEventHandler extends AbstractEventHandler {
+    /**
+     * Create a new BrowserExtensionEventHandler
+     * @param mediator The protection mediator
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(mediator, debugMode = false) {
+        super(mediator, "BrowserExtensionEventHandler", debugMode);
+    }
+    /**
+     * Initialize the handler and subscribe to events
+     */
+    initialize() {
+        this.subscribe(ProtectionEventType.EXTENSION_DETECTED, this.handleExtensionDetected.bind(this));
+    }
+    /**
+     * Handle extension detection
+     * @param event the ProtectionEvent
+     */
+    handleExtensionDetected(event) {
+        // Use type guard for type-safe access
+        if (!isEventType(event, ProtectionEventType.EXTENSION_DETECTED)) {
+            this.error("Received invalid event type");
+            return;
+        }
+        const { data } = event;
+        this.log(`Handling extension detection state change, name=${data.extension?.name || "unknown"}`);
+        if (data.extension) {
+            this.applyExtensionProtection(event);
+            this.log("Blocking interface due to extension detection");
+        }
+        else {
+            this.removeExtensionProtection(event);
+            this.log("Unlocking interface after extension removal");
+        }
+    }
+    /**
+     * Handle extension detection
+     * @param event the typed ExtensionDetectedEvent
+     */
+    applyExtensionProtection(event) {
+        const { data } = event;
+        if (data.hideContent) {
+            this.mediator.publish({
+                type: ProtectionEventType.CONTENT_HIDDEN,
+                source: this.COMPONENT_NAME,
+                timestamp: Date.now(),
+                data: {
+                    strategyName: this.COMPONENT_NAME,
+                    reason: "extension_detected",
+                    targetElement: data.target,
+                    options: {
+                        title: data.overlayOptions?.title,
+                        message: data.overlayOptions?.message,
+                        secondaryMessage: `"${data.extension?.name}" triggered this warning`,
+                        textColor: "black",
+                        backgroundColor: "rgba(0, 0, 0, 0.05)",
+                    },
+                    priority: 8,
+                },
+            });
+        }
+        if (data.showOverlay) {
+            const extensionConfig = data.extension;
+            const additionalContent = `
+        <p style="font-size: 18px; margin-top: 20px;">Detected: ${extensionConfig.name}</p>
+        <p style="font-size: 14px; margin-top: 10px;">Risk Level: ${extensionConfig.risk.toUpperCase()}</p>
+        <button id="extension-protection-close" style="margin-top: 20px; padding: 10px 20px; background-color: white; color: black; border: none; border-radius: 4px; cursor: pointer; pointer-events: auto;">
+          I've Disabled the Extension
+        </button>
+      `;
+            setTimeout(() => {
+                const closeButton = document.getElementById("extension-protection-close");
+                if (closeButton) {
+                    closeButton.addEventListener("click", () => {
+                        window.location.reload();
+                    });
+                }
+            }, 0);
+            this.mediator.publish({
+                type: ProtectionEventType.OVERLAY_SHOWN,
+                source: this.COMPONENT_NAME,
+                timestamp: Date.now(),
+                data: {
+                    strategyName: this.COMPONENT_NAME,
+                    overlayType: "extension",
+                    options: {
+                        ...data.overlayOptions,
+                        blockEvents: true,
+                        autoRestore: true,
+                        additionalContent,
+                    },
+                    priority: 8,
+                },
+            });
+        }
+    }
+    /**
+     * Remove extension protection
+     * @param event The typed ExtensionDetectedEvent
+     */
+    removeExtensionProtection(event) {
+        const { data } = event;
+        if (data.hideContent) {
+            this.mediator.publish({
+                type: ProtectionEventType.CONTENT_RESTORED,
+                source: this.COMPONENT_NAME,
+                timestamp: Date.now(),
+                data: {
+                    strategyName: this.COMPONENT_NAME,
+                    targetElement: data.target,
+                },
+            });
+        }
+        if (data.showOverlay) {
+            this.mediator.publish({
+                type: ProtectionEventType.OVERLAY_REMOVED,
+                source: this.COMPONENT_NAME,
+                timestamp: Date.now(),
+                data: {
+                    strategyName: this.COMPONENT_NAME,
+                    overlayType: "extension",
+                    reason: "extension_removed",
+                },
+            });
+        }
+    }
+    /**
+     * Additional cleanup to be performed on disposal
+     */
+    onDispose() {
+        // No additional cleanup needed for this handler
+    }
+}

package/dist/core/mediator/handlers/iFrameEventHandlers.d.ts

@@ -0,0 +1,27 @@
+import type { ProtectionMediator } from "../../mediator/types";
+import { type ProtectionEvent } from "../../mediator/protection-event";
+import { AbstractEventHandler } from "./abstractEventHandler";
+/**
+ * Handler for frame embedding events
+ */
+export declare class FrameEmbeddingEventHandler extends AbstractEventHandler {
+    /**
+     * Create a new FrameEmbeddingEventHandler
+     * @param mediator The protection mediator
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(mediator: ProtectionMediator, debugMode?: boolean);
+    /**
+     * Initialize the handler and set up event subscriptions
+     */
+    protected initialize(): void;
+    /**
+     * Handle frame embedding detection event
+     * @param event The protection event containing frame embedding data
+     */
+    handleFrameEmbeddingDetected(event: ProtectionEvent): void;
+    /**
+     * Clean up resources when the handler is disposed
+     */
+    protected onDispose(): void;
+}

package/dist/core/mediator/handlers/iFrameEventHandlers.js

@@ -0,0 +1,93 @@
+import { ProtectionEventType } from "../../mediator/protection-event";
+import { AbstractEventHandler } from "./abstractEventHandler";
+/**
+ * Handler for frame embedding events
+ */
+export class FrameEmbeddingEventHandler extends AbstractEventHandler {
+    /**
+     * Create a new FrameEmbeddingEventHandler
+     * @param mediator The protection mediator
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(mediator, debugMode = false) {
+        super(mediator, "FrameEmbeddingEventHandler", debugMode);
+    }
+    /**
+     * Initialize the handler and set up event subscriptions
+     */
+    initialize() {
+        // Subscribe to the FRAME_EMBEDDING_DETECTED event
+        this.subscribe(ProtectionEventType.FRAME_EMBEDDING_DETECTED, this.handleFrameEmbeddingDetected.bind(this));
+        this.log("Initialized and subscribed to frame embedding events");
+    }
+    /**
+     * Handle frame embedding detection event
+     * @param event The protection event containing frame embedding data
+     */
+    handleFrameEmbeddingDetected(event) {
+        try {
+            const frameEvent = event;
+            this.log("Handling frame embedding detected event", frameEvent);
+            const data = frameEvent.data;
+            if (!data) {
+                this.warn("Received invalid frame embedding event data");
+                return;
+            }
+            // Only handle external frames
+            if (data.isEmbedded && data.isExternalFrame) {
+                this.log(`Applying protection for external frame embedding from ${data.parentDomain || "unknown domain"}`);
+                // Show overlay if configured
+                if (data.showOverlay) {
+                    this.mediator.publish({
+                        type: ProtectionEventType.OVERLAY_SHOWN,
+                        source: this.COMPONENT_NAME,
+                        timestamp: Date.now(),
+                        data: {
+                            strategyName: this.COMPONENT_NAME,
+                            overlayType: "frame_embedding",
+                            options: {
+                                ...data.overlayOptions,
+                                blockEvents: true,
+                                autoRestore: true,
+                            },
+                            priority: 9, // High priority for frame embedding
+                        },
+                    });
+                }
+                // Hide content if configured
+                if (data.hideContent) {
+                    this.mediator.publish({
+                        type: ProtectionEventType.CONTENT_HIDDEN,
+                        source: this.COMPONENT_NAME,
+                        timestamp: Date.now(),
+                        data: {
+                            strategyName: this.COMPONENT_NAME,
+                            reason: "frame_embedding",
+                            targetElement: data.targetElement,
+                            options: {
+                                title: data.overlayOptions?.title,
+                                message: data.overlayOptions?.message,
+                                secondaryMessage: data.overlayOptions?.secondaryMessage,
+                                textColor: "black",
+                                backgroundColor: "rgba(0, 0, 0, 0.05)",
+                            },
+                            priority: 9, // High priority for frame embedding
+                        },
+                    });
+                }
+            }
+            else {
+                this.log("Skipping protection for non-external frame embedding");
+            }
+        }
+        catch (error) {
+            this.error("Error handling frame embedding detected event:", error);
+        }
+    }
+    /**
+     * Clean up resources when the handler is disposed
+     */
+    onDispose() {
+        // No additional cleanup needed beyond what the base class does
+    }
+}

package/dist/core/mediator/handlers/screenShotEventHandlers.d.ts

@@ -0,0 +1,34 @@
+import type { ProtectionMediator } from "../../mediator/types";
+import { type ProtectionEvent } from "../protection-event";
+import { AbstractEventHandler } from "./abstractEventHandler";
+/**
+ * Handler for screenshot detection events
+ */
+export declare class ScreenshotEventHandler extends AbstractEventHandler {
+    private timeoutManager;
+    private activeTimeouts;
+    /**
+     * Create a new ScreenshotEventHandler
+     * @param mediator The protection mediator
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(mediator: ProtectionMediator, debugMode?: boolean);
+    /**
+     * Initialize the handler and subscribe to events
+     */
+    protected initialize(): void;
+    /**
+     * Handle screenshot attempt event
+     * @param event The protection event
+     */
+    handleScreenshotAttempt(event: ProtectionEvent): void;
+    /**
+     * Set debug mode
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled: boolean): void;
+    /**
+     * Additional cleanup to be performed on disposal
+     */
+    protected onDispose(): void;
+}

package/dist/core/mediator/handlers/screenShotEventHandlers.js

@@ -0,0 +1,111 @@
+import { ProtectionEventType } from "../protection-event";
+import { TimeoutManager } from "../../../utils/timeoutManager";
+import { AbstractEventHandler } from "./abstractEventHandler";
+/**
+ * Handler for screenshot detection events
+ */
+export class ScreenshotEventHandler extends AbstractEventHandler {
+    /**
+     * Create a new ScreenshotEventHandler
+     * @param mediator The protection mediator
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(mediator, debugMode = false) {
+        super(mediator, "ScreenshotEventHandler", debugMode);
+        this.activeTimeouts = new Set(); // Track active timeouts
+        this.timeoutManager = TimeoutManager.getInstance();
+        this.timeoutManager.setDebugMode(this.debugMode);
+    }
+    /**
+     * Initialize the handler and subscribe to events
+     */
+    initialize() {
+        // Subscribe to the SCREENSHOT_ATTEMPT event
+        this.subscribe(ProtectionEventType.SCREENSHOT_ATTEMPT, this.handleScreenshotAttempt.bind(this));
+    }
+    /**
+     * Handle screenshot attempt event
+     * @param event The protection event
+     */
+    handleScreenshotAttempt(event) {
+        const screenshotEvent = event;
+        this.log("Handling screenshot attempt event", screenshotEvent);
+        // Generate a unique ID for this protection instance
+        const protectionId = `screenshot_${Date.now()}`;
+        if (screenshotEvent.data.showOverlay) {
+            this.mediator.publish({
+                type: ProtectionEventType.OVERLAY_SHOWN,
+                source: screenshotEvent.source,
+                timestamp: Date.now(),
+                data: {
+                    strategyName: screenshotEvent.source,
+                    overlayType: "screenshot",
+                    options: {
+                        ...screenshotEvent.data.overlayOptions,
+                        blockEvents: false, // Don't block events, just show a notification
+                        autoRestore: true,
+                    },
+                    priority: screenshotEvent.data.priority || 5,
+                    duration: screenshotEvent.data.overlayOptions?.duration || 3000
+                },
+            });
+        }
+        if (screenshotEvent.data.hideContent) {
+            this.mediator.publish({
+                type: ProtectionEventType.CONTENT_HIDDEN,
+                source: screenshotEvent.source,
+                timestamp: Date.now(),
+                data: {
+                    strategyName: screenshotEvent.source,
+                    reason: "screenshot_attempt",
+                    options: {
+                        title: screenshotEvent.data.overlayOptions?.title,
+                        message: screenshotEvent.data.overlayOptions?.message,
+                        secondaryMessage: screenshotEvent.data.overlayOptions?.secondaryMessage,
+                        textColor: 'black',
+                        backgroundColor: screenshotEvent.data.overlayOptions?.backgroundColor || "rgba(0, 0, 0, 0.05)",
+                    },
+                    targetElement: screenshotEvent.data.target,
+                    priority: screenshotEvent.data.priority || 5,
+                },
+            });
+            // Create a unique timeout ID for this screenshot event
+            const contentTimeoutId = `${protectionId}_content`;
+            this.activeTimeouts.add(contentTimeoutId);
+            // If duration is specified, set a timeout to restore content
+            if (screenshotEvent.data.overlayOptions?.duration) {
+                this.timeoutManager.setTimeout(contentTimeoutId, () => {
+                    this.mediator.publish({
+                        type: ProtectionEventType.CONTENT_RESTORED,
+                        source: screenshotEvent.source,
+                        timestamp: Date.now(),
+                        data: {
+                            strategyName: screenshotEvent.source,
+                            targetElement: screenshotEvent.data.target,
+                        },
+                    });
+                    this.activeTimeouts.delete(contentTimeoutId);
+                }, screenshotEvent.data.overlayOptions?.duration);
+                this.log(`Set timeout ${contentTimeoutId} to restore content after ${screenshotEvent.data.overlayOptions.duration}s`);
+            }
+        }
+    }
+    /**
+     * Set debug mode
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled) {
+        super.setDebugMode(enabled);
+        this.timeoutManager.setDebugMode(enabled);
+    }
+    /**
+     * Additional cleanup to be performed on disposal
+     */
+    onDispose() {
+        // Clear all active timeouts
+        for (const timeoutId of this.activeTimeouts) {
+            this.timeoutManager.clearTimeout(timeoutId);
+        }
+        this.activeTimeouts.clear();
+    }
+}

package/dist/core/mediator/protection-event.d.ts

@@ -0,0 +1,77 @@
+import { EventDataMap } from "./eventDataTypes";
+/**
+ * Types of protection events that can be published and subscribed to.
+ *
+ * Only the events listed below are actually wired through the mediator today.
+ * The mediator pattern serves a specific case: a detect-and-react fan-out where
+ * one detection signal needs to coordinate multiple visible reactions (overlay,
+ * content hiding, telemetry). That's why only 4 of the 10 strategies use it —
+ * DevTools, Extension, IFrame, and Screenshot. The other 6 (Clipboard,
+ * Selection, ContextMenu, Keyboard, Print, Watermark) are direct-blocking
+ * strategies where the handler IS the strategy; routing them through the
+ * mediator would add ceremony for no decoupling benefit.
+ *
+ * If you need a NEW event type, add it here AND give it a `[NewType]: { ... }`
+ * entry in {@link EventDataMap}.
+ */
+export declare enum ProtectionEventType {
+    STRATEGY_REMOVED = "strategy:removed",
+    DEVTOOLS_STATE_CHANGE = "protection:devtools",
+    EXTENSION_DETECTED = "protection:extension",
+    FRAME_EMBEDDING_DETECTED = "protection:frame",
+    SCREENSHOT_ATTEMPT = "protection:screenshot",
+    OVERLAY_SHOWN = "overlay:shown",
+    OVERLAY_REMOVED = "overlay:removed",
+    OVERLAY_RESTORED = "overlay:restored",
+    CONTENT_HIDDEN = "content:hidden",
+    CONTENT_RESTORED = "content:restored"
+}
+/**
+ * Base protection event interface
+ */
+export interface ProtectionEvent {
+    /**
+     * Type of the event
+     */
+    type: ProtectionEventType;
+    /**
+     * Source of the event (usually strategy name)
+     */
+    source: string;
+    /**
+     * Timestamp when the event occurred
+     */
+    timestamp: number;
+    /**
+     * Additional data specific to the event type
+     */
+    data?: unknown;
+}
+/**
+ * Event for DevTools state changes
+ */
+export interface DevToolsEvent extends ProtectionEvent {
+    type: ProtectionEventType.DEVTOOLS_STATE_CHANGE;
+    data: EventDataMap[ProtectionEventType.DEVTOOLS_STATE_CHANGE];
+}
+/**
+ * Event for extension detection
+ */
+export interface ExtensionEvent extends ProtectionEvent {
+    type: ProtectionEventType.EXTENSION_DETECTED;
+    data: EventDataMap[ProtectionEventType.EXTENSION_DETECTED];
+}
+/**
+ * Event for screenshot detection
+ */
+export interface ScreenshotEvent extends ProtectionEvent {
+    type: ProtectionEventType.SCREENSHOT_ATTEMPT;
+    data: EventDataMap[ProtectionEventType.SCREENSHOT_ATTEMPT];
+}
+/**
+ * Event for frame embedding detection
+ */
+export interface FrameEmbeddingEvent extends ProtectionEvent {
+    type: ProtectionEventType.FRAME_EMBEDDING_DETECTED;
+    data: EventDataMap[ProtectionEventType.FRAME_EMBEDDING_DETECTED];
+}

package/dist/core/mediator/protection-event.js

@@ -0,0 +1,32 @@
+/**
+ * Types of protection events that can be published and subscribed to.
+ *
+ * Only the events listed below are actually wired through the mediator today.
+ * The mediator pattern serves a specific case: a detect-and-react fan-out where
+ * one detection signal needs to coordinate multiple visible reactions (overlay,
+ * content hiding, telemetry). That's why only 4 of the 10 strategies use it —
+ * DevTools, Extension, IFrame, and Screenshot. The other 6 (Clipboard,
+ * Selection, ContextMenu, Keyboard, Print, Watermark) are direct-blocking
+ * strategies where the handler IS the strategy; routing them through the
+ * mediator would add ceremony for no decoupling benefit.
+ *
+ * If you need a NEW event type, add it here AND give it a `[NewType]: { ... }`
+ * entry in {@link EventDataMap}.
+ */
+export var ProtectionEventType;
+(function (ProtectionEventType) {
+    // Strategy lifecycle
+    ProtectionEventType["STRATEGY_REMOVED"] = "strategy:removed";
+    // Detection signals (published by the detect-and-react strategies)
+    ProtectionEventType["DEVTOOLS_STATE_CHANGE"] = "protection:devtools";
+    ProtectionEventType["EXTENSION_DETECTED"] = "protection:extension";
+    ProtectionEventType["FRAME_EMBEDDING_DETECTED"] = "protection:frame";
+    ProtectionEventType["SCREENSHOT_ATTEMPT"] = "protection:screenshot";
+    // Overlay coordination
+    ProtectionEventType["OVERLAY_SHOWN"] = "overlay:shown";
+    ProtectionEventType["OVERLAY_REMOVED"] = "overlay:removed";
+    ProtectionEventType["OVERLAY_RESTORED"] = "overlay:restored";
+    // Content coordination
+    ProtectionEventType["CONTENT_HIDDEN"] = "content:hidden";
+    ProtectionEventType["CONTENT_RESTORED"] = "content:restored";
+})(ProtectionEventType || (ProtectionEventType = {}));

package/dist/core/mediator/types.d.ts

@@ -0,0 +1,105 @@
+import { EventDataMap } from './eventDataTypes';
+import { ProtectionEvent, ProtectionEventType } from './protection-event';
+/**
+ * Event handler function type
+ */
+export type ProtectionEventHandler = (event: ProtectionEvent) => void;
+/**
+ * Subscription information
+ */
+export interface Subscription {
+    /**
+     * Unique ID for the subscription
+     */
+    id: string;
+    /**
+     * Event type being subscribed to
+     */
+    eventType: ProtectionEventType;
+    /**
+     * Handler function for the event
+     */
+    handler: ProtectionEventHandler;
+    /**
+     * Optional filter function to determine if the handler should be called
+     */
+    filter?: (event: ProtectionEvent) => boolean;
+    /**
+     * Optional priority for the handler (higher numbers execute first)
+     */
+    priority?: number;
+    /**
+     * Optional context information (e.g., strategy name)
+     */
+    context?: string;
+}
+/**
+ * Subscription options
+ */
+export interface SubscriptionOptions {
+    /**
+     * Optional filter function to determine if the handler should be called
+     */
+    filter?: (event: ProtectionEvent) => boolean;
+    /**
+     * Optional priority for the handler (higher numbers execute first)
+     */
+    priority?: number;
+    /**
+     * Optional context information (e.g., strategy name)
+     */
+    context?: string;
+}
+/**
+ * Interface for the protection mediator
+ */
+export interface ProtectionMediator {
+    /**
+     * Subscribe to an event
+     * @param eventType Type of event to subscribe to
+     * @param handler Handler function for the event
+     * @param options Optional subscription options
+     * @returns Subscription ID for later unsubscribing
+     */
+    subscribe(eventType: ProtectionEventType, handler: ProtectionEventHandler, options?: SubscriptionOptions): string;
+    /**
+     * Unsubscribe from an event
+     * @param subscriptionId ID of the subscription to remove
+     * @returns True if the subscription was found and removed
+     */
+    unsubscribe(subscriptionId: string): boolean;
+    /**
+     * Publish an event to all subscribers
+     * @param event Event to publish
+     */
+    publish<T extends ProtectionEventType | string>(event: Omit<ProtectionEvent, "data"> & {
+        type: T;
+        data?: T extends ProtectionEventType ? EventDataMap[T] : Record<string, unknown>;
+    }): void;
+    /**
+     * Get all subscriptions for a specific event type
+     * @param eventType Type of event to get subscriptions for
+     * @returns Array of subscriptions
+     */
+    getSubscriptions(eventType: ProtectionEventType): Subscription[];
+    /**
+     * Set debug mode
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled: boolean): void;
+}
+/**
+ * Interface for components that can work with the mediator
+ */
+export interface MediatorAware {
+    /**
+     * Set the mediator for this component
+     * @param mediator The protection mediator
+     */
+    setMediator(mediator: ProtectionMediator): void;
+    /**
+     * Get the component name
+     * Used to identify the component in mediator communications
+     */
+    readonly COMPONENT_NAME: string;
+}

package/dist/core/mediator/types.js

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

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { assess } from './assess.js';
+export type { ShieldAssessment, ShieldSignals, ShieldRisk, AssessOptions } from './types/assessment.js';
+export { ContentProtector } from './core/index.js';
+export * from './types/index.js';
+export * from './strategies/index.js';
+export * from './utils/index.js';
+export { attachShieldToSpan } from './otel.js';
+export type { SpanEmitter } from './otel.js';
+export { assessAndProtect } from './policy.js';
+export type { PolicyRule, PolicyCondition, PolicyEngineOptions, PolicyResult, StrategyKey } from './policy.js';

package/dist/index.js

@@ -0,0 +1,7 @@
+export { assess } from './assess.js';
+export { ContentProtector } from './core/index.js';
+export * from './types/index.js';
+export * from './strategies/index.js';
+export * from './utils/index.js';
+export { attachShieldToSpan } from './otel.js';
+export { assessAndProtect } from './policy.js';

package/dist/otel.d.ts

@@ -0,0 +1,24 @@
+import { ContentProtector } from '@/core/index.js';
+import type { ContentProtectionOptions } from '@/types/index.js';
+/**
+ * A function that records one Shield security event as an immediately-ending
+ * span (or any other sink). Keeping it framework-agnostic — Shield does not
+ * depend on @opentelemetry/api; callers provide the emitter.
+ *
+ * @example with Blindspot:
+ *   import { getTracer, getRouteContext } from '@tindalabs/blindspot';
+ *   const emitter: SpanEmitter = (name, attrs) => {
+ *     const span = getTracer().startSpan(name, { attributes: attrs }, getRouteContext());
+ *     span.end();
+ *   };
+ */
+export type SpanEmitter = (name: string, attrs?: Record<string, string | number | boolean>) => void;
+/**
+ * Creates a ContentProtector with all callbacks wired to the provided SpanEmitter.
+ * Each security event fires a call to emitter(), which should create and immediately
+ * end a child span — so events are exported to Tempo without waiting for the
+ * long-lived navigation span to close.
+ *
+ * Any existing customHandlers in options are preserved and called after the emit.
+ */
+export declare function attachShieldToSpan(options: ContentProtectionOptions, emitter: SpanEmitter): ContentProtector;