@pan-sec/notebooklm-mcp 2026.3.3 → 2026.4.1

package/dist/notebook-creation/selectors.js

@@ -227,13 +227,15 @@ export function getSelectors(key) {
     const info = NOTEBOOKLM_SELECTORS[key];
     return [info.primary, ...info.fallbacks].filter(Boolean);
 }
-// I146: warn once at module load for unconfirmed selectors so UI drift is visible
-{
+// I146 / L32: surface unconfirmed selectors so UI drift is visible, but as a
+// debug-only message gated behind NLMCP_DEBUG. Previously this ran at import
+// time as a log.warning side effect, producing constant unsuppressable startup
+// noise on every server boot.
+if (process.env.NLMCP_DEBUG) {
     const unconfirmed = Object.entries(NOTEBOOKLM_SELECTORS)
         .filter(([, v]) => !v.confirmed)
         .map(([k]) => k);
     if (unconfirmed.length > 0) {
-        log.warning(`⚠️  Unconfirmed selectors in use (run discovery to validate): ${unconfirmed.join(", ")}`);
+        log.debug(`Unconfirmed selectors in use (run discovery to validate): ${unconfirmed.join(", ")}`);
     }
 }
-//# sourceMappingURL=selectors.js.map

package/dist/notebook-creation/source-manager-shared.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Source Manager — shared primitives
+ *
+ * Helpers genuinely shared between the two source managers in
+ * `source-manager.ts`:
+ *   - SourceManager                  (legacy: list/add/remove on an existing
+ *                                     notebook)
+ *   - NotebookCreationSourceManager  (the creation flow)
+ *
+ * Only logic that is byte-equivalent between the two classes lives here; the
+ * managers' distinct flows (source-type selection, submit/insert clicks, error
+ * alert handling, waitForSourceProcessing) intentionally differ and stay in
+ * place. These helpers are a pure de-duplication and are behavior-preserving.
+ */
+import type { Page } from "patchright";
+export type BrowserDomElement = unknown;
+export type BrowserSourceItem = {
+    textContent?: string | null;
+    className?: string;
+    id?: string;
+    getAttribute(name: string): string | null;
+    querySelector(selector: string): BrowserDomElement | null;
+    click(): void;
+};
+export type BrowserVisibleElement = {
+    textContent?: string | null;
+    className?: string;
+    offsetParent?: unknown;
+    parentElement?: BrowserVisibleElement | null;
+    getAttribute(name: string): string | null;
+    click(): void;
+};
+export type BrowserTextVisibleElement = BrowserVisibleElement & {
+    className?: string;
+};
+export type BrowserTextAreaCandidate = BrowserVisibleElement & {
+    value?: string;
+};
+export type BrowserInnerTextHandle = {
+    innerText(): Promise<string>;
+};
+export type BrowserDocumentContext = {
+    document: {
+        querySelector(selector: string): BrowserDomElement | null;
+        querySelectorAll(selector: string): Iterable<BrowserDomElement>;
+    };
+    window: {
+        innerWidth: number;
+    };
+};
+/**
+ * Find the first `textInput` selector that resolves to a visible textarea which
+ * is NOT the "discover sources" / "search the web" / query-box control.
+ *
+ * This is the exact, equivalent logic that both SourceManager and
+ * NotebookCreationSourceManager used (their two private copies differed only in
+ * an unused `rejected` field and the debug-log wording — callers read only the
+ * boolean match). The three exclusion substrings are kept byte-identical.
+ *
+ * @param debugLabel preserves each caller's original debug log line verbatim.
+ */
+export declare function findValidTextInputSelector(page: Page, debugLabel: string): Promise<string | null>;
+/**
+ * Set the text-source content via the direct DOM-value path only.
+ * The value is passed as a serialized page.evaluate argument (never
+ * string-interpolated). We deliberately do NOT use the OS copy/paste
+ * buffer: writing to it leaks/overwrites the host's copied data and, when
+ * the relevant browser permission is denied (common in headless), a paste
+ * keystroke would inject STALE buffered contents and corrupt the source.
+ *
+ * This is the byte-identical evaluate block both classes used. The differing
+ * focus/click step that precedes it (textArea.focus() in the legacy manager,
+ * textarea.click() in the creation manager) stays with each caller.
+ */
+export declare function setTextSourceValue(page: Page, selector: string, value: string): Promise<void>;

package/dist/notebook-creation/source-manager-shared.js

@@ -0,0 +1,86 @@
+/**
+ * Source Manager — shared primitives
+ *
+ * Helpers genuinely shared between the two source managers in
+ * `source-manager.ts`:
+ *   - SourceManager                  (legacy: list/add/remove on an existing
+ *                                     notebook)
+ *   - NotebookCreationSourceManager  (the creation flow)
+ *
+ * Only logic that is byte-equivalent between the two classes lives here; the
+ * managers' distinct flows (source-type selection, submit/insert clicks, error
+ * alert handling, waitForSourceProcessing) intentionally differ and stay in
+ * place. These helpers are a pure de-duplication and are behavior-preserving.
+ */
+import { log } from "../utils/logger.js";
+import { getSelectors } from "./selectors.js";
+/**
+ * Find the first `textInput` selector that resolves to a visible textarea which
+ * is NOT the "discover sources" / "search the web" / query-box control.
+ *
+ * This is the exact, equivalent logic that both SourceManager and
+ * NotebookCreationSourceManager used (their two private copies differed only in
+ * an unused `rejected` field and the debug-log wording — callers read only the
+ * boolean match). The three exclusion substrings are kept byte-identical.
+ *
+ * @param debugLabel preserves each caller's original debug log line verbatim.
+ */
+export async function findValidTextInputSelector(page, debugLabel) {
+    for (const selector of getSelectors("textInput")) {
+        try {
+            const state = await page.evaluate((targetSelector) => {
+                const browser = globalThis;
+                const textarea = browser.document.querySelector(targetSelector);
+                if (!textarea || textarea.offsetParent === null) {
+                    return { matches: false };
+                }
+                const aria = textarea.getAttribute("aria-label")?.toLowerCase() || "";
+                const placeholder = textarea.getAttribute("placeholder")?.toLowerCase() || "";
+                const className = textarea.className?.toLowerCase() || "";
+                const haystack = `${aria} ${placeholder} ${className}`;
+                return {
+                    matches: !haystack.includes("discover sources") &&
+                        !haystack.includes("search the web") &&
+                        !haystack.includes("query-box"),
+                };
+            }, selector);
+            if (state.matches) {
+                return selector;
+            }
+        }
+        catch (err) {
+            log.debug(`${debugLabel}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    return null;
+}
+/**
+ * Set the text-source content via the direct DOM-value path only.
+ * The value is passed as a serialized page.evaluate argument (never
+ * string-interpolated). We deliberately do NOT use the OS copy/paste
+ * buffer: writing to it leaks/overwrites the host's copied data and, when
+ * the relevant browser permission is denied (common in headless), a paste
+ * keystroke would inject STALE buffered contents and corrupt the source.
+ *
+ * This is the byte-identical evaluate block both classes used. The differing
+ * focus/click step that precedes it (textArea.focus() in the legacy manager,
+ * textarea.click() in the creation manager) stays with each caller.
+ */
+export async function setTextSourceValue(page, selector, value) {
+    await page.evaluate(({ selector, value }) => {
+        const browser = globalThis;
+        const textarea = browser.document.querySelector(selector);
+        if (!textarea)
+            return false;
+        textarea.focus();
+        if (typeof textarea.value === "string") {
+            textarea.value = value;
+        }
+        else {
+            textarea.textContent = value;
+        }
+        textarea.dispatchEvent(new browser.Event("input", { bubbles: true }));
+        textarea.dispatchEvent(new browser.Event("change", { bubbles: true }));
+        return true;
+    }, { selector, value });
+}

package/dist/notebook-creation/source-manager.d.ts

@@ -32,7 +32,22 @@ export declare class SourceManager {
     private authManager;
     private contextManager;
     private page;
+    private opChain;
     constructor(authManager: AuthManager, contextManager: SharedContextManager);
+    /**
+     * Serialize a public operation onto the op chain so concurrent invocations do
+     * not race on the shared this.page field. Failures of one operation must not
+     * poison the chain for the next, so the chain link always resolves.
+     */
+    private runExclusive;
+    /**
+     * Derive a STABLE source id from a DOM identity attribute when available,
+     * otherwise from a hash of the (title, occurrence) pair. Hashing the title
+     * gives an id that denotes the same source across sessions far better than a
+     * raw enumeration index, while staying opaque/stable for the removeSource
+     * contract. Occurrence disambiguates equal-titled rows within one listing.
+     */
+    private deriveSourceId;
     /**
      * Navigate to a notebook and ensure we're on the right page
      */
@@ -41,14 +56,17 @@ export declare class SourceManager {
      * List all sources in a notebook
      */
     listSources(notebookUrl: string): Promise<ListSourcesResult>;
+    private listSourcesInternal;
     /**
      * Add a source to an existing notebook
      */
     addSource(notebookUrl: string, source: NotebookSource): Promise<AddSourceResult>;
+    private addSourceInternal;
     /**
      * Remove a source from a notebook
      */
     removeSource(notebookUrl: string, sourceId: string): Promise<RemoveSourceResult>;
+    private removeSourceInternal;
     /**
      * Internal: Add URL source
      */
@@ -65,9 +83,19 @@ export declare class SourceManager {
      */
     private addFileSourceInternal;
     /**
-     * Wait for source processing to complete
+     * Wait for source processing to complete.
+     *
+     * Returns an honest status:
+     * - "failed"     — an error alert/toast appeared
+     * - "ready"      — the processing indicator cleared (positive completion)
+     * - "processing" — we timed out before any conclusion (do NOT report "ready")
      */
     private waitForSourceProcessing;
+    /**
+     * Detect an error alert/toast for a source. Returns the error text if found,
+     * otherwise null. Mirrors NotebookCreationSourceManager.throwIfSourceErrorAlert.
+     */
+    private detectSourceErrorAlert;
     /**
      * Close the page if open
      */
@@ -96,4 +124,3 @@ export declare class NotebookCreationSourceManager {
     private waitForSourceProcessing;
     private throwIfSourceErrorAlert;
 }
-//# sourceMappingURL=source-manager.d.ts.map

package/dist/notebook-creation/studio-manager-base.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Studio Manager Base
+ *
+ * Shared page-lifecycle plumbing for the NotebookLM "Studio" managers
+ * (audio, video, data table). These managers all open a notebook page,
+ * validate authentication, drive a Studio-panel artifact flow, then close
+ * the page. The navigation and teardown logic is identical across them and
+ * lives here; the artifact-specific flows stay in each subclass.
+ *
+ * Behavior is preserved exactly:
+ *   - navigateToNotebook: getOrCreateContext → validateWithRetry (throws
+ *     "Not authenticated. Run setup_auth first." when false) → newPage →
+ *     goto(domcontentloaded) → waitForLoadState("networkidle") (errors
+ *     swallowed) → per-subclass randomDelay → return page.
+ *   - closePage: close the page, swallowing errors, then null the handle.
+ *
+ * Per-subclass differences are expressed as protected properties so that no
+ * call site needs to thread arguments:
+ *   - navigateDelay: video & data table use 2000–3000ms, audio uses 1500–2500ms.
+ *   - logName: the log-prefix used in the swallowed close-error debug line.
+ */
+import type { Page } from "patchright";
+import { AuthManager } from "../auth/auth-manager.js";
+import { SharedContextManager } from "../session/shared-context-manager.js";
+/** Opaque DOM element handle used only in `as`-casts inside page.evaluate bodies. */
+export type BrowserDomElement = unknown;
+/** Minimal `document` shape used inside page.evaluate bodies. Common to all managers. */
+export interface BrowserDocumentContext {
+    document: {
+        querySelector(selector: string): BrowserDomElement | null;
+        querySelectorAll(selector: string): Iterable<BrowserDomElement>;
+    };
+}
+export declare abstract class StudioManagerBase {
+    protected authManager: AuthManager;
+    protected contextManager: SharedContextManager;
+    protected page: Page | null;
+    /**
+     * Trailing delay applied after navigation settles. Video & data table use the
+     * default (2000–3000ms); audio overrides to 1500–2500ms.
+     */
+    protected readonly navigateDelay: {
+        min: number;
+        max: number;
+    };
+    /** Log prefix used in the swallowed close-error debug line (kept per-manager). */
+    protected abstract readonly logName: string;
+    constructor(authManager: AuthManager, contextManager: SharedContextManager);
+    /**
+     * Navigate to a notebook and ensure we're on the right page
+     */
+    protected navigateToNotebook(notebookUrl: string): Promise<Page>;
+    /**
+     * Close the page if open
+     */
+    protected closePage(): Promise<void>;
+}

package/dist/notebook-creation/studio-manager-base.js

@@ -0,0 +1,67 @@
+/**
+ * Studio Manager Base
+ *
+ * Shared page-lifecycle plumbing for the NotebookLM "Studio" managers
+ * (audio, video, data table). These managers all open a notebook page,
+ * validate authentication, drive a Studio-panel artifact flow, then close
+ * the page. The navigation and teardown logic is identical across them and
+ * lives here; the artifact-specific flows stay in each subclass.
+ *
+ * Behavior is preserved exactly:
+ *   - navigateToNotebook: getOrCreateContext → validateWithRetry (throws
+ *     "Not authenticated. Run setup_auth first." when false) → newPage →
+ *     goto(domcontentloaded) → waitForLoadState("networkidle") (errors
+ *     swallowed) → per-subclass randomDelay → return page.
+ *   - closePage: close the page, swallowing errors, then null the handle.
+ *
+ * Per-subclass differences are expressed as protected properties so that no
+ * call site needs to thread arguments:
+ *   - navigateDelay: video & data table use 2000–3000ms, audio uses 1500–2500ms.
+ *   - logName: the log-prefix used in the swallowed close-error debug line.
+ */
+import { log } from "../utils/logger.js";
+import { randomDelay } from "../utils/stealth-utils.js";
+export class StudioManagerBase {
+    authManager;
+    contextManager;
+    page = null;
+    /**
+     * Trailing delay applied after navigation settles. Video & data table use the
+     * default (2000–3000ms); audio overrides to 1500–2500ms.
+     */
+    navigateDelay = { min: 2000, max: 3000 };
+    constructor(authManager, contextManager) {
+        this.authManager = authManager;
+        this.contextManager = contextManager;
+    }
+    /**
+     * Navigate to a notebook and ensure we're on the right page
+     */
+    async navigateToNotebook(notebookUrl) {
+        const context = await this.contextManager.getOrCreateContext();
+        const isAuth = await this.authManager.validateWithRetry(context);
+        if (!isAuth) {
+            throw new Error("Not authenticated. Run setup_auth first.");
+        }
+        this.page = await context.newPage();
+        await this.page.goto(notebookUrl, { waitUntil: "domcontentloaded" });
+        await this.page.waitForLoadState("networkidle").catch(() => { });
+        await randomDelay(this.navigateDelay.min, this.navigateDelay.max);
+        return this.page;
+    }
+    /**
+     * Close the page if open
+     */
+    async closePage() {
+        if (this.page) {
+            try {
+                await this.page.close();
+            }
+            catch (err) {
+                log.debug(`${this.logName}: closing page: ${err instanceof Error ? err.message : String(err)}`);
+                // Ignore close errors
+            }
+            this.page = null;
+        }
+    }
+}

package/dist/notebook-creation/types.d.ts

@@ -174,4 +174,3 @@ export interface DiscoveryResult {
     /** Any errors encountered */
     errors: string[];
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/notebook-creation/types.js

@@ -2,4 +2,3 @@
  * Types for notebook creation functionality
  */
 export {};
-//# sourceMappingURL=types.js.map

package/dist/notebook-creation/video-manager.d.ts

@@ -14,8 +14,7 @@
  * - Artifacts appear in .artifact-library-container with .artifact-item-button
  * - Generating state: .shimmer-blue class + .rotate icon + "Generating" title
  */
-import { AuthManager } from "../auth/auth-manager.js";
-import { SharedContextManager } from "../session/shared-context-manager.js";
+import { StudioManagerBase } from "./studio-manager-base.js";
 /**
  * Visual styles for video overviews (matches actual NotebookLM UI)
  */
@@ -34,15 +33,8 @@ export interface GenerateVideoResult {
     status: VideoStatus;
     error?: string;
 }
-export declare class VideoManager {
-    private authManager;
-    private contextManager;
-    private page;
-    constructor(authManager: AuthManager, contextManager: SharedContextManager);
-    /**
-     * Navigate to a notebook and ensure we're on the right page
-     */
-    private navigateToNotebook;
+export declare class VideoManager extends StudioManagerBase {
+    protected readonly logName = "video-manager";
     /**
      * Ensure the Studio panel is visible (expand if collapsed).
      *
@@ -93,9 +85,4 @@ export declare class VideoManager {
      * Check the current video status for a notebook
      */
     getVideoStatus(notebookUrl: string): Promise<VideoStatus>;
-    /**
-     * Close the page if open
-     */
-    private closePage;
 }
-//# sourceMappingURL=video-manager.d.ts.map

package/dist/notebook-creation/video-manager.js

@@ -16,29 +16,32 @@
  */
 import { log } from "../utils/logger.js";
 import { randomDelay } from "../utils/stealth-utils.js";
-export class VideoManager {
-    authManager;
-    contextManager;
-    page = null;
-    constructor(authManager, contextManager) {
-        this.authManager = authManager;
-        this.contextManager = contextManager;
-    }
-    /**
-     * Navigate to a notebook and ensure we're on the right page
-     */
-    async navigateToNotebook(notebookUrl) {
-        const context = await this.contextManager.getOrCreateContext();
-        const isAuth = await this.authManager.validateWithRetry(context);
-        if (!isAuth) {
-            throw new Error("Not authenticated. Run setup_auth first.");
-        }
-        this.page = await context.newPage();
-        await this.page.goto(notebookUrl, { waitUntil: "domcontentloaded" });
-        await this.page.waitForLoadState("networkidle").catch(() => { });
-        await randomDelay(2000, 3000);
-        return this.page;
-    }
+import { StudioManagerBase, } from "./studio-manager-base.js";
+/**
+ * Allowlisted style values. Single source of truth used to validate untrusted
+ * input before it is passed into the page context (prevents attribute-selector
+ * injection in selectStyle).
+ */
+const VALID_VIDEO_STYLES = [
+    "auto-select",
+    "custom",
+    "classic",
+    "whiteboard",
+    "kawaii",
+    "anime",
+    "watercolour",
+    "retro-print",
+    "heritage",
+    "paper-craft",
+];
+/**
+ * Allowlisted format values. Single source of truth used to validate untrusted
+ * input before it is passed into the page context (prevents attribute-selector
+ * injection in selectFormat).
+ */
+const VALID_VIDEO_FORMATS = ["explainer", "brief"];
+export class VideoManager extends StudioManagerBase {
+    logName = "video-manager";
     /**
      * Ensure the Studio panel is visible (expand if collapsed).
      *
@@ -117,6 +120,18 @@ export class VideoManager {
                     item.classList?.contains("shimmer-green")) {
                     return { status: "generating", progress: 0 };
                 }
+                // Detect an explicit failure state on THIS artifact before assuming ready.
+                // A failed generation leaves a non-shimmer artifact, which would otherwise be
+                // misreported as "ready". Scope the check to the matched item only — a page-global
+                // alert query could match unrelated UI. Class names are best-effort (unconfirmed
+                // by live inspection); [role="alert"]/error child is the locale-independent signal.
+                const hasErrorChild = !!item.querySelector('[role="alert"], .error-state, .artifact-error');
+                if (hasErrorChild ||
+                    item.classList?.contains("error-state") ||
+                    item.classList?.contains("artifact-error") ||
+                    item.classList?.contains("failed")) {
+                    return { status: "failed" };
+                }
                 // Otherwise it's ready
                 return { status: "ready" };
             }
@@ -181,17 +196,28 @@ export class VideoManager {
      * Select a video format in the dialog (Explainer or Brief)
      */
     async selectFormat(page, format) {
+        // Validate against the allowlist BEFORE the value crosses into the page
+        // context. Without this, a value containing `"]` could break out of the
+        // attribute selector below (selector injection).
+        if (!VALID_VIDEO_FORMATS.includes(format)) {
+            log.warning(`video-manager: ignoring non-allowlisted format "${format}"`);
+            return false;
+        }
         return await page.evaluate((fmt) => {
             const browser = globalThis;
             // Format is in mat-radio-group.tile-group
             const radioGroup = browser.document.querySelector("mat-radio-group.tile-group");
             if (!radioGroup)
                 return false;
-            // Primary: value attribute (locale-independent if Angular Material uses stable values)
-            const byValue = radioGroup.querySelector(`[value="${fmt}"]`);
-            if (byValue) {
-                byValue.click();
-                return true;
+            // Primary: value attribute (locale-independent if Angular Material uses stable values).
+            // Iterate radio options and compare values with === rather than building a
+            // selector from the value, so untrusted text can never alter the selector.
+            const options = Array.from(radioGroup.querySelectorAll("[value]"));
+            for (const option of options) {
+                if (option.getAttribute?.("value") === fmt) {
+                    option.click();
+                    return true;
+                }
             }
             // Fallback: text match (English only — may not work in non-English locales,
             // but selectFormat is best-effort; generation will use default format if this fails)
@@ -210,17 +236,28 @@ export class VideoManager {
      * Select a video style in the dialog carousel
      */
     async selectStyle(page, style) {
+        // Validate against the allowlist BEFORE the value crosses into the page
+        // context. Without this, a value containing `"]` could break out of the
+        // attribute selector below (selector injection).
+        if (!VALID_VIDEO_STYLES.includes(style)) {
+            log.warning(`video-manager: ignoring non-allowlisted style "${style}"`);
+            return false;
+        }
         return await page.evaluate((styleName) => {
             const browser = globalThis;
             // Style is in mat-radio-group.carousel-group
             const radioGroup = browser.document.querySelector("mat-radio-group.carousel-group");
             if (!radioGroup)
                 return false;
-            // Primary: value attribute (locale-independent)
-            const byValue = radioGroup.querySelector(`[value="${styleName}"]`);
-            if (byValue) {
-                byValue.click();
-                return true;
+            // Primary: value attribute (locale-independent).
+            // Iterate radio options and compare values with === rather than building a
+            // selector from the value, so untrusted text can never alter the selector.
+            const options = Array.from(radioGroup.querySelectorAll("[value]"));
+            for (const option of options) {
+                if (option.getAttribute?.("value") === styleName) {
+                    option.click();
+                    return true;
+                }
             }
             // Fallback: text match (English only — style labels are translated in non-English UIs,
             // but selectStyle is best-effort; generation will use default style if this fails)
@@ -243,14 +280,26 @@ export class VideoManager {
     async clickDialogGenerate(page) {
         return await page.evaluate(() => {
             const browser = globalThis;
-            // Primary: button in mat-dialog-actions
+            // Primary: the primary-color action button inside mat-dialog-actions.
+            // NEVER blindly click the FIRST button — Material dialogs conventionally place
+            // Cancel/Close first and the primary action last, so clicking [0] can hit Cancel
+            // and silently abort generation. Match the primary-color class/attribute first,
+            // then fall back to the LAST enabled button within the actions container.
             const dialogActions = browser.document.querySelector("mat-dialog-actions");
             if (dialogActions) {
-                const btn = dialogActions.querySelector("button");
-                if (btn) {
-                    btn.click();
+                const primaryInActions = dialogActions.querySelector('button.button-color--primary, button[color="primary"]');
+                if (primaryInActions) {
+                    primaryInActions.click();
                     return true;
                 }
+                const actionButtons = Array.from(dialogActions.querySelectorAll("button"));
+                for (let i = actionButtons.length - 1; i >= 0; i--) {
+                    const button = actionButtons[i];
+                    if (!button.disabled) {
+                        button.click();
+                        return true;
+                    }
+                }
             }
             // Fallback: button with primary color in any dialog
             const primaryBtn = browser.document.querySelector('.dialog-actions button, button.button-color--primary');
@@ -341,6 +390,14 @@ export class VideoManager {
             await randomDelay(500, 800);
             // Check if generation started
             const newStatus = await this.checkVideoStatusInternal(page);
+            if (newStatus.status === "failed") {
+                log.warning("  Video generation reported a failed state");
+                return {
+                    success: false,
+                    status: newStatus,
+                    error: "Video generation failed.",
+                };
+            }
             if (newStatus.status === "generating" || newStatus.status === "ready") {
                 log.success(`  Video generation ${newStatus.status === "ready" ? "completed" : "started"}`);
                 return { success: true, status: newStatus };
@@ -372,20 +429,4 @@ export class VideoManager {
             await this.closePage();
         }
     }
-    /**
-     * Close the page if open
-     */
-    async closePage() {
-        if (this.page) {
-            try {
-                await this.page.close();
-            }
-            catch (err) {
-                log.debug(`video-manager: closing page: ${err instanceof Error ? err.message : String(err)}`);
-                // Ignore close errors
-            }
-            this.page = null;
-        }
-    }
 }
-//# sourceMappingURL=video-manager.js.map

package/dist/observability/metrics.d.ts

@@ -16,4 +16,3 @@ export declare class MetricsRegistry {
     reset(): void;
 }
 export declare function getMetricsRegistry(): MetricsRegistry;
-//# sourceMappingURL=metrics.d.ts.map

package/dist/observability/metrics.js

@@ -32,4 +32,3 @@ const metrics = new MetricsRegistry();
 export function getMetricsRegistry() {
     return metrics;
 }
-//# sourceMappingURL=metrics.js.map

package/dist/quota/index.d.ts

@@ -5,4 +5,3 @@
  * usage tracking, and limit enforcement.
  */
 export { QuotaManager, getQuotaManager, type LicenseTier, type QuotaLimits, type QuotaUsage, type QuotaSettings, } from "./quota-manager.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/quota/index.js

@@ -5,4 +5,3 @@
  * usage tracking, and limit enforcement.
  */
 export { QuotaManager, getQuotaManager, } from "./quota-manager.js";
-//# sourceMappingURL=index.js.map