notebooklm-sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2390 @@
+'use strict';
+
+var fs = require('fs');
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/types/errors.ts
+exports.NotebookLMError = void 0; exports.NetworkError = void 0; exports.RPCTimeoutError = void 0; exports.RPCError = void 0; exports.AuthError = void 0; exports.RateLimitError = void 0; exports.ServerError = void 0; exports.ClientError = void 0; exports.NotebookError = void 0; exports.NotebookNotFoundError = void 0; exports.SourceError = void 0; exports.SourceNotFoundError = void 0; exports.SourceAddError = void 0; exports.SourceProcessingError = void 0; exports.SourceTimeoutError = void 0; exports.ArtifactError = void 0; exports.ArtifactNotFoundError = void 0; exports.ArtifactNotReadyError = void 0; exports.ArtifactParseError = void 0; exports.ArtifactDownloadError = void 0; exports.ChatError = void 0;
+var init_errors = __esm({
+  "src/types/errors.ts"() {
+    exports.NotebookLMError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+      }
+    };
+    exports.NetworkError = class extends exports.NotebookLMError {
+      methodId;
+      originalError;
+      constructor(message, opts = {}) {
+        super(message);
+        this.methodId = opts.methodId;
+        this.originalError = opts.originalError;
+      }
+    };
+    exports.RPCTimeoutError = class extends exports.NetworkError {
+    };
+    exports.RPCError = class extends exports.NotebookLMError {
+      methodId;
+      rawResponse;
+      rpcCode;
+      foundIds;
+      constructor(message, opts = {}) {
+        super(message);
+        this.methodId = opts.methodId;
+        this.rawResponse = opts.rawResponse ? opts.rawResponse.slice(0, 500) : void 0;
+        this.rpcCode = opts.rpcCode;
+        this.foundIds = opts.foundIds ?? [];
+      }
+    };
+    exports.AuthError = class extends exports.RPCError {
+    };
+    exports.RateLimitError = class extends exports.RPCError {
+      retryAfter;
+      constructor(message, opts = {}) {
+        super(message, opts);
+        this.retryAfter = opts.retryAfter;
+      }
+    };
+    exports.ServerError = class extends exports.RPCError {
+      statusCode;
+      constructor(message, opts = {}) {
+        super(message, opts);
+        this.statusCode = opts.statusCode;
+      }
+    };
+    exports.ClientError = class extends exports.RPCError {
+      statusCode;
+      constructor(message, opts = {}) {
+        super(message, opts);
+        this.statusCode = opts.statusCode;
+      }
+    };
+    exports.NotebookError = class extends exports.NotebookLMError {
+    };
+    exports.NotebookNotFoundError = class extends exports.NotebookError {
+      notebookId;
+      constructor(notebookId) {
+        super(`Notebook not found: ${notebookId}`);
+        this.notebookId = notebookId;
+      }
+    };
+    exports.SourceError = class extends exports.NotebookLMError {
+    };
+    exports.SourceNotFoundError = class extends exports.SourceError {
+      sourceId;
+      constructor(sourceId) {
+        super(`Source not found: ${sourceId}`);
+        this.sourceId = sourceId;
+      }
+    };
+    exports.SourceAddError = class extends exports.SourceError {
+      url;
+      cause;
+      constructor(url, opts = {}) {
+        super(
+          opts.message ?? `Failed to add source: ${url}
+Possible causes:
+  - URL is invalid or inaccessible
+  - Content is behind a paywall or requires authentication
+  - Rate limiting or quota exceeded`
+        );
+        this.url = url;
+        this.cause = opts.cause;
+      }
+    };
+    exports.SourceProcessingError = class extends exports.SourceError {
+      sourceId;
+      status;
+      constructor(sourceId, status = 3, message) {
+        super(message ?? `Source ${sourceId} failed to process`);
+        this.sourceId = sourceId;
+        this.status = status;
+      }
+    };
+    exports.SourceTimeoutError = class extends exports.SourceError {
+      sourceId;
+      timeout;
+      lastStatus;
+      constructor(sourceId, timeout, lastStatus) {
+        const statusInfo = lastStatus != null ? ` (last status: ${lastStatus})` : "";
+        super(`Source ${sourceId} not ready after ${timeout.toFixed(1)}s${statusInfo}`);
+        this.sourceId = sourceId;
+        this.timeout = timeout;
+        this.lastStatus = lastStatus;
+      }
+    };
+    exports.ArtifactError = class extends exports.NotebookLMError {
+    };
+    exports.ArtifactNotFoundError = class extends exports.ArtifactError {
+      artifactId;
+      artifactType;
+      constructor(artifactId, artifactType) {
+        const typeInfo = artifactType ? ` ${artifactType}` : "";
+        super(`${typeInfo.trim() || "Artifact"} ${artifactId} not found`);
+        this.artifactId = artifactId;
+        this.artifactType = artifactType;
+      }
+    };
+    exports.ArtifactNotReadyError = class extends exports.ArtifactError {
+      artifactType;
+      artifactId;
+      status;
+      constructor(artifactType, opts = {}) {
+        const base = opts.artifactId ? `${artifactType} artifact ${opts.artifactId} is not ready` : `No completed ${artifactType} found`;
+        const statusInfo = opts.status ? ` (status: ${opts.status})` : "";
+        super(`${base}${statusInfo}`);
+        this.artifactType = artifactType;
+        this.artifactId = opts.artifactId;
+        this.status = opts.status;
+      }
+    };
+    exports.ArtifactParseError = class extends exports.ArtifactError {
+      artifactType;
+      artifactId;
+      details;
+      cause;
+      constructor(artifactType, opts = {}) {
+        let msg = `Failed to parse ${artifactType} artifact`;
+        if (opts.artifactId) msg += ` ${opts.artifactId}`;
+        if (opts.details) msg += `: ${opts.details}`;
+        super(msg);
+        this.artifactType = artifactType;
+        this.artifactId = opts.artifactId;
+        this.details = opts.details;
+        this.cause = opts.cause;
+      }
+    };
+    exports.ArtifactDownloadError = class extends exports.ArtifactError {
+      artifactType;
+      artifactId;
+      details;
+      cause;
+      constructor(artifactType, opts = {}) {
+        let msg = `Failed to download ${artifactType} artifact`;
+        if (opts.artifactId) msg += ` ${opts.artifactId}`;
+        if (opts.details) msg += `: ${opts.details}`;
+        super(msg);
+        this.artifactType = artifactType;
+        this.artifactId = opts.artifactId;
+        this.details = opts.details;
+        this.cause = opts.cause;
+      }
+    };
+    exports.ChatError = class extends exports.NotebookLMError {
+    };
+  }
+});
+
+// src/auth.ts
+var auth_exports = {};
+__export(auth_exports, {
+  buildCookieHeader: () => buildCookieHeader,
+  buildGoogleCookieHeader: () => buildGoogleCookieHeader,
+  connect: () => connect,
+  fetchTokens: () => fetchTokens,
+  loadCookiesFromFile: () => loadCookiesFromFile,
+  loadCookiesFromMap: () => loadCookiesFromMap,
+  loadCookiesFromObject: () => loadCookiesFromObject,
+  loadCookiesFromString: () => loadCookiesFromString
+});
+function loadCookiesFromFile(filePath) {
+  let raw;
+  try {
+    raw = fs.readFileSync(filePath, "utf-8");
+  } catch {
+    throw new exports.AuthError(
+      `Cookie file not found: ${filePath}
+Provide valid Playwright storage state JSON.`
+    );
+  }
+  return extractCookiesFromStorageState(JSON.parse(raw));
+}
+function loadCookiesFromObject(storageState) {
+  return extractCookiesFromStorageState(storageState);
+}
+function buildGoogleCookieHeader(storageState) {
+  const map = {};
+  for (const c of storageState.cookies ?? []) {
+    if (c.domain === ".google.com" && c.name && c.value) {
+      map[c.name] = map[c.name] ?? c.value;
+    }
+  }
+  return buildCookieHeader(map);
+}
+function loadCookiesFromMap(map) {
+  return { ...map };
+}
+function loadCookiesFromString(cookieStr) {
+  const map = {};
+  for (const part of cookieStr.split(/;\s*/)) {
+    const idx = part.indexOf("=");
+    if (idx > 0) {
+      const name = part.slice(0, idx).trim();
+      const value = part.slice(idx + 1).trim();
+      if (name) map[name] = value;
+    }
+  }
+  return map;
+}
+function extractCookiesFromStorageState(storageState) {
+  const cookies = {};
+  for (const cookie of storageState.cookies ?? []) {
+    const { domain, name, value } = cookie;
+    if (!isAllowedDomain(domain) || !name) continue;
+    const isBase = domain === ".google.com";
+    if (!(name in cookies) || isBase) {
+      cookies[name] = value;
+    }
+  }
+  if (!cookies["SID"]) {
+    throw new exports.AuthError(
+      "Missing required cookie: SID. Provide valid Playwright storage state with Google cookies."
+    );
+  }
+  return cookies;
+}
+function isAllowedDomain(domain) {
+  if (domain === ".google.com" || domain === "notebooklm.google.com" || domain === ".googleusercontent.com") {
+    return true;
+  }
+  if (domain.startsWith(".google.")) {
+    return true;
+  }
+  return false;
+}
+function buildCookieHeader(cookies) {
+  return Object.entries(cookies).map(([k, v]) => `${k}=${v}`).join("; ");
+}
+async function fetchTokens(cookies) {
+  const cookieHeader = buildCookieHeader(cookies);
+  const response = await fetch(NOTEBOOKLM_URL, {
+    headers: { Cookie: cookieHeader },
+    redirect: "follow"
+  });
+  if (!response.ok) {
+    throw new exports.AuthError(`Failed to fetch NotebookLM page: HTTP ${response.status}`);
+  }
+  const finalUrl = response.url;
+  if (isGoogleAuthRedirect(finalUrl)) {
+    throw new exports.AuthError(`Redirected to login page: ${finalUrl}. Cookies may be expired.`);
+  }
+  const html = await response.text();
+  const csrfToken = extractCsrfToken(html, finalUrl);
+  const sessionId = extractSessionId(html, finalUrl);
+  return { csrfToken, sessionId };
+}
+function extractCsrfToken(html, finalUrl) {
+  const match = /"SNlM0e"\s*:\s*"([^"]+)"/.exec(html);
+  if (!match?.[1]) {
+    if (isGoogleAuthRedirect(finalUrl) || html.includes("accounts.google.com")) {
+      throw new exports.AuthError("Authentication expired or invalid. Cookies may need to be refreshed.");
+    }
+    throw new exports.AuthError("CSRF token (SNlM0e) not found in NotebookLM page HTML.");
+  }
+  return match[1];
+}
+function extractSessionId(html, finalUrl) {
+  const match = /"FdrFJe"\s*:\s*"([^"]+)"/.exec(html);
+  if (!match?.[1]) {
+    if (isGoogleAuthRedirect(finalUrl) || html.includes("accounts.google.com")) {
+      throw new exports.AuthError("Authentication expired or invalid. Cookies may need to be refreshed.");
+    }
+    throw new exports.AuthError("Session ID (FdrFJe) not found in NotebookLM page HTML.");
+  }
+  return match[1];
+}
+function isGoogleAuthRedirect(url) {
+  return url.includes("accounts.google.com") || url.includes("signin");
+}
+async function connect(opts) {
+  let cookieMap;
+  let googleCookieHeader = null;
+  if (opts.cookies) {
+    cookieMap = loadCookiesFromString(opts.cookies);
+  } else if (opts.cookiesFile) {
+    cookieMap = loadCookiesFromFile(opts.cookiesFile);
+  } else if (opts.cookiesObject) {
+    if ("cookies" in opts.cookiesObject && Array.isArray(opts.cookiesObject.cookies)) {
+      const storageState = opts.cookiesObject;
+      cookieMap = loadCookiesFromObject(storageState);
+      googleCookieHeader = buildGoogleCookieHeader(storageState);
+    } else {
+      cookieMap = loadCookiesFromMap(opts.cookiesObject);
+    }
+  } else {
+    const envCookies = process.env["NOTEBOOKLM_COOKIES"];
+    if (envCookies) {
+      cookieMap = loadCookiesFromString(envCookies);
+    } else {
+      throw new exports.AuthError(
+        "No cookies provided. Pass cookies, cookiesFile, or cookiesObject to connect()."
+      );
+    }
+  }
+  const { csrfToken, sessionId } = await fetchTokens(cookieMap);
+  const cookieHeader = buildCookieHeader(cookieMap);
+  return {
+    cookies: cookieMap,
+    csrfToken,
+    sessionId,
+    cookieHeader,
+    googleCookieHeader: googleCookieHeader ?? cookieHeader
+  };
+}
+var NOTEBOOKLM_URL;
+var init_auth = __esm({
+  "src/auth.ts"() {
+    init_errors();
+    NOTEBOOKLM_URL = "https://notebooklm.google.com/";
+  }
+});
+
+// src/types/enums.ts
+var enums_exports = {};
+__export(enums_exports, {
+  ArtifactStatusCode: () => ArtifactStatusCode,
+  ArtifactTypeCode: () => exports.ArtifactTypeCode,
+  AudioFormat: () => exports.AudioFormat,
+  AudioLength: () => exports.AudioLength,
+  ExportType: () => exports.ExportType,
+  InfographicDetail: () => exports.InfographicDetail,
+  InfographicOrientation: () => exports.InfographicOrientation,
+  InfographicStyle: () => exports.InfographicStyle,
+  QuizDifficulty: () => exports.QuizDifficulty,
+  QuizQuantity: () => exports.QuizQuantity,
+  RPCMethod: () => exports.RPCMethod,
+  ShareAccess: () => exports.ShareAccess,
+  SharePermission: () => exports.SharePermission,
+  ShareViewLevel: () => exports.ShareViewLevel,
+  SlideDeckFormat: () => exports.SlideDeckFormat,
+  SlideDeckLength: () => exports.SlideDeckLength,
+  SourceStatusCode: () => SourceStatusCode,
+  VideoFormat: () => exports.VideoFormat,
+  VideoStyle: () => exports.VideoStyle,
+  artifactStatusFromCode: () => artifactStatusFromCode,
+  artifactTypeFromCode: () => artifactTypeFromCode,
+  sourceStatusFromCode: () => sourceStatusFromCode,
+  sourceTypeFromCode: () => sourceTypeFromCode
+});
+function sourceTypeFromCode(code) {
+  if (code == null) return "unknown";
+  return SOURCE_TYPE_MAP[code] ?? "unknown";
+}
+function artifactTypeFromCode(typeCode, variant) {
+  if (typeCode === 4) {
+    if (variant === 1) return "flashcards";
+    if (variant === 2) return "quiz";
+    return "unknown";
+  }
+  return ARTIFACT_TYPE_MAP[typeCode] ?? "unknown";
+}
+function artifactStatusFromCode(code) {
+  return ARTIFACT_STATUS_MAP[code] ?? "unknown";
+}
+function sourceStatusFromCode(code) {
+  return SOURCE_STATUS_MAP[code] ?? "unknown";
+}
+exports.RPCMethod = void 0; exports.ArtifactTypeCode = void 0; var ArtifactStatusCode, SourceStatusCode; exports.AudioFormat = void 0; exports.AudioLength = void 0; exports.VideoFormat = void 0; exports.VideoStyle = void 0; exports.QuizQuantity = void 0; exports.QuizDifficulty = void 0; exports.InfographicOrientation = void 0; exports.InfographicDetail = void 0; exports.InfographicStyle = void 0; exports.SlideDeckFormat = void 0; exports.SlideDeckLength = void 0; exports.ExportType = void 0; var SOURCE_TYPE_MAP, ARTIFACT_TYPE_MAP, ARTIFACT_STATUS_MAP, SOURCE_STATUS_MAP; exports.ShareAccess = void 0; exports.ShareViewLevel = void 0; exports.SharePermission = void 0;
+var init_enums = __esm({
+  "src/types/enums.ts"() {
+    exports.RPCMethod = {
+      // Notebook
+      LIST_NOTEBOOKS: "wXbhsf",
+      CREATE_NOTEBOOK: "CCqFvf",
+      GET_NOTEBOOK: "rLM1Ne",
+      RENAME_NOTEBOOK: "s0tc2d",
+      DELETE_NOTEBOOK: "WWINqb",
+      // Sources
+      ADD_SOURCE: "izAoDd",
+      ADD_SOURCE_FILE: "o4cbdc",
+      DELETE_SOURCE: "tGMBJ",
+      GET_SOURCE: "hizoJc",
+      REFRESH_SOURCE: "FLmJqe",
+      CHECK_SOURCE_FRESHNESS: "yR9Yof",
+      UPDATE_SOURCE: "b7Wfje",
+      // Summary
+      SUMMARIZE: "VfAZjd",
+      GET_SOURCE_GUIDE: "tr032e",
+      GET_SUGGESTED_REPORTS: "ciyUvf",
+      // Artifacts
+      CREATE_ARTIFACT: "R7cb6c",
+      LIST_ARTIFACTS: "gArtLc",
+      DELETE_ARTIFACT: "V5N4be",
+      RENAME_ARTIFACT: "rc3d8d",
+      EXPORT_ARTIFACT: "Krh3pd",
+      SHARE_ARTIFACT: "RGP97b",
+      GET_INTERACTIVE_HTML: "v9rmvd",
+      REVISE_SLIDE: "KmcKPe",
+      // Research
+      START_FAST_RESEARCH: "Ljjv0c",
+      START_DEEP_RESEARCH: "QA9ei",
+      POLL_RESEARCH: "e3bVqc",
+      IMPORT_RESEARCH: "LBwxtb",
+      // Notes / Mind Maps
+      GENERATE_MIND_MAP: "yyryJe",
+      CREATE_NOTE: "CYK0Xb",
+      GET_NOTES_AND_MIND_MAPS: "cFji9",
+      UPDATE_NOTE: "cYAfTb",
+      DELETE_NOTE: "AH0mwd",
+      // Conversation
+      GET_LAST_CONVERSATION_ID: "hPTbtc",
+      GET_CONVERSATION_TURNS: "khqZz",
+      // Sharing
+      SHARE_NOTEBOOK: "QDyure",
+      GET_SHARE_STATUS: "JFMDGd",
+      // Misc
+      REMOVE_RECENTLY_VIEWED: "fejl7e",
+      GET_USER_SETTINGS: "ZwVcOc",
+      SET_USER_SETTINGS: "hT54vc"
+    };
+    exports.ArtifactTypeCode = {
+      AUDIO: 1,
+      REPORT: 2,
+      VIDEO: 3,
+      QUIZ: 4,
+      MIND_MAP: 5,
+      INFOGRAPHIC: 7,
+      SLIDE_DECK: 8,
+      DATA_TABLE: 9
+    };
+    ArtifactStatusCode = {
+      PROCESSING: 1,
+      PENDING: 2,
+      COMPLETED: 3,
+      FAILED: 4
+    };
+    SourceStatusCode = {
+      PROCESSING: 1,
+      READY: 2,
+      ERROR: 3,
+      PREPARING: 5
+    };
+    exports.AudioFormat = {
+      DEEP_DIVE: 1,
+      BRIEF: 2,
+      CRITIQUE: 3,
+      DEBATE: 4
+    };
+    exports.AudioLength = {
+      SHORT: 1,
+      DEFAULT: 2,
+      LONG: 3
+    };
+    exports.VideoFormat = {
+      EXPLAINER: 1,
+      BRIEF: 2,
+      CINEMATIC: 3
+    };
+    exports.VideoStyle = {
+      AUTO_SELECT: 1,
+      CUSTOM: 2,
+      CLASSIC: 3,
+      WHITEBOARD: 4,
+      KAWAII: 5,
+      ANIME: 6,
+      WATERCOLOR: 7,
+      RETRO_PRINT: 8,
+      HERITAGE: 9,
+      PAPER_CRAFT: 10
+    };
+    exports.QuizQuantity = {
+      FEWER: 1,
+      STANDARD: 2,
+      MORE: 2
+      // API limitation: same as STANDARD
+    };
+    exports.QuizDifficulty = {
+      EASY: 1,
+      MEDIUM: 2,
+      HARD: 3
+    };
+    exports.InfographicOrientation = {
+      LANDSCAPE: 1,
+      PORTRAIT: 2,
+      SQUARE: 3
+    };
+    exports.InfographicDetail = {
+      CONCISE: 1,
+      STANDARD: 2,
+      DETAILED: 3
+    };
+    exports.InfographicStyle = {
+      AUTO_SELECT: 1,
+      SKETCH_NOTE: 2,
+      PROFESSIONAL: 3,
+      BENTO_GRID: 4,
+      EDITORIAL: 5,
+      INSTRUCTIONAL: 6,
+      BRICKS: 7,
+      CLAY: 8,
+      ANIME: 9,
+      KAWAII: 10,
+      SCIENTIFIC: 11
+    };
+    exports.SlideDeckFormat = {
+      DETAILED_DECK: 1,
+      PRESENTER_SLIDES: 2
+    };
+    exports.SlideDeckLength = {
+      DEFAULT: 1,
+      SHORT: 2
+    };
+    exports.ExportType = {
+      DOCS: 1,
+      SHEETS: 2
+    };
+    SOURCE_TYPE_MAP = {
+      1: "google_docs",
+      2: "google_slides",
+      3: "pdf",
+      4: "pasted_text",
+      5: "web_page",
+      8: "markdown",
+      9: "youtube",
+      10: "media",
+      11: "docx",
+      13: "image",
+      14: "google_spreadsheet",
+      16: "csv"
+    };
+    ARTIFACT_TYPE_MAP = {
+      1: "audio",
+      2: "report",
+      3: "video",
+      5: "mind_map",
+      7: "infographic",
+      8: "slide_deck",
+      9: "data_table"
+    };
+    ARTIFACT_STATUS_MAP = {
+      1: "in_progress",
+      2: "pending",
+      3: "completed",
+      4: "failed"
+    };
+    SOURCE_STATUS_MAP = {
+      1: "processing",
+      2: "ready",
+      3: "error",
+      5: "preparing"
+    };
+    exports.ShareAccess = {
+      /** Only explicitly shared users can access */
+      RESTRICTED: 0,
+      /** Anyone with the link can access */
+      ANYONE_WITH_LINK: 1
+    };
+    exports.ShareViewLevel = {
+      /** Chat + sources + notes */
+      FULL_NOTEBOOK: 0,
+      /** Chat interface only */
+      CHAT_ONLY: 1
+    };
+    exports.SharePermission = {
+      OWNER: 1,
+      EDITOR: 2,
+      VIEWER: 3,
+      /** Internal: remove user from share list */
+      _REMOVE: 4
+    };
+  }
+});
+
+// src/client.ts
+init_auth();
+
+// src/rpc/core.ts
+init_errors();
+
+// src/rpc/encoder.ts
+function encodeRPCRequest(methodId, params) {
+  const paramsJson = JSON.stringify(params);
+  return [[[methodId, paramsJson, null, "generic"]]];
+}
+function buildRequestBody(rpcRequest, csrfToken) {
+  const fReq = encodeURIComponent(JSON.stringify(rpcRequest));
+  const at = encodeURIComponent(csrfToken);
+  return `f.req=${fReq}&at=${at}&`;
+}
+function buildUrlParams(methodId, sessionId, sourcePath = "/") {
+  return new URLSearchParams({
+    rpcids: methodId,
+    "source-path": sourcePath,
+    "f.sid": sessionId,
+    hl: "en",
+    rt: "c"
+  });
+}
+
+// src/rpc/decoder.ts
+init_errors();
+function stripAntiXSSI(response) {
+  if (response.startsWith(")]}'")) {
+    const match = /\)\]\}'\r?\n/.exec(response);
+    if (match) return response.slice(match[0].length);
+  }
+  return response;
+}
+function parseChunkedResponse(response) {
+  if (!response || !response.trim()) return [];
+  const chunks = [];
+  let skippedCount = 0;
+  const lines = response.trim().split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const line = (lines[i] ?? "").trim();
+    if (!line) {
+      i++;
+      continue;
+    }
+    if (/^\d+$/.test(line)) {
+      i++;
+      if (i < lines.length) {
+        try {
+          const chunk = JSON.parse(lines[i] ?? "");
+          chunks.push(chunk);
+        } catch {
+          skippedCount++;
+        }
+      }
+      i++;
+    } else {
+      try {
+        const chunk = JSON.parse(line);
+        chunks.push(chunk);
+      } catch {
+        skippedCount++;
+      }
+      i++;
+    }
+  }
+  if (skippedCount > 0 && lines.length > 0) {
+    const errorRate = skippedCount / lines.length;
+    if (errorRate > 0.1) {
+      throw new exports.RPCError(
+        `Response parsing failed: ${skippedCount} of ${lines.length} chunks malformed`,
+        { rawResponse: response.slice(0, 500) }
+      );
+    }
+  }
+  return chunks;
+}
+function containsUserDisplayableError(obj) {
+  if (typeof obj === "string") return obj.includes("UserDisplayableError");
+  if (Array.isArray(obj)) return obj.some(containsUserDisplayableError);
+  if (obj !== null && typeof obj === "object") {
+    return Object.values(obj).some(containsUserDisplayableError);
+  }
+  return false;
+}
+function collectRPCIds(chunks) {
+  const ids = [];
+  for (const chunk of chunks) {
+    if (!Array.isArray(chunk)) continue;
+    const items = Array.isArray(chunk[0]) ? chunk : [chunk];
+    for (const item of items) {
+      if (!Array.isArray(item) || item.length < 2) continue;
+      if ((item[0] === "wrb.fr" || item[0] === "er") && typeof item[1] === "string") {
+        ids.push(item[1]);
+      }
+    }
+  }
+  return ids;
+}
+function extractRPCResult(chunks, rpcId) {
+  for (const chunk of chunks) {
+    if (!Array.isArray(chunk)) continue;
+    const items = Array.isArray(chunk[0]) ? chunk : [chunk];
+    for (const item of items) {
+      if (!Array.isArray(item) || item.length < 3) continue;
+      if (item[0] === "er" && item[1] === rpcId) {
+        const code = item[2];
+        let msg = "Unknown error";
+        if (typeof code === "number") {
+          if (code === 429) msg = "API rate limit exceeded. Please wait before retrying.";
+          else if (code === 401 || code === 403) msg = "Authentication required or forbidden.";
+          else if (code === 404) msg = "Resource not found.";
+          else if (code >= 500) msg = `Server error ${code}. Try again later.`;
+          else msg = `Error code: ${code}`;
+        } else if (typeof code === "string") {
+          msg = code;
+        }
+        throw new exports.RPCError(msg, { methodId: rpcId, rpcCode: code });
+      }
+      if (item[0] === "wrb.fr" && item[1] === rpcId) {
+        const resultData = item[2];
+        if (resultData === null && item.length > 5 && item[5] != null) {
+          if (containsUserDisplayableError(item[5])) {
+            throw new exports.RateLimitError(
+              "API rate limit or quota exceeded. Please wait before retrying.",
+              { methodId: rpcId, rpcCode: "USER_DISPLAYABLE_ERROR" }
+            );
+          }
+        }
+        if (typeof resultData === "string") {
+          try {
+            return JSON.parse(resultData);
+          } catch {
+            return resultData;
+          }
+        }
+        return resultData;
+      }
+    }
+  }
+  return void 0;
+}
+function decodeResponse(rawResponse, rpcId, allowNull = false) {
+  const cleaned = stripAntiXSSI(rawResponse);
+  const chunks = parseChunkedResponse(cleaned);
+  const responsePreview = cleaned.slice(0, 500);
+  const foundIds = collectRPCIds(chunks);
+  let result;
+  try {
+    result = extractRPCResult(chunks, rpcId);
+  } catch (e) {
+    if (e instanceof exports.RPCError && e.foundIds.length === 0) {
+      throw new exports.RPCError(e.message, {
+        methodId: e.methodId,
+        rpcCode: e.rpcCode,
+        foundIds,
+        rawResponse: responsePreview
+      });
+    }
+    throw e;
+  }
+  if (result === void 0 && !allowNull) {
+    if (foundIds.length > 0 && !foundIds.includes(rpcId)) {
+      throw new exports.RPCError(
+        `No result for RPC ID '${rpcId}'. Response has IDs: ${foundIds.join(", ")}. Method ID may have changed.`,
+        { methodId: rpcId, foundIds, rawResponse: responsePreview }
+      );
+    }
+    throw new exports.RPCError(`No result found for RPC ID: ${rpcId} (${chunks.length} chunks parsed)`, {
+      methodId: rpcId,
+      foundIds,
+      rawResponse: responsePreview
+    });
+  }
+  return result ?? null;
+}
+
+// src/rpc/core.ts
+var BATCHEXECUTE_URL = "https://notebooklm.google.com/_/LabsTailwindUi/data/batchexecute";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var RPCCore = class {
+  auth;
+  timeoutMs;
+  constructor(auth, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    this.auth = auth;
+    this.timeoutMs = timeoutMs;
+  }
+  async call(methodId, params, opts = {}) {
+    const sourcePath = opts.sourcePath ?? "/";
+    const allowNull = opts.allowNull ?? false;
+    const timeoutMs = opts.timeoutMs ?? this.timeoutMs;
+    const rpcRequest = encodeRPCRequest(methodId, params);
+    const body = buildRequestBody(rpcRequest, this.auth.csrfToken);
+    const urlParams = buildUrlParams(methodId, this.auth.sessionId, sourcePath);
+    const url = `${BATCHEXECUTE_URL}?${urlParams.toString()}`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
+          Cookie: this.auth.cookieHeader
+        },
+        body,
+        signal: controller.signal
+      });
+    } catch (e) {
+      clearTimeout(timer);
+      if (e instanceof Error && e.name === "AbortError") {
+        throw new exports.RPCTimeoutError(`Request timed out calling ${methodId}`, {
+          methodId,
+          originalError: e
+        });
+      }
+      throw new exports.NetworkError(`Request failed calling ${methodId}: ${String(e)}`, {
+        methodId,
+        originalError: e instanceof Error ? e : void 0
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+    if (!response.ok) {
+      const status = response.status;
+      if (status === 429) {
+        const retryAfterHeader = response.headers.get("retry-after");
+        const retryAfter = retryAfterHeader ? parseInt(retryAfterHeader, 10) : void 0;
+        throw new exports.RateLimitError(`API rate limit exceeded calling ${methodId}`, {
+          methodId,
+          retryAfter: isNaN(retryAfter ?? NaN) ? void 0 : retryAfter
+        });
+      }
+      if (status === 401 || status === 403) {
+        throw new exports.AuthError(`HTTP ${status} calling ${methodId}: authentication required`, {
+          methodId
+        });
+      }
+      if (status >= 500) {
+        throw new exports.ServerError(`Server error ${status} calling ${methodId}`, {
+          methodId,
+          statusCode: status
+        });
+      }
+      if (status >= 400) {
+        throw new exports.ClientError(`Client error ${status} calling ${methodId}`, {
+          methodId,
+          statusCode: status
+        });
+      }
+      throw new exports.RPCError(`HTTP ${status} calling ${methodId}`, { methodId });
+    }
+    const text = await response.text();
+    return decodeResponse(text, methodId, allowNull);
+  }
+  /** Extract source IDs from a notebook (used by chat/artifact APIs). */
+  async getSourceIds(notebookId) {
+    const params = [notebookId, null, [2], null, 0];
+    const { RPCMethod: RPCMethod2 } = await Promise.resolve().then(() => (init_enums(), enums_exports));
+    const data = await this.call(RPCMethod2.GET_NOTEBOOK, params, {
+      sourcePath: `/notebook/${notebookId}`
+    });
+    const sourceIds = [];
+    if (!Array.isArray(data) || !data.length) return sourceIds;
+    try {
+      const nbInfo = data[0];
+      if (!Array.isArray(nbInfo) || nbInfo.length <= 1) return sourceIds;
+      const sources = nbInfo[1];
+      if (!Array.isArray(sources)) return sourceIds;
+      for (const src of sources) {
+        if (!Array.isArray(src) || !src.length) continue;
+        const first = src[0];
+        if (Array.isArray(first) && first.length > 0 && typeof first[0] === "string") {
+          sourceIds.push(first[0]);
+        }
+      }
+    } catch {
+    }
+    return sourceIds;
+  }
+};
+
+// src/api/notebooks.ts
+init_enums();
+
+// src/types/models.ts
+init_enums();
+function parseNotebook(data) {
+  const rawTitle = typeof data[0] === "string" ? data[0] : "";
+  const title = rawTitle.replace("thought\n", "").trim();
+  const id = typeof data[2] === "string" ? data[2] : "";
+  let createdAt = null;
+  if (Array.isArray(data[5]) && Array.isArray(data[5][5]) && data[5][5].length > 0) {
+    try {
+      createdAt = new Date(data[5][5][0] * 1e3);
+    } catch {
+    }
+  }
+  const isOwner = !(Array.isArray(data[5]) && data[5][1] === true);
+  return { id, title, createdAt, sourcesCount: 0, isOwner };
+}
+function parseSource(src) {
+  const srcId = Array.isArray(src[0]) ? src[0][0] : src[0];
+  const title = typeof src[1] === "string" ? src[1] : null;
+  let url = null;
+  if (Array.isArray(src[2]) && Array.isArray(src[2][7]) && src[2][7].length > 0) {
+    url = typeof src[2][7][0] === "string" ? src[2][7][0] : null;
+  }
+  let createdAt = null;
+  if (Array.isArray(src[2]) && Array.isArray(src[2][2]) && typeof src[2][2][0] === "number") {
+    try {
+      createdAt = new Date(src[2][2][0] * 1e3);
+    } catch {
+    }
+  }
+  let statusCode = 2;
+  if (Array.isArray(src[3]) && typeof src[3][1] === "number") {
+    statusCode = src[3][1];
+  }
+  let typeCode = null;
+  if (Array.isArray(src[2]) && typeof src[2][4] === "number") {
+    typeCode = src[2][4];
+  }
+  return {
+    id: String(srcId),
+    title,
+    url,
+    kind: sourceTypeFromCode(typeCode),
+    createdAt,
+    status: sourceStatusFromCode(statusCode),
+    _typeCode: typeCode
+  };
+}
+function parseArtifact(data, notebookId) {
+  const id = typeof data[0] === "string" ? data[0] : "";
+  const title = typeof data[1] === "string" ? data[1] : null;
+  const typeCode = typeof data[2] === "number" ? data[2] : 0;
+  const statusCode = typeof data[4] === "number" ? data[4] : 0;
+  let variant = null;
+  if (typeCode === 4 && Array.isArray(data[9]) && Array.isArray(data[9][1]) && typeof data[9][1][0] === "number") {
+    variant = data[9][1][0];
+  }
+  let audioUrl = null;
+  const meta6 = data[6];
+  if (Array.isArray(meta6) && Array.isArray(meta6[5])) {
+    const mediaList = meta6[5];
+    for (const item of mediaList) {
+      if (Array.isArray(item) && item[2] === "audio/mp4" && typeof item[0] === "string") {
+        audioUrl = item[0];
+        break;
+      }
+    }
+    if (!audioUrl && Array.isArray(mediaList[0]) && typeof mediaList[0][0] === "string") {
+      audioUrl = mediaList[0][0];
+    }
+  }
+  let videoUrl = null;
+  if (Array.isArray(data[8])) {
+    const meta8 = data[8];
+    for (const item of meta8) {
+      if (Array.isArray(item) && Array.isArray(item[0]) && typeof item[0][0] === "string" && item[0][0].startsWith("http")) {
+        const mediaList = item;
+        let best = null;
+        for (const m of mediaList) {
+          if (Array.isArray(m) && m[2] === "video/mp4" && typeof m[0] === "string") {
+            best = m[0];
+            if (m[1] === 4) break;
+          }
+        }
+        videoUrl = best ?? (Array.isArray(mediaList[0]) && typeof mediaList[0][0] === "string" ? mediaList[0][0] : null);
+        break;
+      }
+    }
+  }
+  let content = null;
+  if (Array.isArray(data[7]) && typeof data[7][0] === "string") {
+    content = data[7][0];
+  } else if (typeof data[7] === "string") {
+    content = data[7];
+  }
+  return {
+    id,
+    title,
+    kind: artifactTypeFromCode(typeCode, variant),
+    status: artifactStatusFromCode(statusCode),
+    notebookId,
+    audioUrl,
+    videoUrl,
+    exportUrl: null,
+    shareUrl: null,
+    content,
+    _raw: Array.isArray(data) ? data : []
+  };
+}
+function parseNote(data) {
+  const id = typeof data[0] === "string" ? data[0] : "";
+  const content = typeof data[1] === "string" ? data[1] : "";
+  const title = typeof data[2] === "string" ? data[2] : null;
+  let createdAt = null;
+  let updatedAt = null;
+  if (Array.isArray(data[3]) && typeof data[3][0] === "number") {
+    try {
+      createdAt = new Date(data[3][0] * 1e3);
+    } catch {
+    }
+  }
+  if (Array.isArray(data[4]) && typeof data[4][0] === "number") {
+    try {
+      updatedAt = new Date(data[4][0] * 1e3);
+    } catch {
+    }
+  }
+  return { id, title, content, createdAt, updatedAt };
+}
+
+// src/api/notebooks.ts
+var NotebooksAPI = class {
+  constructor(rpc) {
+    this.rpc = rpc;
+  }
+  async list() {
+    const params = [null, 1, null, [2]];
+    const result = await this.rpc.call(exports.RPCMethod.LIST_NOTEBOOKS, params);
+    if (!Array.isArray(result) || !result.length) return [];
+    const raw = Array.isArray(result[0]) ? result[0] : result;
+    return raw.map((nb) => parseNotebook(nb));
+  }
+  async create(title) {
+    const params = [title, null, null, [2], [1]];
+    const result = await this.rpc.call(exports.RPCMethod.CREATE_NOTEBOOK, params);
+    return parseNotebook(result);
+  }
+  async get(notebookId) {
+    const params = [notebookId, null, [2], null, 0];
+    const result = await this.rpc.call(exports.RPCMethod.GET_NOTEBOOK, params, {
+      sourcePath: `/notebook/${notebookId}`
+    });
+    const data = Array.isArray(result) && result.length ? result[0] : result;
+    return parseNotebook(data);
+  }
+  async delete(notebookId) {
+    const params = [[notebookId], [2]];
+    await this.rpc.call(exports.RPCMethod.DELETE_NOTEBOOK, params);
+    return true;
+  }
+  async rename(notebookId, newTitle) {
+    const params = [notebookId, [[null, null, null, [null, newTitle]]]];
+    await this.rpc.call(exports.RPCMethod.RENAME_NOTEBOOK, params, {
+      sourcePath: "/",
+      allowNull: true
+    });
+    return this.get(notebookId);
+  }
+  async getSummary(notebookId) {
+    const params = [notebookId, [2]];
+    const result = await this.rpc.call(exports.RPCMethod.SUMMARIZE, params, {
+      sourcePath: `/notebook/${notebookId}`
+    });
+    try {
+      if (Array.isArray(result)) {
+        const val = result[0]?.[0]?.[0];
+        return typeof val === "string" ? val : "";
+      }
+    } catch {
+    }
+    return "";
+  }
+  async getDescription(notebookId) {
+    const params = [notebookId, [2]];
+    const result = await this.rpc.call(exports.RPCMethod.SUMMARIZE, params, {
+      sourcePath: `/notebook/${notebookId}`
+    });
+    let summary = "";
+    const suggestedTopics = [];
+    try {
+      if (Array.isArray(result)) {
+        const outer = result[0];
+        if (Array.isArray(outer)) {
+          const summaryVal = outer[0]?.[0];
+          if (typeof summaryVal === "string") summary = summaryVal;
+          const topicsList = outer[1]?.[0];
+          if (Array.isArray(topicsList)) {
+            for (const t of topicsList) {
+              const question = typeof t[0] === "string" ? t[0] : "";
+              const prompt = typeof t[1] === "string" ? t[1] : "";
+              suggestedTopics.push({ question, prompt });
+            }
+          }
+        }
+      }
+    } catch {
+    }
+    return { summary, suggestedTopics };
+  }
+};
+
+// src/api/sources.ts
+init_enums();
+init_errors();
+var UPLOAD_URL = "https://notebooklm.google.com/upload/_/";
+var SourcesAPI = class {
+  constructor(rpc, auth) {
+    this.rpc = rpc;
+    this.auth = auth;
+  }
+  async list(notebookId) {
+    const params = [notebookId, null, [2], null, 0];
+    const notebook = await this.rpc.call(exports.RPCMethod.GET_NOTEBOOK, params, {
+      sourcePath: `/notebook/${notebookId}`
+    });
+    if (!Array.isArray(notebook) || !notebook.length) return [];
+    const nbInfo = notebook[0];
+    if (!Array.isArray(nbInfo) || nbInfo.length <= 1) return [];
+    const sourcesList = nbInfo[1];
+    if (!Array.isArray(sourcesList)) return [];
+    return sourcesList.filter((s) => Array.isArray(s) && s.length > 0).map((s) => parseSource(s));
+  }
+  async get(notebookId, sourceId) {
+    const sources = await this.list(notebookId);
+    return sources.find((s) => s.id === sourceId) ?? null;
+  }
+  async addUrl(notebookId, url, opts = {}) {
+    const params = [notebookId, [[url]], null, null, [2]];
+    const result = await this.rpc.call(exports.RPCMethod.ADD_SOURCE, params, {
+      sourcePath: `/notebook/${notebookId}`
+    });
+    const sourceId = extractSourceId(result);
+    if (opts.waitUntilReady) {
+      return this.waitUntilReady(notebookId, sourceId, opts.waitTimeout);
+    }
+    return {
+      id: sourceId,
+      title: url,
+      url,
+      kind: "web_page",
+      createdAt: null,
+      status: "processing",
+      _typeCode: null
+    };
+  }
+  async addText(notebookId, text, title, opts = {}) {
+    const params = [notebookId, null, [[null, null, null, text, title ?? null]], null, [2]];
+    const result = await this.rpc.call(exports.RPCMethod.ADD_SOURCE, params, {
+      sourcePath: `/notebook/${notebookId}`
+    });
+    const sourceId = extractSourceId(result);
+    if (opts.waitUntilReady) {
+      return this.waitUntilReady(notebookId, sourceId, opts.waitTimeout);
+    }
+    return {
+      id: sourceId,
+      title: title ?? null,
+      url: null,
+      kind: "pasted_text",
+      createdAt: null,
+      status: "processing",
+      _typeCode: null
+    };
+  }
+  async addFile(notebookId, filePath, mimeType, opts = {}) {
+    const fileData = fs.readFileSync(filePath);
+    const fileName = filePath.split("/").pop() ?? "file";
+    return this.addFileBuffer(notebookId, fileData, fileName, mimeType, opts);
+  }
+  async addFileBuffer(notebookId, data, fileName, mimeType, opts = {}) {
+    const uploadUrl = await this.uploadFile(notebookId, data, fileName, mimeType);
+    const params = [notebookId, null, null, [[uploadUrl, fileName, mimeType]], [2]];
+    const result = await this.rpc.call(exports.RPCMethod.ADD_SOURCE_FILE, params, {
+      sourcePath: `/notebook/${notebookId}`
+    });
+    const sourceId = extractSourceId(result);
+    if (opts.waitUntilReady) {
+      return this.waitUntilReady(notebookId, sourceId, opts.waitTimeout);
+    }
+    return {
+      id: sourceId,
+      title: fileName,
+      url: null,
+      kind: "pdf",
+      createdAt: null,
+      status: "processing",
+      _typeCode: null
+    };
+  }
+  async uploadFile(notebookId, data, fileName, mimeType) {
+    const params = new URLSearchParams({
+      "source-path": `/notebook/${notebookId}`,
+      upload_id: `${Date.now()}`,
+      upload_protocol: "resumable"
+    });
+    const initResp = await fetch(`${UPLOAD_URL}?${params}`, {
+      method: "POST",
+      headers: {
+        Cookie: this.auth.cookieHeader,
+        "X-Goog-Upload-Command": "start",
+        "X-Goog-Upload-Header-Content-Length": String(data.length),
+        "X-Goog-Upload-Header-Content-Type": mimeType,
+        "X-Upload-Content-Type": mimeType,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ title: fileName })
+    });
+    if (!initResp.ok) {
+      throw new Error(`Upload initiation failed: HTTP ${initResp.status}`);
+    }
+    const uploadSessionUrl = initResp.headers.get("x-goog-upload-url") ?? `${UPLOAD_URL}?${params}`;
+    const uploadResp = await fetch(uploadSessionUrl, {
+      method: "POST",
+      headers: {
+        Cookie: this.auth.cookieHeader,
+        "X-Goog-Upload-Command": "upload, finalize",
+        "X-Goog-Upload-Offset": "0",
+        "Content-Type": mimeType,
+        "Content-Length": String(data.length)
+      },
+      body: data instanceof Buffer ? data.buffer : data.buffer
+    });
+    if (!uploadResp.ok) {
+      throw new Error(`File upload failed: HTTP ${uploadResp.status}`);
+    }
+    const uploadResult = await uploadResp.text();
+    return uploadResult.trim();
+  }
+  async delete(notebookId, sourceId) {
+    const params = [notebookId, [sourceId], [2]];
+    await this.rpc.call(exports.RPCMethod.DELETE_SOURCE, params, {
+      sourcePath: `/notebook/${notebookId}`,
+      allowNull: true
+    });
+    return true;
+  }
+  async refresh(notebookId, sourceId) {
+    const params = [notebookId, sourceId, [2]];
+    await this.rpc.call(exports.RPCMethod.REFRESH_SOURCE, params, {
+      sourcePath: `/notebook/${notebookId}`,
+      allowNull: true
+    });
+    return true;
+  }
+  async waitUntilReady(notebookId, sourceId, timeout = 120, initialInterval = 1, maxInterval = 10, backoffFactor = 1.5) {
+    const deadline = Date.now() + timeout * 1e3;
+    let interval = initialInterval;
+    let lastStatus;
+    while (Date.now() < deadline) {
+      const source = await this.get(notebookId, sourceId);
+      if (source) {
+        if (source.status === "ready") return source;
+        if (source.status === "error") {
+          throw new exports.SourceProcessingError(sourceId, 3);
+        }
+        lastStatus = source._typeCode ?? void 0;
+      }
+      await sleep(interval * 1e3);
+      interval = Math.min(interval * backoffFactor, maxInterval);
+    }
+    throw new exports.SourceTimeoutError(sourceId, timeout, lastStatus);
+  }
+};
+function extractSourceId(result) {
+  if (Array.isArray(result)) {
+    try {
+      const v0 = result[0];
+      if (Array.isArray(v0)) {
+        const v00 = v0[0];
+        if (Array.isArray(v00)) {
+          const v000 = v00[0];
+          if (Array.isArray(v000) && typeof v000[0] === "string") return v000[0];
+          if (typeof v000 === "string") return v000;
+        }
+        if (typeof v00 === "string") return v00;
+      }
+      if (typeof v0 === "string") return v0;
+    } catch {
+    }
+    for (const item of result) {
+      if (typeof item === "string" && item.length > 8) return item;
+    }
+  }
+  if (typeof result === "string") return result;
+  throw new Error("Could not extract source ID from API response");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/api/artifacts.ts
+init_enums();
+init_errors();
+function tripleNest(ids) {
+  return ids.map((id) => [[id]]);
+}
+function doubleNest(ids) {
+  return ids.map((id) => [id]);
+}
+var ArtifactsAPI = class {
+  constructor(rpc, auth) {
+    this.rpc = rpc;
+    this.auth = auth;
+  }
+  async list(notebookId) {
+    const params = [[2], notebookId, 'NOT artifact.status = "ARTIFACT_STATUS_SUGGESTED"'];
+    const result = await this.rpc.call(exports.RPCMethod.LIST_ARTIFACTS, params, {
+      sourcePath: `/notebook/${notebookId}`,
+      allowNull: true
+    });
+    if (!Array.isArray(result) || !result.length) return [];
+    const rawList = Array.isArray(result[0]) ? result[0] : result;
+    const artifacts = [];
+    for (const item of rawList) {
+      if (Array.isArray(item)) {
+        try {
+          artifacts.push(parseArtifact(item, notebookId));
+        } catch {
+        }
+      }
+    }
+    return artifacts;
+  }
+  async get(notebookId, artifactId) {
+    const artifacts = await this.list(notebookId);
+    return artifacts.find((a) => a.id === artifactId) ?? null;
+  }
+  async delete(notebookId, artifactId) {
+    const params = [[2], notebookId, artifactId];
+    await this.rpc.call(exports.RPCMethod.DELETE_ARTIFACT, params, {
+      sourcePath: `/notebook/${notebookId}`,
+      allowNull: true
+    });
+    return true;
+  }
+  async rename(notebookId, artifactId, newTitle) {
+    const params = [[2], notebookId, artifactId, newTitle];
+    await this.rpc.call(exports.RPCMethod.RENAME_ARTIFACT, params, {
+      sourcePath: `/notebook/${notebookId}`,
+      allowNull: true
+    });
+    return true;
+  }
+  // ---------------------------------------------------------------------------
+  // Generation
+  // ---------------------------------------------------------------------------
+  async createAudio(notebookId, opts = {}) {
+    const format = opts.format ?? null;
+    const length = opts.length ?? null;
+    const language = opts.language ?? "en";
+    const sourceIds = opts.sourceIds ?? await this.rpc.getSourceIds(notebookId);
+    const triple = tripleNest(sourceIds);
+    const double = doubleNest(sourceIds);
+    const params = [
+      [2],
+      notebookId,
+      [
+        null,
+        null,
+        exports.ArtifactTypeCode.AUDIO,
+        triple,
+        null,
+        null,
+        [null, [opts.instructions ?? null, length, null, double, language, null, format]]
+      ]
+    ];
+    return this._callGenerate(notebookId, params);
+  }
+  async createVideo(notebookId, opts = {}) {
+    const format = opts.format ?? null;
+    const style = opts.style ?? null;
+    const language = opts.language ?? "en";
+    const sourceIds = opts.sourceIds ?? await this.rpc.getSourceIds(notebookId);
+    const triple = tripleNest(sourceIds);
+    const double = doubleNest(sourceIds);
+    const params = [
+      [2],
+      notebookId,
+      [
+        null,
+        null,
+        exports.ArtifactTypeCode.VIDEO,
+        triple,
+        null,
+        null,
+        null,
+        null,
+        [null, null, [double, language, opts.instructions ?? null, null, format, style]]
+      ]
+    ];
+    return this._callGenerate(notebookId, params);
+  }
+  async createQuiz(notebookId, opts = {}) {
+    const quantity = opts.quantity ?? null;
+    const difficulty = opts.difficulty ?? null;
+    const sourceIds = opts.sourceIds ?? await this.rpc.getSourceIds(notebookId);
+    const triple = tripleNest(sourceIds);
+    const params = [
+      [2],
+      notebookId,
+      [
+        null,
+        null,
+        exports.ArtifactTypeCode.QUIZ,
+        triple,
+        null,
+        null,
+        null,
+        null,
+        null,
+        [
+          null,
+          [2, null, opts.instructions ?? null, null, null, null, null, [quantity, difficulty]]
+        ]
+      ]
+    ];
+    return this._callGenerate(notebookId, params);
+  }
+  async createFlashcards(notebookId, opts = {}) {
+    const quantity = opts.quantity ?? null;
+    const difficulty = opts.difficulty ?? null;
+    const sourceIds = opts.sourceIds ?? await this.rpc.getSourceIds(notebookId);
+    const triple = tripleNest(sourceIds);
+    const params = [
+      [2],
+      notebookId,
+      [
+        null,
+        null,
+        exports.ArtifactTypeCode.QUIZ,
+        triple,
+        null,
+        null,
+        null,
+        null,
+        null,
+        [null, [1, null, opts.instructions ?? null, null, null, null, [difficulty, quantity]]]
+      ]
+    ];
+    return this._callGenerate(notebookId, params);
+  }
+  async createInfographic(notebookId, opts = {}) {
+    const orientation = opts.orientation ?? null;
+    const detail = opts.detail ?? null;
+    const style = opts.style ?? null;
+    const language = opts.language ?? "en";
+    const sourceIds = opts.sourceIds ?? await this.rpc.getSourceIds(notebookId);
+    const triple = tripleNest(sourceIds);
+    const params = [
+      [2],
+      notebookId,
+      [
+        null,
+        null,
+        exports.ArtifactTypeCode.INFOGRAPHIC,
+        triple,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        [[opts.instructions ?? null, language, null, orientation, detail, style]]
+      ]
+    ];
+    return this._callGenerate(notebookId, params);
+  }
+  async createSlideDeck(notebookId, opts = {}) {
+    const format = opts.format ?? null;
+    const length = opts.length ?? null;
+    const language = opts.language ?? "en";
+    const sourceIds = opts.sourceIds ?? await this.rpc.getSourceIds(notebookId);
+    const triple = tripleNest(sourceIds);
+    const params = [
+      [2],
+      notebookId,
+      [
+        null,
+        null,
+        exports.ArtifactTypeCode.SLIDE_DECK,
+        triple,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        [[opts.instructions ?? null, language, format, length]]
+      ]
+    ];
+    return this._callGenerate(notebookId, params);
+  }
+  async createReport(notebookId, opts = {}) {
+    const format = opts.format ?? "briefing_doc";
+    const language = opts.language ?? "en";
+    const sourceIds = opts.sourceIds ?? await this.rpc.getSourceIds(notebookId);
+    const triple = tripleNest(sourceIds);
+    const double = doubleNest(sourceIds);
+    const configs = {
+      briefing_doc: {
+        title: "Briefing Doc",
+        description: "Key insights and important quotes",
+        prompt: "Create a comprehensive briefing document that includes an Executive Summary, detailed analysis of key themes, important quotes with context, and actionable insights."
+      },
+      study_guide: {
+        title: "Study Guide",
+        description: "Short-answer quiz, essay questions, glossary",
+        prompt: "Create a comprehensive study guide that includes key concepts, short-answer practice questions, essay prompts for deeper exploration, and a glossary of important terms."
+      },
+      blog_post: {
+        title: "Blog Post",
+        description: "Insightful takeaways in readable article format",
+        prompt: "Write an engaging blog post that presents the key insights in an accessible, reader-friendly format with an attention-grabbing introduction and compelling conclusion."
+      },
+      custom: {
+        title: "Custom Report",
+        description: "Custom format",
+        prompt: opts.customPrompt ?? "Create a report based on the provided sources."
+      }
+    };
+    const cfg = configs[format] ?? configs["briefing_doc"];
+    const prompt = opts.extraInstructions && format !== "custom" ? `${cfg.prompt}
+
+${opts.extraInstructions}` : cfg.prompt;
+    const params = [
+      [2],
+      notebookId,
+      [
+        null,
+        null,
+        exports.ArtifactTypeCode.REPORT,
+        triple,
+        null,
+        null,
+        null,
+        [null, [cfg.title, cfg.description, null, double, language, prompt, null, true]]
+      ]
+    ];
+    return this._callGenerate(notebookId, params);
+  }
+  async createMindMap(notebookId, sourceIds) {
+    const ids = sourceIds ?? await this.rpc.getSourceIds(notebookId);
+    const triple = tripleNest(ids);
+    const params = [
+      triple,
+      null,
+      null,
+      null,
+      null,
+      ["interactive_mindmap", [["[CONTEXT]", ""]], ""],
+      null,
+      [2, null, [1]]
+    ];
+    const result = await this.rpc.call(exports.RPCMethod.GENERATE_MIND_MAP, params, {
+      sourcePath: `/notebook/${notebookId}`,
+      allowNull: true
+    });
+    return this._parseGenerationResult(result);
+  }
+  // ---------------------------------------------------------------------------
+  // Polling / download
+  // ---------------------------------------------------------------------------
+  /** Poll until artifact reaches completed/failed status. */
+  async waitUntilReady(notebookId, artifactId, timeout = 300, pollInterval = 3) {
+    const deadline = Date.now() + timeout * 1e3;
+    while (Date.now() < deadline) {
+      const artifact = await this.get(notebookId, artifactId);
+      if (artifact?.status === "completed") return artifact;
+      if (artifact?.status === "failed") {
+        throw new exports.ArtifactNotReadyError(artifact.kind, { artifactId, status: "failed" });
+      }
+      await sleep2(pollInterval * 1e3);
+    }
+    throw new exports.ArtifactNotReadyError("artifact", { artifactId, status: "timeout" });
+  }
+  /** Download audio content as a Buffer. */
+  async downloadAudio(notebookId, artifactId) {
+    const artifact = await this.get(notebookId, artifactId);
+    if (!artifact || artifact.status !== "completed") {
+      throw new exports.ArtifactNotReadyError("audio", { artifactId, status: artifact?.status });
+    }
+    if (!artifact.audioUrl) throw new exports.ArtifactNotReadyError("audio", { artifactId });
+    return this._fetchMediaWithCookies(artifact.audioUrl);
+  }
+  /** Download video content as a Buffer. */
+  async downloadVideo(notebookId, artifactId) {
+    const artifact = await this.get(notebookId, artifactId);
+    if (!artifact || artifact.status !== "completed") {
+      throw new exports.ArtifactNotReadyError("video", { artifactId, status: artifact?.status });
+    }
+    if (!artifact.videoUrl) throw new exports.ArtifactNotReadyError("video", { artifactId });
+    return this._fetchMediaWithCookies(artifact.videoUrl);
+  }
+  /** Get markdown content for a completed report artifact. */
+  async getReportMarkdown(notebookId, artifactId) {
+    const artifact = await this.get(notebookId, artifactId);
+    return artifact?.content ?? null;
+  }
+  /** Get interactive HTML for quiz/flashcard artifacts. */
+  async getInteractiveHtml(notebookId, artifactId) {
+    const params = [artifactId];
+    const result = await this.rpc.call(exports.RPCMethod.GET_INTERACTIVE_HTML, params, {
+      sourcePath: `/notebook/${notebookId}`,
+      allowNull: true
+    });
+    if (Array.isArray(result) && Array.isArray(result[0])) {
+      const data = result[0];
+      if (Array.isArray(data[9]) && typeof data[9][0] === "string") {
+        return data[9][0];
+      }
+    }
+    return null;
+  }
+  // ---------------------------------------------------------------------------
+  // Internal
+  // ---------------------------------------------------------------------------
+  /**
+   * Fetch a Google-hosted media URL, manually following redirects to ensure
+   * cookies are included on every hop. Node/Bun fetch strips the Cookie header
+   * on cross-origin redirects (e.g. googleusercontent.com → lh3.google.com).
+   */
+  async _fetchMediaWithCookies(url, maxRedirects = 10) {
+    let current = url;
+    for (let i = 0; i < maxRedirects; i++) {
+      if (!isTrustedDomain(current)) {
+        throw new Error(`Untrusted redirect target: ${new URL(current).hostname}`);
+      }
+      const response = await fetch(current, {
+        headers: { Cookie: this.auth.googleCookieHeader },
+        redirect: "manual"
+      });
+      if (response.status >= 300 && response.status < 400) {
+        const location = response.headers.get("location");
+        if (!location)
+          throw new Error(`Redirect with no Location header (status ${response.status})`);
+        current = location.startsWith("http") ? location : new URL(location, current).href;
+        continue;
+      }
+      if (!response.ok) throw new Error(`Media download failed: HTTP ${response.status}`);
+      const contentType = response.headers.get("content-type") ?? "";
+      if (contentType.includes("text/html")) {
+        throw new Error("Media download returned HTML \u2014 authentication cookies may be expired.");
+      }
+      return Buffer.from(await response.arrayBuffer());
+    }
+    throw new Error("Too many redirects fetching media URL");
+  }
+  async _callGenerate(notebookId, params) {
+    const result = await this.rpc.call(exports.RPCMethod.CREATE_ARTIFACT, params, {
+      sourcePath: `/notebook/${notebookId}`,
+      allowNull: true
+    });
+    return this._parseGenerationResult(result);
+  }
+  _parseGenerationResult(result) {
+    if (Array.isArray(result) && result.length > 0) {
+      const artifactData = result[0];
+      const artifactId = Array.isArray(artifactData) && artifactData.length > 0 && typeof artifactData[0] === "string" ? artifactData[0] : null;
+      const statusCode = Array.isArray(artifactData) && artifactData.length > 4 && typeof artifactData[4] === "number" ? artifactData[4] : null;
+      if (artifactId) {
+        return {
+          artifactId,
+          status: statusCode != null ? artifactStatusFromCode(statusCode) : "pending"
+        };
+      }
+    }
+    return { artifactId: null, status: "failed" };
+  }
+};
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var TRUSTED_MEDIA_DOMAINS = [
+  ".google.com",
+  ".googleusercontent.com",
+  ".googleapis.com",
+  ".usercontent.google.com"
+];
+function isTrustedDomain(url) {
+  try {
+    const host = new URL(url).hostname;
+    return TRUSTED_MEDIA_DOMAINS.some((d) => host === d.slice(1) || host.endsWith(d));
+  } catch {
+    return false;
+  }
+}
+
+// src/api/chat.ts
+init_enums();
+init_errors();
+var QUERY_URL = "https://notebooklm.google.com/_/LabsTailwindUi/data/google.internal.labs.tailwind.orchestration.v1.LabsTailwindOrchestrationService/GenerateFreeFormStreamed";
+var DEFAULT_BL = "boq_labs-tailwind-frontend_20260301.03_p0";
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var ChatAPI = class {
+  constructor(rpc, auth) {
+    this.rpc = rpc;
+    this.auth = auth;
+  }
+  conversationCache = /* @__PURE__ */ new Map();
+  reqid = Math.floor(Math.random() * 9e5) + 1e5;
+  async ask(notebookId, query, opts = {}) {
+    const sourceIds = opts.sourceIds ?? await this.rpc.getSourceIds(notebookId);
+    const isNew = !opts.conversationId;
+    const conversationId = opts.conversationId ?? randomUUID();
+    const history = isNew ? null : this._buildHistory(conversationId);
+    const sourcesArray = sourceIds.map((sid) => [[sid]]);
+    const params = [
+      sourcesArray,
+      query,
+      history,
+      [2, null, [1], [1]],
+      conversationId,
+      null,
+      null,
+      notebookId,
+      1
+    ];
+    const paramsJson = JSON.stringify(params, null, 0);
+    const fReq = JSON.stringify([null, paramsJson]);
+    this.reqid += 1e5;
+    const bl = typeof process !== "undefined" && process.env["NOTEBOOKLM_BL"] || DEFAULT_BL;
+    const urlParams = new URLSearchParams({ bl, hl: "en", _reqid: String(this.reqid), rt: "c" });
+    if (this.auth.sessionId) urlParams.set("f.sid", this.auth.sessionId);
+    const bodyParts = [`f.req=${encodeURIComponent(fReq)}`];
+    if (this.auth.csrfToken) bodyParts.push(`at=${encodeURIComponent(this.auth.csrfToken)}`);
+    const body = bodyParts.join("&") + "&";
+    let response;
+    try {
+      response = await fetch(`${QUERY_URL}?${urlParams.toString()}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
+          Cookie: this.auth.cookieHeader
+        },
+        body
+      });
+    } catch (e) {
+      throw new exports.ChatError(`Chat request failed: ${String(e)}`);
+    }
+    if (!response.ok) throw new exports.ChatError(`Chat request failed: HTTP ${response.status}`);
+    const text = await response.text();
+    const { answer, conversationId: serverConvId, references } = parseStreamingResponse(text);
+    const finalConvId = serverConvId ?? conversationId;
+    const cached = this.conversationCache.get(finalConvId) ?? [];
+    const turnNumber = cached.length + 1;
+    cached.push({ query, answer, turnNumber });
+    this.conversationCache.set(finalConvId, cached);
+    return { answer, conversationId: finalConvId, turnNumber, references };
+  }
+  async getConversationTurns(notebookId, conversationId) {
+    const params = [[], null, null, conversationId, 100];
+    const result = await this.rpc.call(exports.RPCMethod.GET_CONVERSATION_TURNS, params, {
+      sourcePath: `/notebook/${notebookId}`,
+      allowNull: true
+    });
+    if (!Array.isArray(result) || !Array.isArray(result[0])) return [];
+    const rawTurns = [...result[0]].reverse();
+    const turns = [];
+    let i = 0;
+    while (i < rawTurns.length) {
+      const turn = rawTurns[i];
+      if (!Array.isArray(turn) || turn.length < 3) {
+        i++;
+        continue;
+      }
+      if (turn[2] === 1 && turn.length > 3) {
+        const q = typeof turn[3] === "string" ? turn[3] : "";
+        let a = "";
+        const next = rawTurns[i + 1];
+        if (Array.isArray(next) && next.length > 4 && next[2] === 2) {
+          try {
+            a = String(next[4][0][0] ?? "");
+          } catch {
+          }
+          i++;
+        }
+        turns.push({ query: q, answer: a, turnNumber: turns.length + 1 });
+      }
+      i++;
+    }
+    return turns;
+  }
+  async getLastConversationId(notebookId) {
+    const params = [[], null, notebookId, 1];
+    const result = await this.rpc.call(exports.RPCMethod.GET_LAST_CONVERSATION_ID, params, {
+      sourcePath: `/notebook/${notebookId}`,
+      allowNull: true
+    });
+    if (!Array.isArray(result)) return null;
+    for (const group of result) {
+      if (!Array.isArray(group)) continue;
+      for (const conv of group) {
+        if (Array.isArray(conv) && typeof conv[0] === "string") {
+          return conv[0];
+        }
+      }
+    }
+    return null;
+  }
+  clearCache(conversationId) {
+    if (conversationId) {
+      this.conversationCache.delete(conversationId);
+    } else {
+      this.conversationCache.clear();
+    }
+  }
+  _buildHistory(conversationId) {
+    const turns = this.conversationCache.get(conversationId) ?? [];
+    if (!turns.length) return null;
+    const history = [];
+    for (const turn of turns) {
+      history.push([turn.answer, null, 2]);
+      history.push([turn.query, null, 1]);
+    }
+    return history;
+  }
+};
+function parseStreamingResponse(rawText) {
+  let text = rawText;
+  if (text.startsWith(")]}'")) text = text.slice(4);
+  const lines = text.trim().split("\n");
+  let bestMarkedAnswer = "";
+  let bestUnmarkedAnswer = "";
+  let serverConvId = null;
+  const references = [];
+  function processChunk(jsonStr) {
+    let data;
+    try {
+      data = JSON.parse(jsonStr);
+    } catch {
+      return;
+    }
+    if (!Array.isArray(data)) return;
+    for (const item of data) {
+      if (!Array.isArray(item) || item.length < 3 || item[0] !== "wrb.fr") continue;
+      const innerJson = item[2];
+      if (typeof innerJson !== "string") continue;
+      let innerData;
+      try {
+        innerData = JSON.parse(innerJson);
+      } catch {
+        continue;
+      }
+      if (!Array.isArray(innerData) || !innerData.length) continue;
+      const first = innerData[0];
+      if (!Array.isArray(first) || !first.length) continue;
+      const answerText = first[0];
+      if (typeof answerText !== "string" || !answerText) continue;
+      const typeInfo = first[4];
+      const isAnswer = Array.isArray(typeInfo) && typeInfo.length > 0 && typeInfo[typeInfo.length - 1] === 1;
+      const convData = first[2];
+      if (!serverConvId && Array.isArray(convData) && convData.length > 0 && typeof convData[0] === "string") {
+        serverConvId = convData[0];
+      }
+      if (Array.isArray(typeInfo) && typeInfo.length > 3) {
+        const citations = typeInfo[3];
+        if (Array.isArray(citations)) {
+          for (const cite of citations) {
+            const sourceId = extractUuid(cite);
+            if (sourceId) {
+              references.push({ sourceId, title: null, url: null });
+            }
+          }
+        }
+      }
+      if (isAnswer && answerText.length > bestMarkedAnswer.length) {
+        bestMarkedAnswer = answerText;
+      } else if (!isAnswer && answerText.length > bestUnmarkedAnswer.length) {
+        bestUnmarkedAnswer = answerText;
+      }
+    }
+  }
+  let i = 0;
+  while (i < lines.length) {
+    const line = (lines[i] ?? "").trim();
+    if (!line) {
+      i++;
+      continue;
+    }
+    if (/^\d+$/.test(line)) {
+      i++;
+      const next = lines[i];
+      if (next !== void 0) processChunk(next);
+      i++;
+    } else {
+      processChunk(line);
+      i++;
+    }
+  }
+  return {
+    answer: bestMarkedAnswer || bestUnmarkedAnswer,
+    conversationId: serverConvId,
+    references
+  };
+}
+function extractUuid(data, depth = 8) {
+  if (depth <= 0 || data == null) return null;
+  if (typeof data === "string") return UUID_RE.test(data) ? data : null;
+  if (Array.isArray(data)) {
+    for (const item of data) {
+      const found = extractUuid(item, depth - 1);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+function randomUUID() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    return (c === "x" ? r : r & 3 | 8).toString(16);
+  });
+}
+
+// src/api/notes.ts
+init_enums();
+var NotesAPI = class {
+  constructor(rpc) {
+    this.rpc = rpc;
+  }
+  async list(notebookId) {
+    const params = [notebookId, [2]];
+    const result = await this.rpc.call(exports.RPCMethod.GET_NOTES_AND_MIND_MAPS, params, {
+      sourcePath: `/notebook/${notebookId}`
+    });
+    const notes = [];
+    const mindMaps = [];
+    if (!Array.isArray(result)) return { notes, mindMaps };
+    try {
+      const notesData = result[0];
+      if (Array.isArray(notesData)) {
+        for (const n of notesData) {
+          if (Array.isArray(n)) notes.push(parseNote(n));
+        }
+      }
+      const mapsData = result[1];
+      if (Array.isArray(mapsData)) {
+        for (const m of mapsData) {
+          if (Array.isArray(m)) {
+            mindMaps.push({
+              id: typeof m[0] === "string" ? m[0] : "",
+              title: typeof m[2] === "string" ? m[2] : null,
+              content: typeof m[1] === "string" ? m[1] : "",
+              createdAt: Array.isArray(m[3]) && typeof m[3][0] === "number" ? new Date(m[3][0] * 1e3) : null
+            });
+          }
+        }
+      }
+    } catch {
+    }
+    return { notes, mindMaps };
+  }
+  async create(notebookId, content, title) {
+    const params = [notebookId, content, title ?? null, [2]];
+    const result = await this.rpc.call(exports.RPCMethod.CREATE_NOTE, params, {
+      sourcePath: `/notebook/${notebookId}`
+    });
+    if (Array.isArray(result)) return parseNote(result);
+    throw new Error("Could not parse note creation response");
+  }
+  async update(notebookId, noteId, content, title) {
+    const params = [notebookId, noteId, content, title ?? null, [2]];
+    const result = await this.rpc.call(exports.RPCMethod.UPDATE_NOTE, params, {
+      sourcePath: `/notebook/${notebookId}`
+    });
+    if (Array.isArray(result)) return parseNote(result);
+    return { id: noteId, title: title ?? null, content, createdAt: null, updatedAt: /* @__PURE__ */ new Date() };
+  }
+  async delete(notebookId, noteId) {
+    const params = [notebookId, noteId, [2]];
+    await this.rpc.call(exports.RPCMethod.DELETE_NOTE, params, {
+      sourcePath: `/notebook/${notebookId}`,
+      allowNull: true
+    });
+    return true;
+  }
+};
+
+// src/api/research.ts
+init_enums();
+var ResearchAPI = class {
+  constructor(rpc) {
+    this.rpc = rpc;
+  }
+  /**
+   * Start a research session.
+   * @param source "web" or "drive"
+   * @param mode "fast" or "deep" (deep only available for web)
+   */
+  async start(notebookId, query, source = "web", mode = "fast") {
+    if (mode === "deep" && source === "drive") {
+      throw new Error("Deep research only supports web sources.");
+    }
+    const sourceType = source === "web" ? 1 : 2;
+    let rpcId;
+    let params;
+    if (mode === "fast") {
+      rpcId = exports.RPCMethod.START_FAST_RESEARCH;
+      params = [[query, sourceType], null, 1, notebookId];
+    } else {
+      rpcId = exports.RPCMethod.START_DEEP_RESEARCH;
+      params = [null, [1], [query, sourceType], 5, notebookId];
+    }
+    const result = await this.rpc.call(rpcId, params, {
+      sourcePath: `/notebook/${notebookId}`,
+      allowNull: true
+    });
+    if (Array.isArray(result) && result.length > 0) {
+      return {
+        taskId: result[0],
+        reportId: result.length > 1 ? result[1] : null,
+        notebookId,
+        query,
+        mode
+      };
+    }
+    return null;
+  }
+  /** Poll for current research results in a notebook. */
+  async poll(notebookId) {
+    const params = [null, null, notebookId];
+    let result = await this.rpc.call(exports.RPCMethod.POLL_RESEARCH, params, {
+      sourcePath: `/notebook/${notebookId}`,
+      allowNull: true
+    });
+    if (!Array.isArray(result) || !result.length) {
+      return emptyResult();
+    }
+    if (Array.isArray(result[0]) && Array.isArray(result[0][0])) {
+      result = result[0];
+    }
+    const parsedTasks = [];
+    for (const taskData of result) {
+      if (!Array.isArray(taskData) || taskData.length < 2) continue;
+      const taskId = taskData[0];
+      const taskInfo = taskData[1];
+      if (typeof taskId !== "string" || !Array.isArray(taskInfo)) continue;
+      const queryText = Array.isArray(taskInfo[1]) ? taskInfo[1][0] ?? "" : "";
+      const sourcesAndSummary = Array.isArray(taskInfo[3]) ? taskInfo[3] : [];
+      const statusCode = typeof taskInfo[4] === "number" ? taskInfo[4] : null;
+      const sourcesData = Array.isArray(sourcesAndSummary[0]) ? sourcesAndSummary[0] : [];
+      const summary = typeof sourcesAndSummary[1] === "string" ? sourcesAndSummary[1] : "";
+      const parsedSources = [];
+      let report = "";
+      for (const src of sourcesData) {
+        if (!Array.isArray(src) || src.length < 2) continue;
+        let url = "";
+        let title = "";
+        let sourceReport = "";
+        let resultType = parseResultType(src.length > 3 ? src[3] : 1);
+        if (src[0] === null) {
+          if (Array.isArray(src[1]) && src[1].length >= 2 && typeof src[1][0] === "string" && typeof src[1][1] === "string") {
+            title = src[1][0];
+            sourceReport = src[1][1];
+            if (resultType === 1) resultType = 5;
+          } else if (typeof src[1] === "string") {
+            title = src[1];
+            if (resultType === 1) resultType = 5;
+          }
+        } else {
+          url = typeof src[0] === "string" ? src[0] : "";
+          title = src.length > 1 && typeof src[1] === "string" ? src[1] : "";
+        }
+        if (title || url) {
+          const parsed = { url, title, resultType, researchTaskId: taskId };
+          if (sourceReport) parsed.reportMarkdown = sourceReport;
+          parsedSources.push(parsed);
+          if (!report && sourceReport) {
+            report = sourceReport;
+          } else if (!report) {
+            const legacyReport = extractLegacyReport(src);
+            if (legacyReport) {
+              report = legacyReport;
+              parsed.reportMarkdown = legacyReport;
+            }
+          }
+        }
+      }
+      const status = statusCode === 2 || statusCode === 6 ? "completed" : "in_progress";
+      parsedTasks.push({
+        taskId,
+        status,
+        query: queryText,
+        sources: parsedSources,
+        summary,
+        report,
+        tasks: []
+      });
+    }
+    if (parsedTasks.length > 0) {
+      return { ...parsedTasks[0], tasks: parsedTasks };
+    }
+    return emptyResult();
+  }
+  /**
+   * Import selected research sources into the notebook.
+   * Pass sources from poll() — web sources need `url`, deep research report entries
+   * need `reportMarkdown` (resultType=5).
+   *
+   * Note: The API may return fewer items than imported. Use sources.list() to verify.
+   */
+  async importSources(notebookId, taskId, sources) {
+    if (!sources.length) return [];
+    const taskIds = new Set(sources.map((s) => s.researchTaskId).filter(Boolean));
+    if (taskIds.size > 1)
+      throw new Error("Cannot import sources from multiple research tasks in one batch.");
+    const effectiveTaskId = taskIds.size === 1 ? [...taskIds][0] : taskId;
+    const reportSources = sources.filter((s) => s.resultType === 5 && s.title && s.reportMarkdown);
+    const reportSourceSet = new Set(reportSources);
+    const webSources = sources.filter((s) => s.url && !reportSourceSet.has(s));
+    if (!webSources.length && !reportSources.length) return [];
+    const sourceArray = [
+      ...reportSources.map((s) => buildReportEntry(s.title, s.reportMarkdown)),
+      ...webSources.map((s) => buildWebEntry(s.url, s.title))
+    ];
+    const params = [null, [1], effectiveTaskId, notebookId, sourceArray];
+    let result = await this.rpc.call(exports.RPCMethod.IMPORT_RESEARCH, params, {
+      sourcePath: `/notebook/${notebookId}`,
+      allowNull: true
+    });
+    if (!Array.isArray(result)) return [];
+    if (result.length > 0 && Array.isArray(result[0]) && Array.isArray(result[0][0])) {
+      result = result[0];
+    }
+    const imported = [];
+    for (const srcData of result) {
+      if (!Array.isArray(srcData) || srcData.length < 2) continue;
+      const first = srcData[0];
+      const srcId = Array.isArray(first) && first.length > 0 ? first[0] : null;
+      if (srcId) imported.push({ id: srcId, title: srcData[1] });
+    }
+    return imported;
+  }
+};
+function parseResultType(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "string") {
+    const aliases = { web: 1, drive: 2, report: 5 };
+    return aliases[value.toLowerCase()] ?? 1;
+  }
+  return 1;
+}
+function extractLegacyReport(src) {
+  if (src.length <= 6 || !Array.isArray(src[6])) return "";
+  return src[6].filter((c) => typeof c === "string" && !!c).join("\n\n");
+}
+function buildReportEntry(title, markdown) {
+  return [null, [title, markdown], null, 3, null, null, null, null, null, null, 3];
+}
+function buildWebEntry(url, title) {
+  return [null, null, [url, title], null, null, null, null, null, null, null, 2];
+}
+function emptyResult() {
+  return {
+    taskId: null,
+    status: "no_research",
+    query: "",
+    sources: [],
+    summary: "",
+    report: "",
+    tasks: []
+  };
+}
+
+// src/api/settings.ts
+init_enums();
+var SettingsAPI = class {
+  constructor(rpc) {
+    this.rpc = rpc;
+  }
+  /** Get the current output language setting (e.g. "en", "ja", "zh_Hans"). */
+  async getOutputLanguage() {
+    const params = [null, [1, null, null, null, null, null, null, null, null, null, [1]]];
+    const result = await this.rpc.call(exports.RPCMethod.GET_USER_SETTINGS, params, {
+      sourcePath: "/",
+      allowNull: true
+    });
+    return extractNested(result, [0, 2, 4, 0]);
+  }
+  /**
+   * Set the output language for artifact generation.
+   * Pass a BCP-47 language code, e.g. "en", "ja", "zh_Hans".
+   * Returns the language that was set, or null if the response couldn't be parsed.
+   */
+  async setOutputLanguage(language) {
+    if (!language) return null;
+    const params = [[[null, [[null, null, null, null, [language]]]]]];
+    const result = await this.rpc.call(exports.RPCMethod.SET_USER_SETTINGS, params, {
+      sourcePath: "/",
+      allowNull: true
+    });
+    return extractNested(result, [2, 4, 0]);
+  }
+};
+function extractNested(data, path) {
+  try {
+    let cur = data;
+    for (const idx of path) {
+      if (!Array.isArray(cur)) return null;
+      cur = cur[idx];
+    }
+    return typeof cur === "string" && cur ? cur : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/api/sharing.ts
+init_enums();
+var SharingAPI = class {
+  constructor(rpc) {
+    this.rpc = rpc;
+  }
+  /** Get current sharing configuration for a notebook. */
+  async getStatus(notebookId) {
+    const params = [notebookId, [2]];
+    const result = await this.rpc.call(exports.RPCMethod.GET_SHARE_STATUS, params, {
+      sourcePath: `/notebook/${notebookId}`,
+      allowNull: true
+    });
+    return parseShareStatus(result, notebookId);
+  }
+  /** Enable or disable public link sharing. Returns updated status. */
+  async setPublic(notebookId, isPublic) {
+    const access = isPublic ? exports.ShareAccess.ANYONE_WITH_LINK : exports.ShareAccess.RESTRICTED;
+    const params = [[[notebookId, null, [access], [access, ""]]], 1, null, [2]];
+    await this.rpc.call(exports.RPCMethod.SHARE_NOTEBOOK, params, {
+      sourcePath: `/notebook/${notebookId}`,
+      allowNull: true
+    });
+    return this.getStatus(notebookId);
+  }
+  /**
+   * Set what viewers can access: full notebook or chat only.
+   * Note: GET_SHARE_STATUS doesn't return view_level, so it's inferred from what was set.
+   */
+  async setViewLevel(notebookId, level) {
+    const params = [notebookId, [[null, null, null, null, null, null, null, null, [[level]]]]];
+    await this.rpc.call(exports.RPCMethod.RENAME_NOTEBOOK, params, {
+      sourcePath: `/notebook/${notebookId}`,
+      allowNull: true
+    });
+    const status = await this.getStatus(notebookId);
+    return { ...status, viewLevel: level };
+  }
+  /** Share notebook with a user. Returns updated status. */
+  async addUser(notebookId, email, permission = exports.SharePermission.VIEWER, opts = {}) {
+    if (permission === exports.SharePermission.OWNER) throw new Error("Cannot assign OWNER permission");
+    if (permission === exports.SharePermission._REMOVE) throw new Error("Use removeUser() instead");
+    const { notify = true, welcomeMessage = "" } = opts;
+    const messageFlag = welcomeMessage ? 0 : 1;
+    const notifyFlag = notify ? 1 : 0;
+    const params = [
+      [[notebookId, [[email, null, permission]], null, [messageFlag, welcomeMessage]]],
+      notifyFlag,
+      null,
+      [2]
+    ];
+    await this.rpc.call(exports.RPCMethod.SHARE_NOTEBOOK, params, {
+      sourcePath: `/notebook/${notebookId}`,
+      allowNull: true
+    });
+    return this.getStatus(notebookId);
+  }
+  /** Update an existing user's permission level. Returns updated status. */
+  async updateUser(notebookId, email, permission) {
+    return this.addUser(notebookId, email, permission, { notify: false });
+  }
+  /** Remove a user's access to the notebook. Returns updated status. */
+  async removeUser(notebookId, email) {
+    const params = [
+      [[notebookId, [[email, null, exports.SharePermission._REMOVE]], null, [0, ""]]],
+      0,
+      null,
+      [2]
+    ];
+    await this.rpc.call(exports.RPCMethod.SHARE_NOTEBOOK, params, {
+      sourcePath: `/notebook/${notebookId}`,
+      allowNull: true
+    });
+    return this.getStatus(notebookId);
+  }
+};
+var PERM_MAP = {
+  1: "owner",
+  2: "editor",
+  3: "viewer"
+};
+function parseSharedUser(data) {
+  const email = typeof data[0] === "string" ? data[0] : "";
+  const permCode = typeof data[1] === "number" ? data[1] : 3;
+  const permission = PERM_MAP[permCode] ?? "viewer";
+  let displayName = null;
+  let avatarUrl = null;
+  if (Array.isArray(data[3])) {
+    const info = data[3];
+    displayName = typeof info[0] === "string" ? info[0] : null;
+    avatarUrl = typeof info[1] === "string" ? info[1] : null;
+  }
+  return { email, permission, displayName, avatarUrl };
+}
+function parseShareStatus(data, notebookId) {
+  const users = [];
+  if (Array.isArray(data[0])) {
+    for (const entry of data[0]) {
+      if (Array.isArray(entry)) users.push(parseSharedUser(entry));
+    }
+  }
+  const isPublic = Array.isArray(data[1]) && data[1][0] === true;
+  const access = isPublic ? exports.ShareAccess.ANYONE_WITH_LINK : exports.ShareAccess.RESTRICTED;
+  const shareUrl = isPublic ? `https://notebooklm.google.com/notebook/${notebookId}` : null;
+  return {
+    notebookId,
+    isPublic,
+    access,
+    viewLevel: exports.ShareViewLevel.FULL_NOTEBOOK,
+    sharedUsers: users,
+    shareUrl
+  };
+}
+
+// src/client.ts
+var NotebookLMClient = class _NotebookLMClient {
+  constructor(auth, opts = {}) {
+    this.auth = auth;
+    const rpc = new RPCCore(auth, opts.timeoutMs);
+    this.notebooks = new NotebooksAPI(rpc);
+    this.sources = new SourcesAPI(rpc, auth);
+    this.artifacts = new ArtifactsAPI(rpc, auth);
+    this.chat = new ChatAPI(rpc, auth);
+    this.notes = new NotesAPI(rpc);
+    this.research = new ResearchAPI(rpc);
+    this.settings = new SettingsAPI(rpc);
+    this.sharing = new SharingAPI(rpc);
+  }
+  notebooks;
+  sources;
+  artifacts;
+  chat;
+  notes;
+  research;
+  settings;
+  sharing;
+  /**
+   * Connect to NotebookLM using cookies.
+   * Fetches CSRF and session tokens from the NotebookLM homepage.
+   */
+  static async connect(opts, clientOpts = {}) {
+    const auth = await connect(opts);
+    return new _NotebookLMClient(auth, clientOpts);
+  }
+  /**
+   * Refresh CSRF and session tokens (e.g. if they expire mid-session).
+   */
+  async refreshTokens() {
+    const { fetchTokens: fetchTokens2 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
+    const { csrfToken, sessionId } = await fetchTokens2(this.auth.cookies);
+    this.auth.csrfToken = csrfToken;
+    this.auth.sessionId = sessionId;
+  }
+};
+
+// src/index.ts
+init_auth();
+init_enums();
+init_errors();
+
+exports.ArtifactsAPI = ArtifactsAPI;
+exports.ChatAPI = ChatAPI;
+exports.NotebookLMClient = NotebookLMClient;
+exports.NotebooksAPI = NotebooksAPI;
+exports.NotesAPI = NotesAPI;
+exports.ResearchAPI = ResearchAPI;
+exports.SettingsAPI = SettingsAPI;
+exports.SharingAPI = SharingAPI;
+exports.SourcesAPI = SourcesAPI;
+exports.connect = connect;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map