@pan-sec/notebooklm-mcp 2026.3.2 → 2026.4.0

package/dist/notebook-creation/notebook-creator.js

@@ -83,6 +83,17 @@ export class NotebookCreator {
                 }
                 await randomDelay(1000, 2000);
             }
+            // Fail-safe: if sources were requested but NONE actually succeeded, the
+            // notebook is empty and useless. Discard it (best-effort delete to avoid
+            // burning quota) and throw so the caller never persists a library entry
+            // or counts a successful creation for it. An empty `sources` array (e.g.
+            // an overflow shell notebook) is a legitimate zero-success case and is
+            // left untouched.
+            if (sources.length > 0 && successCount === 0) {
+                log.error(`❌ Notebook creation failed: no sources could be added (${notebookId})`);
+                await this.deleteEmptyNotebook();
+                throw new Error("Notebook creation failed: no sources could be added; empty notebook was discarded");
+            }
             currentStep++;
             await sendProgress?.("Finalizing notebook...", currentStep, totalSteps);
             const notebookUrl = await this.navigation.finalizeAndGetUrl();
@@ -103,9 +114,47 @@ export class NotebookCreator {
             await this.navigation.cleanup();
         }
     }
+    /**
+     * Best-effort deletion of a freshly-created but empty notebook (no sources
+     * added). Opens the notebook's overflow/options menu and confirms delete.
+     *
+     * Failure to delete is logged but not rethrown: the caller is already
+     * reporting the creation as failed, so we must not mask that with a
+     * secondary error.
+     */
+    async deleteEmptyNotebook() {
+        const page = this.navigation.getCurrentPage();
+        if (!page) {
+            log.debug("notebook creator: no page available to delete empty notebook");
+            return;
+        }
+        try {
+            const menuButton = page
+                .locator('button[aria-label*="more" i], button[aria-label*="options" i], button[aria-label*="settings" i]')
+                .first();
+            await menuButton.click({ timeout: 5000 });
+            await randomDelay(500, 1000);
+            const deleteOption = page
+                .locator('button:has-text("Delete"), [role="menuitem"]:has-text("Delete")')
+                .first();
+            await deleteOption.click({ timeout: 5000 });
+            await randomDelay(500, 1000);
+            // Confirm in any follow-up dialog.
+            const confirmButton = page
+                .locator('button:has-text("Delete"), button:has-text("Confirm")')
+                .last();
+            if ((await confirmButton.count()) > 0) {
+                await confirmButton.click({ timeout: 5000 });
+                await randomDelay(500, 1000);
+            }
+            log.info("🗑️  Discarded empty notebook (no sources added)");
+        }
+        catch (error) {
+            log.warning(`⚠️ Could not delete empty notebook: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
 }
 export async function createNotebook(authManager, contextManager, options) {
     const creator = new NotebookCreator(authManager, contextManager);
     return creator.createNotebook(options);
 }
-//# sourceMappingURL=notebook-creator.js.map

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

@@ -16,4 +16,3 @@ export declare class NotebookNavigation {
     safePageUrl(page: Page): string;
     cleanup(): Promise<void>;
 }
-//# sourceMappingURL=notebook-nav.d.ts.map

package/dist/notebook-creation/notebook-nav.js

@@ -29,7 +29,16 @@ export class NotebookNavigation {
     }
     async initialize(headless) {
         log.info("🌐 Initializing browser for notebook creation...");
-        const context = await this.contextManager.getOrCreateContext(headless === false ? true : undefined);
+        // Map the caller's headless intent to getOrCreateContext's explicit
+        // "show browser" contract (its argument is true = show/visible,
+        // false = headless, undefined = defer to CONFIG.headless).
+        //   - headless === false  -> the caller explicitly wants a VISIBLE browser
+        //                            -> showBrowser = true
+        //   - headless === true / undefined -> no explicit visible request; defer
+        //                            to the configured default
+        //                            -> showBrowser = undefined
+        const showBrowser = headless === false ? true : undefined;
+        const context = await this.contextManager.getOrCreateContext(showBrowser);
         const isAuthenticated = await this.authManager.validateWithRetry(context);
         if (!isAuthenticated) {
             throw new Error("Not authenticated to NotebookLM. Please run setup_auth first.");
@@ -89,16 +98,23 @@ export class NotebookNavigation {
                 log.debug(`notebook-nav: clicking 'New notebook' button selector: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
-        const textPatterns = ["New notebook", "Create notebook", "Create new", "New"];
+        // Specific, multi-word labels only. The previous last-ditch pattern was the
+        // bare word "New", which an includes()-match happily found inside unrelated
+        // controls like "New chat" or "New label" — clicking the wrong button. Match
+        // only full, unambiguous create-notebook labels.
+        const textPatterns = ["New notebook", "Create notebook", "Create new notebook"];
         for (const pattern of textPatterns) {
             try {
                 const clicked = await this.page.evaluate((searchText) => {
                     const browser = globalThis;
+                    const needle = searchText.toLowerCase();
                     const elements = browser.document.querySelectorAll('button, a, [role="button"]');
                     for (const el of elements) {
-                        const elText = el.textContent?.toLowerCase() || "";
-                        const ariaLabel = el.getAttribute("aria-label")?.toLowerCase() || "";
-                        if (elText.includes(searchText.toLowerCase()) || ariaLabel.includes(searchText.toLowerCase())) {
+                        const elText = (el.textContent || "").trim().toLowerCase();
+                        const ariaLabel = (el.getAttribute("aria-label") || "").trim().toLowerCase();
+                        // Exact label match only — never a loose substring — so we cannot
+                        // latch onto "New chat" / "New label" etc.
+                        if (elText === needle || ariaLabel === needle) {
                             el.click();
                             return true;
                         }
@@ -237,4 +253,3 @@ export class NotebookNavigation {
         }
     }
 }
-//# sourceMappingURL=notebook-nav.js.map

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

@@ -26,6 +26,13 @@ export interface SyncResult {
         libraryName: string;
         libraryUrl: string;
         reason: string;
+        /**
+         * Whether this entry is SAFE to auto-remove. Only true when we have an
+         * exact, UUID-based confirmation that the notebook no longer exists. Entries
+         * that merely failed a fuzzy title match are reported as stale (for the
+         * human to review) but are NOT eligible for destructive auto-fix.
+         */
+        autoFixSafe: boolean;
     }>;
     missingNotebooks: ActualNotebook[];
     suggestions: string[];
@@ -84,7 +91,13 @@ export declare class NotebookSync {
      */
     private titlesMatch;
     /**
-     * Extract notebook ID from URL
+     * Extract a STABLE notebook UUID from a URL, or null if none can be derived.
+     *
+     * Returns null for "pending-*" placeholders and for any URL that does not
+     * carry a real /notebook/UUID segment. A null id must NEVER be treated as a
+     * match key (two unknowns are not "equal") and must NEVER feed a destructive
+     * auto-fix decision — doing so previously let placeholder/garbage ids collide
+     * or let a missing id be (mis)matched and removed.
      */
     private extractNotebookId;
     /**
@@ -115,4 +128,3 @@ export declare function syncLibrary(authManager: AuthManager, contextManager: Sh
     autoFix?: boolean;
     showBrowser?: boolean;
 }): Promise<SyncResult>;
-//# sourceMappingURL=notebook-sync.d.ts.map

package/dist/notebook-creation/notebook-sync.js

@@ -289,10 +289,26 @@ export class NotebookSync {
             return [];
         // Click each row to capture the URL via navigation
         const notebooks = [];
-        const startUrl = this.page.url();
+        // Capture the library root URL ONCE, before any navigation. If the page is
+        // already sitting on a /notebook/ URL (left over from a prior step), the
+        // per-row waitForURL(/\/notebook\//) would resolve immediately against the
+        // pre-existing URL and mislabel every row with the wrong UUID. In that case
+        // navigate back to the library root first so clicks produce real
+        // navigations from a known-good base.
+        let startUrl = this.page.url();
+        if (/\/notebook\//.test(startUrl)) {
+            log.warning("  ⚠️ Not on library root before row scrape — returning to library");
+            await this.page.goto(NOTEBOOKLM_URL, { waitUntil: "domcontentloaded", timeout: CONFIG.browserTimeout });
+            await this.page.waitForLoadState("networkidle").catch(() => { });
+            await randomDelay(1500, 2000);
+            startUrl = this.page.url();
+        }
         for (let i = 0; i < rowData.length; i++) {
             const row = rowData[i];
             try {
+                // Record the URL immediately before the click so we can confirm that a
+                // REAL navigation occurred (and not accept a pre-existing notebook URL).
+                const urlBeforeClick = this.page.url();
                 // Click the data row by index (skip non-data rows in evaluate)
                 await this.page.evaluate((clickIdx) => {
                     const browser = globalThis;
@@ -305,22 +321,32 @@ export class NotebookSync {
                     }
                     dataRows[clickIdx]?.click();
                 }, i);
-                // Wait for navigation to complete
-                await this.page.waitForURL(/\/notebook\//, { timeout: 10000 }).catch(() => { });
+                // Wait for the URL to actually CHANGE to a new /notebook/ page. Using a
+                // predicate (rather than a bare /\/notebook\// regex) prevents resolving
+                // immediately against a pre-existing notebook URL and capturing a stale
+                // UUID for this row.
+                await this.page
+                    .waitForURL((u) => /\/notebook\//.test(u.toString()) && u.toString() !== urlBeforeClick, { timeout: 10000 })
+                    .catch(() => { });
                 await randomDelay(500, 1000);
-                // Capture the URL
+                // Capture the URL — only trust a UUID when a real navigation to a NEW
+                // notebook actually happened.
                 const currentUrl = this.page.url();
                 const notebookMatch = currentUrl.match(/\/notebook\/([a-f0-9-]+)/i);
-                const url = notebookMatch
+                const navigated = currentUrl !== urlBeforeClick && notebookMatch !== null;
+                const url = navigated
                     ? `https://notebooklm.google.com/notebook/${notebookMatch[1]}`
                     : `pending-nav-${notebooks.length}`;
+                if (!navigated) {
+                    log.warning(`  ⚠️ Row click did not navigate to a new notebook: ${row.title}`);
+                }
                 notebooks.push({
                     title: row.title,
                     url,
                     sourceCount: row.sourceCount,
                     createdDate: row.createdDate,
                 });
-                // Navigate back
+                // Navigate back to the library root
                 await this.page.goto(startUrl, { waitUntil: "domcontentloaded", timeout: CONFIG.browserTimeout });
                 await this.page.waitForLoadState("networkidle").catch(() => { });
                 await randomDelay(1500, 2000);
@@ -404,65 +430,108 @@ export class NotebookSync {
         const matched = [];
         const staleEntries = [];
         const suggestions = [];
+        // Is the extraction trustworthy enough to treat "UUID absent from this list"
+        // as positive proof of deletion? Only if we actually saw notebooks AND every
+        // one of them yielded a real UUID. An empty list usually means extraction
+        // failed (page didn't load / strategy missed) — NOT that the account is
+        // empty — and a "pending-*" entry could BE the very notebook we're checking,
+        // so "absent" is not a confirmation. Without this guard a failed scrape would
+        // mark every valid library entry as "confirmed deleted" and autoFix would
+        // wipe the whole library. This is the core data-loss M33 must prevent.
+        const extractionIsAuthoritative = actualNotebooks.length > 0 &&
+            actualNotebooks.every((n) => this.extractNotebookId(n.url) !== null);
         // Track which actual notebooks are matched
         const matchedActualIndices = new Set();
+        // Actual notebooks tied to a library entry by a FUZZY (unconfirmed) title
+        // match. They are not authoritative matches, but we must not auto-ADD them
+        // as "missing" either — that would create a duplicate library entry for a
+        // notebook the human still needs to reconcile. Excluded from auto-add only.
+        const fuzzyReservedIndices = new Set();
         // Check each library entry
         for (const entry of libraryEntries) {
-            // Extract notebook ID from URL
+            // Extract notebook ID from URL (null = pending/garbage, never a match key)
             const libraryNotebookId = this.extractNotebookId(entry.url);
-            // Try to find matching actual notebook
-            let matchingActualIndex = -1;
-            // First try: match by URL/ID
-            for (let i = 0; i < actualNotebooks.length; i++) {
-                const actual = actualNotebooks[i];
-                const actualNotebookId = this.extractNotebookId(actual.url);
-                if (actualNotebookId === libraryNotebookId && !actual.url.startsWith("pending-")) {
-                    matchingActualIndex = i;
-                    break;
+            // First try: EXACT UUID match. This is the only authoritative identity —
+            // and the only signal allowed to drive a destructive auto-fix.
+            let exactMatchIndex = -1;
+            if (libraryNotebookId !== null) {
+                for (let i = 0; i < actualNotebooks.length; i++) {
+                    const actualNotebookId = this.extractNotebookId(actualNotebooks[i].url);
+                    if (actualNotebookId !== null && actualNotebookId === libraryNotebookId) {
+                        exactMatchIndex = i;
+                        break;
+                    }
                 }
             }
-            // Second try: match by title similarity (fuzzy match)
-            if (matchingActualIndex < 0) {
+            // Second try: fuzzy title match. This is a SUGGESTION ONLY. A 60% word
+            // overlap can match the wrong notebook ("Security Notes 2025" vs "...2026"),
+            // so a fuzzy hit must never be fed into removal/relabel — it only avoids
+            // proposing deletion of an entry we can plausibly still see.
+            let fuzzyMatchIndex = -1;
+            if (exactMatchIndex < 0) {
                 const normalizedEntryName = this.normalizeTitle(entry.name);
                 for (let i = 0; i < actualNotebooks.length; i++) {
                     if (matchedActualIndices.has(i))
                         continue; // Already matched
-                    const actual = actualNotebooks[i];
-                    const normalizedActualTitle = this.normalizeTitle(actual.title);
-                    // Check for significant overlap
+                    const normalizedActualTitle = this.normalizeTitle(actualNotebooks[i].title);
                     if (this.titlesMatch(normalizedEntryName, normalizedActualTitle)) {
-                        matchingActualIndex = i;
+                        fuzzyMatchIndex = i;
                         break;
                     }
                 }
             }
-            if (matchingActualIndex >= 0) {
-                const matchingActual = actualNotebooks[matchingActualIndex];
+            if (exactMatchIndex >= 0) {
+                const matchingActual = actualNotebooks[exactMatchIndex];
                 matched.push({
                     libraryId: entry.id,
                     libraryName: entry.name,
                     actualTitle: matchingActual.title,
                     actualUrl: matchingActual.url,
                 });
-                matchedActualIndices.add(matchingActualIndex);
-                // Check if name differs significantly
+                matchedActualIndices.add(exactMatchIndex);
+                // Title drift on a UUID-confirmed match is safe to suggest relabelling.
                 const cleanActualTitle = this.normalizeTitle(matchingActual.title);
                 const cleanEntryName = this.normalizeTitle(entry.name);
                 if (cleanEntryName !== cleanActualTitle) {
                     suggestions.push(`📝 "${entry.name}" matches "${matchingActual.title}" (consider updating library entry)`);
                 }
             }
+            else if (fuzzyMatchIndex >= 0) {
+                // Fuzzy hit: report as a SUGGESTION only. Do not consume the actual
+                // notebook (leave it as "missing" so the human sees both sides) and do
+                // NOT mark the library entry as auto-removable.
+                const fuzzyActual = actualNotebooks[fuzzyMatchIndex];
+                fuzzyReservedIndices.add(fuzzyMatchIndex);
+                suggestions.push(`❓ "${entry.name}" may correspond to "${fuzzyActual.title}" (fuzzy title match — verify manually; not auto-applied)`);
+                staleEntries.push({
+                    libraryId: entry.id,
+                    libraryName: entry.name,
+                    libraryUrl: entry.url,
+                    reason: "No exact UUID match; only a fuzzy title match was found (review manually)",
+                    autoFixSafe: false,
+                });
+            }
             else {
+                // No exact and no fuzzy match. Only safe to auto-remove when we could
+                // actually derive a real UUID for this entry AND positively confirmed it
+                // is absent. If the entry's own URL has no parseable UUID (pending/
+                // garbage), we cannot prove the notebook is gone — never auto-delete it.
                 staleEntries.push({
                     libraryId: entry.id,
                     libraryName: entry.name,
                     libraryUrl: entry.url,
-                    reason: "Notebook not found in NotebookLM (may be deleted or URL changed)",
+                    reason: libraryNotebookId === null
+                        ? "Entry has no resolvable notebook UUID (cannot confirm deletion — review manually)"
+                        : !extractionIsAuthoritative
+                            ? "Notebook not found, but extraction was incomplete (empty or pending results) — cannot confirm deletion; review manually"
+                            : "Notebook UUID not present in NotebookLM (confirmed deleted or moved)",
+                    autoFixSafe: libraryNotebookId !== null && extractionIsAuthoritative,
                 });
             }
         }
-        // Find notebooks not in library
-        const missingNotebooks = actualNotebooks.filter((_, index) => !matchedActualIndices.has(index));
+        // Find notebooks not in library. Exclude fuzzy-reserved actuals so we don't
+        // auto-add a duplicate of a notebook a stale entry probably already denotes.
+        const missingNotebooks = actualNotebooks.filter((_, index) => !matchedActualIndices.has(index) && !fuzzyReservedIndices.has(index));
         // Generate suggestions
         if (staleEntries.length > 0) {
             suggestions.unshift(`🗑️  ${staleEntries.length} stale library entries should be removed`);
@@ -484,8 +553,13 @@ export class NotebookSync {
     normalizeTitle(title) {
         return title
             .toLowerCase()
-            .replace(/[🔓🔒📁📄🔐⚛️🧠🛡️💻📋]/g, "") // Remove emojis
-            .replace(/[\u{1F300}-\u{1F9FF}]/gu, "") // Remove other emojis
+            // Remove emoji across all Unicode ranges (flags, symbols, supplemental
+            // pictographs, etc.) plus the zero-width-joiner and variation selectors
+            // used to compose emoji sequences. A hardcoded set / narrow range missed
+            // common emoji and made otherwise-equal titles normalize differently,
+            // producing false "stale" mismatches.
+            .replace(/\p{Extended_Pictographic}/gu, "")
+            .replace(/[\u{200D}\u{FE0E}\u{FE0F}\u{1F3FB}-\u{1F3FF}]/gu, "") // ZWJ, variation selectors, skin-tone modifiers
             .replace(/[^\w\s]/g, " ") // Remove punctuation
             .replace(/\s+/g, " ") // Normalize whitespace
             .trim();
@@ -511,12 +585,21 @@ export class NotebookSync {
         return overlapRatio >= 0.6;
     }
     /**
-     * Extract notebook ID from URL
+     * Extract a STABLE notebook UUID from a URL, or null if none can be derived.
+     *
+     * Returns null for "pending-*" placeholders and for any URL that does not
+     * carry a real /notebook/UUID segment. A null id must NEVER be treated as a
+     * match key (two unknowns are not "equal") and must NEVER feed a destructive
+     * auto-fix decision — doing so previously let placeholder/garbage ids collide
+     * or let a missing id be (mis)matched and removed.
      */
     extractNotebookId(url) {
+        if (!url || url.startsWith("pending-"))
+            return null;
         // URL format: https://notebooklm.google.com/notebook/UUID?authuser=X
-        const match = url.match(/\/notebook\/([a-f0-9-]+)/i);
-        return match ? match[1] : url;
+        // Require a canonical UUID so a partial/garbage id can't be matched.
+        const match = url.match(/\/notebook\/([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})/i);
+        return match ? match[1].toLowerCase() : null;
     }
     /**
      * Auto-fix stale entries by removing them
@@ -524,6 +607,13 @@ export class NotebookSync {
     async autoFixStaleEntries(staleEntries) {
         log.info("🔧 Auto-fixing stale entries...");
         for (const entry of staleEntries) {
+            // DESTRUCTIVE GUARD: only remove entries we could confirm as deleted via
+            // an exact UUID. Fuzzy/unresolvable entries are left for manual review so
+            // a valid library entry is never destroyed on a 60%-title-overlap guess.
+            if (!entry.autoFixSafe) {
+                log.warning(`⏭️  Skipping auto-remove of "${entry.libraryName}" — ${entry.reason}`);
+                continue;
+            }
             try {
                 this.library.removeNotebook(entry.libraryId);
                 log.success(`✅ Removed stale entry: ${entry.libraryName}`);
@@ -623,4 +713,3 @@ export async function syncLibrary(authManager, contextManager, library, options)
     const sync = new NotebookSync(authManager, contextManager, library);
     return await sync.syncLibrary(options);
 }
-//# sourceMappingURL=notebook-sync.js.map

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

@@ -138,4 +138,3 @@ export type SelectorKey = keyof typeof NOTEBOOKLM_SELECTORS;
  * Get all selectors for a key (primary + fallbacks)
  */
 export declare function getSelectors(key: SelectorKey): string[];
-//# sourceMappingURL=selectors.d.ts.map

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.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/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

@@ -98,4 +98,3 @@ export declare class VideoManager {
      */
     private closePage;
 }
-//# sourceMappingURL=video-manager.d.ts.map