education-playlists 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1407 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_FOLLOW_UPS: () => DEFAULT_FOLLOW_UPS,
+  EDUCATION_CATEGORIES: () => EDUCATION_CATEGORIES,
+  EducationPlaylists: () => EducationPlaylists,
+  MAX_ANSWERS: () => MAX_ANSWERS,
+  MAX_ANSWER_LENGTH: () => MAX_ANSWER_LENGTH,
+  MAX_GOAL_LENGTH: () => MAX_GOAL_LENGTH,
+  MAX_PLAN_ITEMS: () => MAX_PLAN_ITEMS,
+  MAX_PLAYLIST_ITEMS: () => MAX_PLAYLIST_ITEMS,
+  MIT_OCW_PRESET_PLAYLISTS: () => MIT_OCW_PRESET_PLAYLISTS,
+  MIT_OCW_SEED_COURSES: () => MIT_OCW_SEED_COURSES,
+  PLAYLISTS_STORAGE_KEY: () => PLAYLISTS_STORAGE_KEY,
+  PROGRESS_STORAGE_KEY: () => PROGRESS_STORAGE_KEY,
+  PlaylistPlanner: () => PlaylistPlanner,
+  PlaylistView: () => PlaylistView,
+  SHARE_HASH_PARAM: () => SHARE_HASH_PARAM,
+  acceptInvite: () => acceptInvite,
+  addItem: () => addItem,
+  buildQuizPrompt: () => buildQuizPrompt,
+  canEdit: () => canEdit,
+  canView: () => canView,
+  catalogItems: () => catalogItems,
+  createLocalPlaylistStore: () => createLocalPlaylistStore,
+  createPlaylist: () => createPlaylist,
+  createProgressStore: () => createProgressStore,
+  decodeShareFragment: () => decodeShareFragment,
+  encodeShareFragment: () => encodeShareFragment,
+  extractJson: () => extractJson,
+  fetchFollowUps: () => fetchFollowUps,
+  fetchPlan: () => fetchPlan,
+  filterPlaylists: () => filterPlaylists,
+  formatMinutes: () => formatMinutes,
+  getDefaultCatalog: () => getDefaultCatalog,
+  invite: () => invite,
+  moveItem: () => moveItem,
+  normalizePlanRequest: () => normalizePlanRequest,
+  parseQuiz: () => parseQuiz,
+  planPlaylist: () => planPlaylist,
+  playlistTime: () => playlistTime,
+  readPreferences: () => readPreferences,
+  removeItem: () => removeItem,
+  removeMember: () => removeMember,
+  safeUrl: () => safeUrl,
+  sanitizeItem: () => sanitizeItem,
+  sanitizePlaylist: () => sanitizePlaylist,
+  searchCatalog: () => searchCatalog,
+  suggestFollowUps: () => suggestFollowUps,
+  toggleDone: () => toggleDone,
+  tokenize: () => tokenize,
+  weeksToFinish: () => weeksToFinish
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/catalog/taxonomy.ts
+var EDUCATION_CATEGORIES = [
+  {
+    id: "engineering",
+    name: "Engineering",
+    majors: [
+      {
+        id: "computer-science",
+        name: "Computer Science",
+        department: "6",
+        programs: [
+          { id: "foundations", name: "Foundations", description: "Programming and discrete math" },
+          { id: "algorithms-theory", name: "Algorithms & Theory" },
+          { id: "ai-ml", name: "AI & Machine Learning" },
+          { id: "systems", name: "Systems" }
+        ]
+      }
+    ]
+  },
+  {
+    id: "science",
+    name: "Science",
+    majors: [
+      {
+        id: "mathematics",
+        name: "Mathematics",
+        department: "18",
+        programs: [
+          { id: "calculus", name: "Calculus" },
+          { id: "linear-algebra-probability", name: "Linear Algebra & Probability" }
+        ]
+      },
+      {
+        id: "physics",
+        name: "Physics",
+        department: "8",
+        programs: [{ id: "core-physics", name: "Core Physics" }]
+      },
+      {
+        id: "biology-chemistry",
+        name: "Biology & Chemistry",
+        department: "7",
+        programs: [{ id: "life-sciences-core", name: "Life Sciences Core" }]
+      },
+      {
+        id: "brain-cognitive",
+        name: "Brain & Cognitive Sciences",
+        department: "9",
+        programs: [{ id: "brain-mind", name: "Brain & Mind" }]
+      }
+    ]
+  },
+  {
+    id: "social-science",
+    name: "Social Science & Management",
+    majors: [
+      {
+        id: "economics",
+        name: "Economics",
+        department: "14",
+        programs: [{ id: "principles", name: "Principles" }]
+      },
+      {
+        id: "finance",
+        name: "Finance",
+        department: "15",
+        programs: [{ id: "finance-theory", name: "Finance Theory" }]
+      }
+    ]
+  }
+];
+
+// src/catalog/mit-ocw-seed.ts
+var OCW = "https://ocw.mit.edu/courses/";
+var OCW_YOUTUBE_SEARCH = "https://www.youtube.com/@mitocw/search?query=";
+var seedProvenance = (note) => ({
+  provider: "mit_ocw",
+  method: "curated_seed",
+  verified: false,
+  note
+});
+function courseItems(course) {
+  const base = {
+    courseNumber: course.number,
+    institution: "MIT",
+    level: course.level
+  };
+  const id = course.slug;
+  const items = [];
+  if (course.lectures > 0) {
+    items.push({
+      ...base,
+      id: `${id}#videos`,
+      title: `${course.number} ${course.title}: lecture videos`,
+      url: `${OCW_YOUTUBE_SEARCH}${encodeURIComponent(`${course.number} ${course.title}`)}`,
+      kind: "video_playlist",
+      minutes: course.lectures * course.lectureMinutes,
+      estimate: "rough",
+      estimateBasis: `about ${course.lectures} lectures \xD7 ${course.lectureMinutes} min`,
+      description: course.description,
+      provenance: seedProvenance(
+        "Searches MIT OCW's YouTube channel; replaced by per-lecture URLs once the OCW YouTube dataset is ingested."
+      )
+    });
+  }
+  items.push({
+    ...base,
+    id: `${id}#courseware`,
+    title: `${course.number} ${course.title}: notes, problem sets and exams`,
+    url: `${OCW}${course.slug}/`,
+    kind: "courseware",
+    minutes: course.studyHours * 60,
+    estimate: "rough",
+    estimateBasis: `about ${course.studyHours} h of problem sets and readings`,
+    description: course.description,
+    provenance: seedProvenance("Canonical OCW course page, curated by hand.")
+  });
+  return items;
+}
+var c = (number, title, slug, level, lectures, lectureMinutes, studyHours, description) => ({ number, title, slug, level, lectures, lectureMinutes, studyHours, description });
+var MIT_OCW_SEED_COURSES = Object.fromEntries(
+  [
+    // Computer science (Course 6)
+    c("6.0001", "Introduction to Computer Science and Programming in Python", "6-0001-introduction-to-computer-science-and-programming-in-python-fall-2016", "introductory", 12, 50, 30, "Programming in Python for people with little or no experience: computation, abstraction, recursion, objects, and algorithmic complexity."),
+    c("6.0002", "Introduction to Computational Thinking and Data Science", "6-0002-introduction-to-computational-thinking-and-data-science-fall-2016", "introductory", 15, 50, 30, "Using computation to solve problems: optimization, graphs, simulation, statistics and machine learning basics, in Python."),
+    c("6.042J", "Mathematics for Computer Science", "6-042j-mathematics-for-computer-science-spring-2015", "introductory", 25, 80, 60, "Discrete math for computer science: proofs, induction, number theory, graphs, counting and discrete probability."),
+    c("6.006", "Introduction to Algorithms", "6-006-introduction-to-algorithms-spring-2020", "intermediate", 21, 50, 60, "Data structures and algorithms: sorting, hashing, graph search, shortest paths and dynamic programming."),
+    c("6.046J", "Design and Analysis of Algorithms", "6-046j-design-and-analysis-of-algorithms-spring-2015", "advanced", 24, 80, 60, "Algorithm design techniques: divide and conquer, amortization, randomization, network flow, and approximation."),
+    c("18.404J", "Theory of Computation", "18-404j-theory-of-computation-fall-2020", "advanced", 25, 75, 50, "Automata, computability and complexity: what can be computed, and how efficiently."),
+    c("6.034", "Artificial Intelligence", "6-034-artificial-intelligence-fall-2010", "intermediate", 23, 50, 40, "Representations and methods of AI: search, constraints, learning, and knowledge representation."),
+    c("6.036", "Introduction to Machine Learning", "6-036-introduction-to-machine-learning-fall-2020", "intermediate", 13, 90, 40, "Principles and algorithms of machine learning: linear models, neural networks, and reinforcement learning."),
+    c("18.065", "Matrix Methods in Data Analysis, Signal Processing, and Machine Learning", "18-065-matrix-methods-in-data-analysis-signal-processing-and-machine-learning-spring-2018", "advanced", 36, 50, 40, "Linear algebra for deep learning and data analysis: SVD, low-rank approximation, optimization, and neural nets."),
+    c("6.004", "Computation Structures", "6-004-computation-structures-spring-2017", "intermediate", 25, 50, 50, "How computers work: digital logic, processor design, memory hierarchy, and operating-system support."),
+    c("6.033", "Computer System Engineering", "6-033-computer-system-engineering-spring-2018", "advanced", 26, 80, 50, "Designing large computer systems: networking, fault tolerance, distributed systems, and security."),
+    c("6.172", "Performance Engineering of Software Systems", "6-172-performance-engineering-of-software-systems-fall-2018", "advanced", 23, 80, 60, "Building fast, scalable software: work and span, caching, parallelism, and measurement."),
+    // Mathematics (Course 18)
+    c("18.01", "Single Variable Calculus", "18-01-single-variable-calculus-fall-2006", "introductory", 39, 50, 60, "Differentiation and integration of functions of one variable, with applications."),
+    c("18.02", "Multivariable Calculus", "18-02-multivariable-calculus-fall-2007", "introductory", 35, 50, 60, "Vectors, partial derivatives, multiple integrals, and vector calculus."),
+    c("18.03", "Differential Equations", "18-03-differential-equations-spring-2010", "intermediate", 33, 50, 50, "Ordinary differential equations: first-order and linear equations, Laplace transforms, and systems."),
+    c("18.06", "Linear Algebra", "18-06-linear-algebra-spring-2010", "introductory", 34, 45, 50, "Matrix theory and linear algebra: systems of equations, vector spaces, determinants, eigenvalues, and positive definite matrices."),
+    c("18.05", "Introduction to Probability and Statistics", "18-05-introduction-to-probability-and-statistics-spring-2014", "introductory", 0, 0, 60, "Probability, random variables, Bayesian and frequentist statistics, taught through readings and class problems."),
+    // Physics (Course 8)
+    c("8.01SC", "Classical Mechanics", "8-01sc-classical-mechanics-fall-2016", "introductory", 35, 45, 60, "Newtonian mechanics: kinematics, forces, energy, momentum, rotation, and gravitation."),
+    c("8.02", "Physics II: Electricity and Magnetism", "8-02-physics-ii-electricity-and-magnetism-spring-2007", "introductory", 36, 50, 50, "Electric and magnetic fields, circuits, induction, and electromagnetic waves."),
+    c("8.04", "Quantum Physics I", "8-04-quantum-physics-i-spring-2013", "advanced", 24, 80, 60, "Wave mechanics: the Schr\xF6dinger equation, one-dimensional potentials, and the hydrogen atom."),
+    // Biology (Course 7), chemistry (Course 5), brain and cognitive sciences (Course 9)
+    c("7.016", "Introductory Biology", "7-016-introductory-biology-fall-2018", "introductory", 35, 50, 40, "Biochemistry, genetics, molecular biology, and cell biology, with an emphasis on how they connect."),
+    c("7.012", "Introduction to Biology", "7-012-introduction-to-biology-fall-2004", "introductory", 35, 50, 30, "Fundamental principles of biochemistry, genetics, molecular biology, and cell biology."),
+    c("5.111SC", "Principles of Chemical Science", "5-111sc-principles-of-chemical-science-fall-2014", "introductory", 36, 50, 40, "Atomic structure, bonding, thermodynamics, kinetics, and chemical equilibrium."),
+    c("9.13", "The Human Brain", "9-13-the-human-brain-spring-2019", "introductory", 23, 80, 30, "How the brain gives rise to perception, language, and thought, and how we know."),
+    c("9.00SC", "Introduction to Psychology", "9-00sc-introduction-to-psychology-fall-2011", "introductory", 24, 50, 30, "Survey of the scientific study of human nature: perception, memory, emotion, and social behavior."),
+    // Economics (Course 14) and management (Course 15)
+    c("14.01SC", "Principles of Microeconomics", "14-01sc-principles-of-microeconomics-fall-2011", "introductory", 26, 50, 40, "How consumers and firms make choices, and how markets set prices."),
+    c("14.02", "Principles of Macroeconomics", "14-02-principles-of-macroeconomics-spring-2014", "introductory", 25, 80, 40, "Output, unemployment, inflation, interest rates, and the policies that move them."),
+    c("15.401", "Finance Theory I", "15-401-finance-theory-i-fall-2008", "intermediate", 24, 80, 40, "Present value, fixed income, equities, risk and return, and capital budgeting.")
+  ].map((course) => [course.number, course])
+);
+function preset(id, title, categoryId, majorId, programId, level, description, courseNumbers) {
+  return {
+    id,
+    title,
+    description,
+    categoryId,
+    majorId,
+    programId,
+    level,
+    visibility: "preset",
+    items: courseNumbers.flatMap((number) => {
+      const course = MIT_OCW_SEED_COURSES[number];
+      if (!course) throw new Error(`Unknown seed course ${number}`);
+      return courseItems(course);
+    })
+  };
+}
+var MIT_OCW_PRESET_PLAYLISTS = [
+  preset("cs-foundations", "CS Foundations", "engineering", "computer-science", "foundations", "introductory", "Start programming and pick up the math computer science leans on.", ["6.0001", "6.0002", "6.042J"]),
+  preset("cs-algorithms-theory", "Algorithms and Theory", "engineering", "computer-science", "algorithms-theory", "intermediate", "From data structures to what can be computed at all.", ["6.006", "6.046J", "18.404J"]),
+  preset("cs-ai-ml", "AI and Machine Learning", "engineering", "computer-science", "ai-ml", "intermediate", "Classical AI, modern machine learning, and the linear algebra underneath.", ["6.034", "6.036", "18.065"]),
+  preset("cs-systems", "Computer Systems", "engineering", "computer-science", "systems", "intermediate", "How hardware runs software, and how to build systems that are fast and reliable.", ["6.004", "6.033", "6.172"]),
+  preset("math-calculus", "The Calculus Sequence", "science", "mathematics", "calculus", "introductory", "Single-variable, multivariable, and differential equations, in that order.", ["18.01", "18.02", "18.03"]),
+  preset("math-linear-algebra-probability", "Linear Algebra and Probability", "science", "mathematics", "linear-algebra-probability", "introductory", "The two subjects every quantitative field assumes.", ["18.06", "18.05"]),
+  preset("physics-core", "Core Physics", "science", "physics", "core-physics", "introductory", "Mechanics, electromagnetism, then a first look at quantum.", ["8.01SC", "8.02", "8.04"]),
+  preset("life-sciences-core", "Life Sciences Core", "science", "biology-chemistry", "life-sciences-core", "introductory", "Biology and the chemistry it is built on.", ["5.111SC", "7.016", "7.012"]),
+  preset("brain-mind", "Brain and Mind", "science", "brain-cognitive", "brain-mind", "introductory", "Psychology and neuroscience for the curious.", ["9.00SC", "9.13"]),
+  preset("econ-principles", "Economics Principles", "social-science", "economics", "principles", "introductory", "Micro then macro: how markets and economies work.", ["14.01SC", "14.02"]),
+  preset("finance-theory", "Finance Theory", "social-science", "finance", "finance-theory", "intermediate", "Valuation, risk, and return.", ["15.401"])
+];
+
+// src/catalog/index.ts
+function getDefaultCatalog() {
+  return { categories: EDUCATION_CATEGORIES, playlists: MIT_OCW_PRESET_PLAYLISTS };
+}
+function filterPlaylists(playlists, filter) {
+  return playlists.filter(
+    (playlist) => (!filter.categoryId || playlist.categoryId === filter.categoryId) && (!filter.majorId || playlist.majorId === filter.majorId) && (!filter.programId || playlist.programId === filter.programId)
+  );
+}
+function catalogItems(catalog) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const playlist of catalog.playlists) {
+    for (const item of playlist.items) if (!seen.has(item.id)) seen.set(item.id, item);
+  }
+  return [...seen.values()];
+}
+
+// src/lib/time.ts
+function formatMinutes(minutes) {
+  const total = Math.max(0, Math.round(minutes));
+  if (total < 60) return `${total} min`;
+  if (total >= 600) return `${Math.round(total / 60)} h`;
+  const hours = Math.floor(total / 60);
+  const rest = total % 60;
+  return rest ? `${hours} h ${rest} min` : `${hours} h`;
+}
+function playlistTime(playlist, done) {
+  let totalMinutes = 0;
+  let doneMinutes = 0;
+  let doneCount = 0;
+  for (const item of playlist.items) {
+    totalMinutes += item.minutes;
+    if (done.has(item.id)) {
+      doneMinutes += item.minutes;
+      doneCount += 1;
+    }
+  }
+  return {
+    totalMinutes,
+    doneMinutes,
+    remainingMinutes: totalMinutes - doneMinutes,
+    percent: totalMinutes ? Math.round(doneMinutes / totalMinutes * 100) : 0,
+    doneCount,
+    itemCount: playlist.items.length
+  };
+}
+function weeksToFinish(remainingMinutes, minutesPerWeek) {
+  if (!minutesPerWeek || minutesPerWeek <= 0) return null;
+  return Math.ceil(remainingMinutes / minutesPerWeek);
+}
+
+// src/lib/progress.ts
+var PROGRESS_STORAGE_KEY = "educationPlaylists.progress";
+function createProgressStore(key = PROGRESS_STORAGE_KEY) {
+  let memory = /* @__PURE__ */ new Set();
+  const storage = () => {
+    try {
+      return typeof localStorage === "undefined" ? null : localStorage;
+    } catch {
+      return null;
+    }
+  };
+  return {
+    load() {
+      try {
+        const raw = storage()?.getItem(key);
+        if (!raw) return new Set(memory);
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? new Set(parsed.filter((id) => typeof id === "string")) : /* @__PURE__ */ new Set();
+      } catch {
+        return new Set(memory);
+      }
+    },
+    save(done) {
+      memory = new Set(done);
+      try {
+        storage()?.setItem(key, JSON.stringify([...done]));
+      } catch {
+      }
+    }
+  };
+}
+function toggleDone(done, id) {
+  const next = new Set(done);
+  if (next.has(id)) next.delete(id);
+  else next.add(id);
+  return next;
+}
+
+// src/lib/sanitize.ts
+var MAX_PLAYLIST_ITEMS = 60;
+var MAX_TITLE = 200;
+var MAX_TEXT = 600;
+var MAX_ITEM_MINUTES = 500 * 60;
+var KINDS = ["video_playlist", "video", "courseware", "lecture_notes", "assignment", "reading", "textbook"];
+var PROVIDERS = ["mit_ocw", "edx", "coursera", "khan", "openstax", "youtube", "web"];
+var METHODS = ["curated_seed", "official_api", "snapshot_dataset", "community_list", "llm_search", "user"];
+var LEVELS = ["introductory", "intermediate", "advanced"];
+var VISIBILITIES = ["preset", "public", "private"];
+var text = (value, max) => typeof value === "string" && value.trim() ? value.trim().slice(0, max) : void 0;
+var oneOf = (value, allowed, fallback) => allowed.includes(value) ? value : fallback;
+function safeUrl(value) {
+  if (typeof value !== "string") return null;
+  try {
+    const url = new URL(value.trim());
+    return url.protocol === "https:" || url.protocol === "http:" ? url.toString() : null;
+  } catch {
+    return null;
+  }
+}
+function sanitizeItem(raw, index = 0) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  const url = safeUrl(r.url);
+  const title = text(r.title, MAX_TITLE);
+  if (!url || !title) return null;
+  const minutes = Number(r.minutes);
+  const p = r.provenance && typeof r.provenance === "object" ? r.provenance : {};
+  return {
+    id: text(r.id, MAX_TITLE) ?? `item-${index}-${url}`,
+    title,
+    url,
+    kind: oneOf(r.kind, KINDS, "reading"),
+    minutes: Number.isFinite(minutes) ? Math.min(Math.max(0, Math.round(minutes)), MAX_ITEM_MINUTES) : 0,
+    estimate: r.estimate === "exact" ? "exact" : "rough",
+    estimateBasis: text(r.estimateBasis, MAX_TITLE),
+    courseNumber: text(r.courseNumber, 40),
+    institution: text(r.institution, 120),
+    level: LEVELS.includes(r.level) ? r.level : void 0,
+    description: text(r.description, MAX_TEXT),
+    provenance: {
+      provider: oneOf(p.provider, PROVIDERS, "web"),
+      method: oneOf(p.method, METHODS, "user"),
+      sourceUrl: safeUrl(p.sourceUrl) ?? void 0,
+      fetchedAt: text(p.fetchedAt, 40),
+      // Nothing that arrives from outside gets to call itself verified.
+      verified: false,
+      note: text(p.note, MAX_TEXT)
+    }
+  };
+}
+function sanitizePlaylist(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  const title = text(r.title, MAX_TITLE);
+  if (!title || !Array.isArray(r.items)) return null;
+  const items = r.items.slice(0, MAX_PLAYLIST_ITEMS).map((item, index) => sanitizeItem(item, index)).filter((item) => item !== null);
+  if (items.length === 0) return null;
+  const visibility = oneOf(r.visibility, VISIBILITIES, "public");
+  return {
+    id: text(r.id, 120) ?? `shared-${Date.now().toString(36)}`,
+    title,
+    description: text(r.description, MAX_TEXT),
+    categoryId: text(r.categoryId, 80) ?? "custom",
+    majorId: text(r.majorId, 80) ?? "custom",
+    programId: text(r.programId, 80),
+    level: LEVELS.includes(r.level) ? r.level : void 0,
+    // A link can only ever carry a public copy.
+    visibility: visibility === "preset" ? "public" : visibility,
+    items
+  };
+}
+
+// src/lib/playlists.ts
+var PLAYLISTS_STORAGE_KEY = "educationPlaylists.mine";
+var newId = () => typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID() : `pl-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+function createPlaylist(input) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: newId(),
+    title: input.title.trim() || "My playlist",
+    description: input.description,
+    categoryId: "custom",
+    majorId: "custom",
+    visibility: input.visibility ?? "private",
+    ownerId: input.ownerId,
+    members: [],
+    items: input.items ?? [],
+    plannedFrom: input.plannedFrom,
+    createdAt: now,
+    updatedAt: now
+  };
+}
+function addItem(playlist, item) {
+  if (playlist.items.some((existing) => existing.id === item.id || existing.url === item.url)) return playlist;
+  return { ...playlist, items: [...playlist.items, item], updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+}
+function removeItem(playlist, itemId) {
+  return { ...playlist, items: playlist.items.filter((item) => item.id !== itemId), updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+}
+function moveItem(playlist, from, to) {
+  const items = [...playlist.items];
+  if (from < 0 || from >= items.length) return playlist;
+  const [moved] = items.splice(from, 1);
+  items.splice(Math.max(0, Math.min(to, items.length)), 0, moved);
+  return { ...playlist, items, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+}
+function createLocalPlaylistStore(key = PLAYLISTS_STORAGE_KEY) {
+  let memory = [];
+  const read = () => {
+    try {
+      const raw = typeof localStorage === "undefined" ? null : localStorage.getItem(key);
+      if (!raw) return memory;
+      const parsed = JSON.parse(raw);
+      if (!Array.isArray(parsed)) return [];
+      return parsed.flatMap((entry) => {
+        const clean = sanitizePlaylist(entry);
+        if (!clean) return [];
+        const original = entry;
+        return [{ ...clean, visibility: original.visibility === "public" ? "public" : "private", ownerId: original.ownerId, members: original.members ?? [], plannedFrom: original.plannedFrom, createdAt: original.createdAt, updatedAt: original.updatedAt }];
+      });
+    } catch {
+      return memory;
+    }
+  };
+  const write = (playlists) => {
+    memory = playlists;
+    try {
+      if (typeof localStorage !== "undefined") localStorage.setItem(key, JSON.stringify(playlists));
+    } catch {
+    }
+    return playlists;
+  };
+  return {
+    list: read,
+    save(playlist) {
+      const others = read().filter((existing) => existing.id !== playlist.id);
+      return write([playlist, ...others]);
+    },
+    remove(id) {
+      return write(read().filter((existing) => existing.id !== id));
+    }
+  };
+}
+
+// src/lib/sharing.ts
+var EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+function activeMember(playlist, userId) {
+  if (!userId) return void 0;
+  return playlist.members?.find((member) => member.status === "active" && member.userId === userId);
+}
+function canView(playlist, userId) {
+  if (playlist.visibility !== "private") return true;
+  if (userId && playlist.ownerId === userId) return true;
+  return Boolean(activeMember(playlist, userId));
+}
+function canEdit(playlist, userId) {
+  if (playlist.visibility === "preset") return false;
+  if (userId && playlist.ownerId === userId) return true;
+  const member = activeMember(playlist, userId);
+  return member?.role === "owner" || member?.role === "editor";
+}
+var defaultToken = () => typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID() : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+function invite(playlist, email, role, makeToken = defaultToken) {
+  const address = email.trim().toLowerCase();
+  if (!EMAIL.test(address)) throw new Error(`Not an email address: ${email}`);
+  if (role === "owner") throw new Error("A playlist has exactly one owner");
+  const members = [...playlist.members ?? []];
+  const existing = members.findIndex((member) => member.email === address);
+  if (existing >= 0) {
+    members[existing] = { ...members[existing], role };
+  } else {
+    members.push({ email: address, role, status: "invited", inviteToken: makeToken() });
+  }
+  return { ...playlist, members };
+}
+function acceptInvite(playlist, token, userId) {
+  const members = playlist.members ?? [];
+  const index = members.findIndex((member) => member.inviteToken === token && member.status === "invited");
+  if (index < 0) return null;
+  const next = [...members];
+  next[index] = { ...next[index], userId, status: "active", inviteToken: void 0 };
+  return { ...playlist, members: next };
+}
+function removeMember(playlist, email) {
+  const address = email.trim().toLowerCase();
+  return { ...playlist, members: (playlist.members ?? []).filter((member) => member.email !== address) };
+}
+var toBase64Url = (value) => {
+  const bytes = new TextEncoder().encode(value);
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+};
+var fromBase64Url = (value) => {
+  const padded = value.replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(value.length / 4) * 4, "=");
+  const binary = atob(padded);
+  return new TextDecoder().decode(Uint8Array.from(binary, (char) => char.charCodeAt(0)));
+};
+var SHARE_HASH_PARAM = "playlist";
+function encodeShareFragment(playlist) {
+  if (playlist.visibility === "private") throw new Error("Private playlists are shared by invitation");
+  const { members: _members, ownerId: _ownerId, plannedFrom: _plannedFrom, ...shareable } = playlist;
+  return `${SHARE_HASH_PARAM}=${toBase64Url(JSON.stringify({ ...shareable, visibility: "public" }))}`;
+}
+function decodeShareFragment(fragment) {
+  const params = new URLSearchParams(fragment.replace(/^#/, ""));
+  const encoded = params.get(SHARE_HASH_PARAM);
+  if (!encoded) return null;
+  try {
+    return sanitizePlaylist(JSON.parse(fromBase64Url(encoded)));
+  } catch {
+    return null;
+  }
+}
+
+// src/lib/search.ts
+var STOP_WORDS = new Set(
+  "a an and are as at be by for from how i in into is it learn learning me my of on or the to want what with about understand study become get better".split(" ")
+);
+function tokenize(text2) {
+  return text2.toLowerCase().split(/[^a-z0-9.]+/).map((token) => token.replace(/^\.+|\.+$/g, "")).filter((token) => token.length > 1 && !STOP_WORDS.has(token));
+}
+function searchCatalog(items, query, limit = 10) {
+  const terms = tokenize(query);
+  if (terms.length === 0) return [];
+  return items.map((item, order) => {
+    const title = item.title.toLowerCase();
+    const body = `${item.description ?? ""} ${item.courseNumber ?? ""}`.toLowerCase();
+    let score = 0;
+    for (const term of terms) {
+      if (title.includes(term)) score += 2;
+      else if (body.includes(term)) score += 1;
+    }
+    return { item, score, order };
+  }).filter((entry) => entry.score > 0).sort((a, b) => b.score - a.score || a.order - b.order).slice(0, limit).map((entry) => entry.item);
+}
+
+// src/planner/index.ts
+var MAX_GOAL_LENGTH = 300;
+var MAX_ANSWERS = 8;
+var MAX_ANSWER_LENGTH = 300;
+var MAX_PLAN_ITEMS = 12;
+var MAX_SEARCHES = 5;
+var WEB_RESULTS_PER_SEARCH = 3;
+var WEB_ITEM_MINUTES = 60;
+var DEFAULT_FOLLOW_UPS = [
+  { id: "level", question: "Where are you starting from?", options: ["New to this", "Some background", "Comfortable, want depth"] },
+  { id: "time", question: "How much time can you give it each week?", options: ["2 hours", "5 hours", "10 hours"] },
+  { id: "format", question: "What do you learn best from?", options: ["Lecture videos", "Problem sets and notes", "A mix"] },
+  { id: "outcome", question: "What should you be able to do at the end?", options: ["Pass a course or exam", "Build a project", "Switch careers", "Just curious"] }
+];
+function normalizePlanRequest(raw) {
+  const r = raw && typeof raw === "object" ? raw : {};
+  const goal = typeof r.goal === "string" ? r.goal.trim().slice(0, MAX_GOAL_LENGTH) : "";
+  if (!goal) throw new Error("A learning goal is required");
+  const answers = Array.isArray(r.answers) ? r.answers.slice(0, MAX_ANSWERS).flatMap((entry) => {
+    const e = entry && typeof entry === "object" ? entry : {};
+    const question = typeof e.question === "string" ? e.question.trim().slice(0, MAX_ANSWER_LENGTH) : "";
+    const answer = typeof e.answer === "string" ? e.answer.trim().slice(0, MAX_ANSWER_LENGTH) : "";
+    return question && answer ? [{ question, answer }] : [];
+  }) : [];
+  return { goal, answers };
+}
+function extractJson(text2) {
+  const start = text2.indexOf("{");
+  const end = text2.lastIndexOf("}");
+  if (start < 0 || end <= start) return null;
+  try {
+    return JSON.parse(text2.slice(start, end + 1));
+  } catch {
+    return null;
+  }
+}
+var FOLLOW_UP_SYSTEM = `You help a self-directed learner plan a study playlist of free university courses and lecture videos.
+Ask 3 or 4 short follow-up questions that would most change which courses to recommend (their starting level, weekly time, preferred format, and what they want to be able to do are usually the most useful).
+Give each question 2 to 4 short answer options. The learner can also type their own answer.
+Reply with JSON only, in this shape: {"questions":[{"question":"...","options":["...","..."]}]}`;
+function parseFollowUps(text2) {
+  const json = extractJson(text2);
+  if (!json || !Array.isArray(json.questions)) return null;
+  const questions = json.questions.slice(0, 4).flatMap((entry, index) => {
+    const e = entry && typeof entry === "object" ? entry : {};
+    const question = typeof e.question === "string" ? e.question.trim().slice(0, 200) : "";
+    if (!question) return [];
+    const options = Array.isArray(e.options) ? e.options.filter((o) => typeof o === "string" && o.trim() !== "").map((o) => o.trim().slice(0, 80)).slice(0, 4) : [];
+    return [{ id: `q${index + 1}`, question, options }];
+  });
+  return questions.length ? questions : null;
+}
+async function suggestFollowUps(goal, deps = {}) {
+  const { goal: cleanGoal } = normalizePlanRequest({ goal });
+  if (deps.generate) {
+    try {
+      const text2 = await deps.generate({ system: FOLLOW_UP_SYSTEM, prompt: `Learning goal: ${cleanGoal}` });
+      const questions = parseFollowUps(text2);
+      if (questions) return { questions, mode: "llm" };
+    } catch {
+    }
+  }
+  return { questions: DEFAULT_FOLLOW_UPS, mode: "offline" };
+}
+var PLAN_SYSTEM = `You plan a self-paced study playlist from free university courseware (MIT OpenCourseWare first) and lecture videos.
+From the learner's goal and answers, write 3 to 5 short search queries (a few words each, the way you would search a course catalog) that together cover what they need, in study order.
+If you know MIT course numbers that fit (for example 6.0001 or 18.06), list them too.
+Reply with JSON only, in this shape: {"title":"...","searches":["..."],"courses":["6.0001"]}`;
+function parseModelPlan(text2) {
+  const json = extractJson(text2);
+  if (!json || !Array.isArray(json.searches)) return null;
+  const strings = (value, max) => Array.isArray(value) ? value.filter((v) => typeof v === "string" && v.trim() !== "").map((v) => v.trim().slice(0, max)) : [];
+  const searches = strings(json.searches, 120).slice(0, MAX_SEARCHES);
+  if (searches.length === 0) return null;
+  return {
+    title: typeof json.title === "string" && json.title.trim() ? json.title.trim().slice(0, 120) : void 0,
+    searches,
+    courses: strings(json.courses, 20).slice(0, 10)
+  };
+}
+function readPreferences(answers = []) {
+  const text2 = answers.map((a) => a.answer.toLowerCase()).join(" | ");
+  const beginner = /\b(new|beginner|none|no background|never|starting out|from scratch)\b/.test(text2);
+  const advanced = /\b(comfortable|depth|advanced|expert|graduate|deep)\b/.test(text2);
+  const wantsVideos = /\bvideo|lecture|watch/.test(text2);
+  const wantsCourseware = /\bproblem|notes|reading|exercise|courseware|text/.test(text2);
+  const hours = text2.match(/(\d+(?:\.\d+)?)\s*(?:\+\s*)?(?:h|hr|hrs|hour|hours)\b/);
+  return {
+    maxLevel: beginner && !advanced ? "intermediate" : void 0,
+    preferAdvanced: advanced && !beginner,
+    format: wantsVideos && !wantsCourseware ? "videos" : wantsCourseware && !wantsVideos ? "courseware" : "mix",
+    minutesPerWeek: hours ? Math.round(Number(hours[1]) * 60) : void 0
+  };
+}
+var LEVEL_ORDER = { introductory: 0, intermediate: 1, advanced: 2 };
+function webItem(hit, query, index) {
+  const url = safeUrl(hit.url);
+  const title = typeof hit.title === "string" ? hit.title.trim().slice(0, 200) : "";
+  if (!url || !title) return null;
+  const isVideo = /youtube\.com|youtu\.be|vimeo\.com/.test(url);
+  return {
+    id: `web:${url}`,
+    title,
+    url,
+    kind: isVideo ? "video" : "reading",
+    minutes: WEB_ITEM_MINUTES,
+    estimate: "rough",
+    estimateBasis: "length unknown; budgeted at 1 h",
+    description: hit.snippet?.slice(0, 300),
+    provenance: {
+      provider: isVideo ? "youtube" : "web",
+      method: "llm_search",
+      verified: false,
+      note: `Found by the planner's web search for "${query}" (result ${index + 1}).`
+    }
+  };
+}
+async function planPlaylist(rawRequest, deps = {}) {
+  const { goal, answers = [] } = normalizePlanRequest(rawRequest);
+  const catalog = deps.catalog ?? getDefaultCatalog();
+  const items = catalogItems(catalog);
+  const prefs = readPreferences(answers);
+  let mode = "offline";
+  let plan = null;
+  if (deps.generate) {
+    try {
+      const prompt = [`Learning goal: ${goal}`, ...answers.map((a) => `Q: ${a.question}
+A: ${a.answer}`)].join("\n\n");
+      plan = parseModelPlan(await deps.generate({ system: PLAN_SYSTEM, prompt }));
+      if (plan) mode = "llm";
+    } catch {
+      plan = null;
+    }
+  }
+  const searches = plan?.searches ?? [
+    goal,
+    ...answers.map((a) => a.answer).filter((answer) => tokenize(answer).length >= 2 && !DEFAULT_FOLLOW_UPS.some((q) => q.options.includes(answer)))
+  ].slice(0, MAX_SEARCHES);
+  const picked = /* @__PURE__ */ new Map();
+  const take = (item) => {
+    if (!picked.has(item.id) && ![...picked.values()].some((p) => p.url === item.url)) picked.set(item.id, item);
+  };
+  for (const number of plan?.courses ?? []) {
+    for (const item of items) if (item.courseNumber?.toLowerCase() === number.toLowerCase()) take(item);
+  }
+  for (const query of searches) for (const item of searchCatalog(items, query, 6)) take(item);
+  if (deps.search) {
+    for (const query of searches.slice(0, 3)) {
+      try {
+        const hits = await deps.search(`${query} free course lecture videos`);
+        hits.slice(0, WEB_RESULTS_PER_SEARCH).forEach((hit, index) => {
+          const item = webItem(hit, query, index);
+          if (item) take(item);
+        });
+      } catch {
+      }
+    }
+  }
+  const chosen = [...picked.values()].filter((item) => !prefs.maxLevel || !item.level || LEVEL_ORDER[item.level] <= LEVEL_ORDER[prefs.maxLevel]).filter((item) => {
+    if (prefs.format === "videos") return item.kind === "video" || item.kind === "video_playlist";
+    if (prefs.format === "courseware") return item.kind !== "video" && item.kind !== "video_playlist";
+    return true;
+  }).map((item, order) => ({ item, order })).sort((a, b) => {
+    const la = a.item.level ? LEVEL_ORDER[a.item.level] : 1;
+    const lb = b.item.level ? LEVEL_ORDER[b.item.level] : 1;
+    return (prefs.preferAdvanced ? lb - la : la - lb) || a.order - b.order;
+  }).slice(0, MAX_PLAN_ITEMS).map((entry) => entry.item);
+  const playlist = createPlaylist({
+    title: plan?.title ?? `My path: ${goal.slice(0, 80)}`,
+    description: `Planned from: ${goal}`,
+    items: chosen,
+    plannedFrom: { goal, answers }
+  });
+  return { playlist, searches, mode, minutesPerWeek: prefs.minutesPerWeek };
+}
+
+// src/quiz.ts
+function buildQuizPrompt(item, questionCount = 5) {
+  return [
+    `Write a ${questionCount}-question multiple-choice quiz on "${item.title}"${item.courseNumber ? ` (${[item.institution, item.courseNumber].filter(Boolean).join(" ")})` : ""}.`,
+    "Use only the attached source material. Each question has 4 choices and exactly one correct answer, with a one-sentence explanation citing the material.",
+    'Reply with JSON only: {"questions":[{"prompt":"...","choices":["...","...","...","..."],"answerIndex":0,"explanation":"..."}]}'
+  ].join("\n");
+}
+function parseQuiz(item, raw, source) {
+  const r = raw && typeof raw === "object" ? raw : {};
+  if (!Array.isArray(r.questions)) return null;
+  const questions = r.questions.flatMap((entry) => {
+    const q = entry && typeof entry === "object" ? entry : {};
+    const choices = Array.isArray(q.choices) ? q.choices.filter((c2) => typeof c2 === "string") : [];
+    const answerIndex = Number(q.answerIndex);
+    if (typeof q.prompt !== "string" || choices.length < 2 || !Number.isInteger(answerIndex) || answerIndex < 0 || answerIndex >= choices.length) return [];
+    return [{ prompt: q.prompt, choices, answerIndex, explanation: typeof q.explanation === "string" ? q.explanation : void 0 }];
+  });
+  return questions.length ? { itemId: item.id, title: `Quiz: ${item.title}`, questions, source } : null;
+}
+
+// src/api/client.ts
+async function post(url, body, signal) {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body),
+    signal
+  });
+  if (!res.ok) throw new Error(`Planner request failed (${res.status})`);
+  return await res.json();
+}
+async function fetchFollowUps(goal, endpoint, signal) {
+  if (endpoint) {
+    try {
+      const result = await post(`${endpoint.replace(/\/+$/, "")}/questions`, { goal }, signal);
+      if (Array.isArray(result?.questions) && result.questions.length) return result;
+    } catch (error) {
+      if (error.name === "AbortError") throw error;
+    }
+  }
+  return suggestFollowUps(goal);
+}
+async function fetchPlan(goal, answers, endpoint, signal) {
+  if (endpoint) {
+    try {
+      const result = await post(endpoint.replace(/\/+$/, ""), { goal, answers }, signal);
+      const playlist = sanitizePlaylist({ ...result?.playlist, visibility: "private" });
+      if (playlist) {
+        return {
+          ...result,
+          playlist: { ...playlist, visibility: "private", members: [], plannedFrom: { goal, answers } }
+        };
+      }
+    } catch (error) {
+      if (error.name === "AbortError") throw error;
+    }
+  }
+  return planPlaylist({ goal, answers });
+}
+
+// src/components/EducationPlaylists.tsx
+var import_react3 = require("react");
+
+// src/components/PlaylistView.tsx
+var import_react = require("react");
+
+// src/components/styles.ts
+var line = "1px solid rgba(127,127,127,0.3)";
+var s = {
+  root: { fontFamily: "system-ui, sans-serif", display: "flex", flexDirection: "column", gap: 8, padding: "10px 14px", borderRadius: 8, fontSize: 13, lineHeight: 1.4, minWidth: 0 },
+  headerRow: { display: "flex", alignItems: "center", justifyContent: "space-between", gap: 8 },
+  label: { fontSize: 11, fontWeight: 600, opacity: 0.75, letterSpacing: 0.3, textTransform: "uppercase" },
+  muted: { opacity: 0.7, fontSize: 12 },
+  row: { display: "flex", alignItems: "center", gap: 6, flexWrap: "wrap" },
+  scrollRow: { display: "flex", gap: 6, overflowX: "auto", paddingBottom: 2, scrollbarWidth: "thin" },
+  chip: { border: line, borderRadius: 999, padding: "2px 10px", fontSize: 12, background: "transparent", color: "inherit", cursor: "pointer", whiteSpace: "nowrap" },
+  chipActive: { background: "rgba(127,127,127,0.22)", borderColor: "rgba(127,127,127,0.6)" },
+  button: { border: line, borderRadius: 6, padding: "4px 10px", fontSize: 12, background: "rgba(127,127,127,0.12)", color: "inherit", cursor: "pointer" },
+  primary: { border: "1px solid rgba(99,102,241,0.7)", borderRadius: 6, padding: "5px 12px", fontSize: 12, fontWeight: 600, background: "rgba(99,102,241,0.25)", color: "inherit", cursor: "pointer" },
+  iconButton: { border: "none", background: "transparent", color: "inherit", cursor: "pointer", padding: 2, opacity: 0.75, display: "flex" },
+  input: { flex: 1, minWidth: 0, border: line, borderRadius: 6, padding: "5px 8px", fontSize: 13, background: "rgba(127,127,127,0.08)", color: "inherit" },
+  card: { border: line, borderRadius: 8, padding: "8px 10px", background: "rgba(127,127,127,0.06)", textAlign: "left", color: "inherit", cursor: "pointer", display: "flex", flexDirection: "column", gap: 4, minWidth: 0 },
+  compactCard: { border: line, borderRadius: 8, padding: "6px 10px", background: "rgba(127,127,127,0.06)", textAlign: "left", color: "inherit", cursor: "pointer", display: "flex", flexDirection: "column", gap: 2, minWidth: 150, maxWidth: 190, flex: "0 0 auto" },
+  title: { fontWeight: 600, fontSize: 13 },
+  bar: { height: 4, borderRadius: 2, background: "rgba(127,127,127,0.25)", overflow: "hidden" },
+  barFill: { height: "100%", background: "rgba(34,197,94,0.85)" },
+  list: { listStyle: "none", margin: 0, padding: 0, display: "flex", flexDirection: "column", gap: 4 },
+  item: { display: "flex", alignItems: "flex-start", gap: 8, padding: "6px 4px", borderBottom: "1px solid rgba(127,127,127,0.15)" },
+  link: { color: "inherit", textDecoration: "none", fontWeight: 500 },
+  badge: { fontSize: 10, border: line, borderRadius: 4, padding: "0 5px", opacity: 0.8, whiteSpace: "nowrap" },
+  section: { display: "flex", flexDirection: "column", gap: 6 }
+};
+
+// src/components/PlaylistView.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var KIND_LABEL = {
+  video_playlist: "Videos",
+  video: "Video",
+  courseware: "Courseware",
+  lecture_notes: "Notes",
+  assignment: "Assignment",
+  reading: "Reading",
+  textbook: "Textbook"
+};
+var PROVIDER_LABEL = {
+  mit_ocw: "MIT OCW",
+  youtube: "YouTube",
+  edx: "edX",
+  coursera: "Coursera",
+  khan: "Khan Academy",
+  openstax: "OpenStax",
+  web: "Web"
+};
+var METHOD_LABEL = {
+  curated_seed: "curated",
+  official_api: "official",
+  snapshot_dataset: "dataset",
+  community_list: "community",
+  llm_search: "AI search",
+  user: "added"
+};
+function ItemRow({
+  item,
+  checked,
+  onToggle,
+  onRemove,
+  quizGenerator
+}) {
+  const [quiz, setQuiz] = (0, import_react.useState)(null);
+  const [quizState, setQuizState] = (0, import_react.useState)("idle");
+  const generateQuiz = async () => {
+    if (!quizGenerator) return;
+    setQuizState("loading");
+    try {
+      setQuiz(await quizGenerator(item));
+      setQuizState("idle");
+    } catch {
+      setQuizState("error");
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("li", { style: s.item, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      "input",
+      {
+        type: "checkbox",
+        checked,
+        onChange: onToggle,
+        "aria-label": `Mark "${item.title}" ${checked ? "not done" : "done"}`,
+        style: { marginTop: 3, cursor: "pointer" }
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: { flex: 1, minWidth: 0, display: "flex", flexDirection: "column", gap: 2 }, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        "a",
+        {
+          href: item.url,
+          target: "_blank",
+          rel: "noopener noreferrer",
+          style: { ...s.link, textDecoration: checked ? "line-through" : "none", opacity: checked ? 0.6 : 1 },
+          children: item.title
+        }
+      ),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: { ...s.row, ...s.muted }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { style: s.badge, children: KIND_LABEL[item.kind] }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { title: item.estimateBasis, children: [
+          item.estimate === "rough" ? "~" : "",
+          formatMinutes(item.minutes)
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { style: s.badge, title: item.provenance.note, children: [
+          PROVIDER_LABEL[item.provenance.provider] ?? item.provenance.provider,
+          " \xB7 ",
+          METHOD_LABEL[item.provenance.method] ?? item.provenance.method
+        ] }),
+        quizGenerator && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "button", style: { ...s.chip, padding: "0 8px" }, onClick: generateQuiz, disabled: quizState === "loading", children: quizState === "loading" ? "Writing quiz\u2026" : quizState === "error" ? "Quiz failed, retry" : "Quiz me" }),
+        onRemove && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "button", style: { ...s.chip, padding: "0 8px" }, onClick: onRemove, "aria-label": `Remove "${item.title}"`, children: "Remove" })
+      ] }),
+      quiz && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("ol", { style: { margin: "4px 0 0", paddingLeft: 18, fontSize: 12 }, children: quiz.questions.map((question, index) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("li", { children: [
+        question.prompt,
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("details", { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("summary", { style: { cursor: "pointer", opacity: 0.7 }, children: "Answer" }),
+          question.choices[question.answerIndex],
+          question.explanation ? ` \u2014 ${question.explanation}` : ""
+        ] })
+      ] }, index)) })
+    ] })
+  ] });
+}
+function SharingControls({ playlist, onChange, shareBaseHref }) {
+  const [email, setEmail] = (0, import_react.useState)("");
+  const [message, setMessage] = (0, import_react.useState)(null);
+  const copyShareLink = async () => {
+    const base = shareBaseHref ?? (typeof window !== "undefined" ? `${window.location.origin}${window.location.pathname}` : "");
+    const link = `${base}#${encodeShareFragment(playlist)}`;
+    try {
+      await navigator.clipboard.writeText(link);
+      setMessage("Share link copied.");
+    } catch {
+      setMessage(link);
+    }
+  };
+  const addInvite = () => {
+    try {
+      onChange(invite(playlist, email, "viewer"));
+      setEmail("");
+      setMessage(null);
+    } catch (error) {
+      setMessage(error.message);
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: s.section, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: s.row, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { style: s.muted, children: "Visibility:" }),
+      ["private", "public"].map((visibility) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        "button",
+        {
+          type: "button",
+          style: { ...s.chip, ...playlist.visibility === visibility ? s.chipActive : null },
+          onClick: () => onChange({ ...playlist, visibility }),
+          "aria-pressed": playlist.visibility === visibility,
+          children: visibility === "private" ? "Private" : "Public"
+        },
+        visibility
+      )),
+      playlist.visibility === "public" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "button", style: s.button, onClick: copyShareLink, children: "Copy share link" })
+    ] }),
+    playlist.visibility === "private" && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+        "form",
+        {
+          style: s.row,
+          onSubmit: (event) => {
+            event.preventDefault();
+            addInvite();
+          },
+          children: [
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)("input", { style: s.input, type: "email", placeholder: "Invite by email", value: email, onChange: (event) => setEmail(event.target.value), "aria-label": "Invite by email" }),
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "submit", style: s.button, disabled: !email.trim(), children: "Invite" })
+          ]
+        }
+      ),
+      (playlist.members ?? []).map((member) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: { ...s.row, ...s.muted }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: member.email }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { style: s.badge, children: member.status === "invited" ? "invite pending" : member.role }),
+        member.email && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "button", style: { ...s.chip, padding: "0 8px" }, onClick: () => onChange(removeMember(playlist, member.email)), children: "Remove" })
+      ] }, member.email ?? member.userId))
+    ] }),
+    message && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { style: { ...s.muted, wordBreak: "break-all" }, children: message })
+  ] });
+}
+function PlaylistView({ playlist, done, onToggle, onChange, onSaveCopy, minutesPerWeek, shareBaseHref, quizGenerator }) {
+  const time = playlistTime(playlist, done);
+  const weeks = weeksToFinish(time.remainingMinutes, minutesPerWeek);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: s.section, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { style: s.title, children: playlist.title }),
+      playlist.description && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { style: s.muted, children: playlist.description })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: { ...s.row, ...s.muted }, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { children: [
+        time.doneCount,
+        "/",
+        time.itemCount,
+        " done"
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { children: [
+        "\xB7 ~",
+        formatMinutes(time.remainingMinutes),
+        " left of ~",
+        formatMinutes(time.totalMinutes)
+      ] }),
+      weeks !== null && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { children: [
+        "\xB7 about ",
+        weeks,
+        " week",
+        weeks === 1 ? "" : "s",
+        " at your pace"
+      ] })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { style: s.bar, role: "progressbar", "aria-valuenow": time.percent, "aria-valuemin": 0, "aria-valuemax": 100, "aria-label": "Progress by time", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { style: { ...s.barFill, width: `${time.percent}%` } }) }),
+    playlist.items.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { style: s.muted, children: "Nothing matched yet. Try different wording, or answer the questions in your own words." }) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)("ul", { style: s.list, children: playlist.items.map((item) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      ItemRow,
+      {
+        item,
+        checked: done.has(item.id),
+        onToggle: () => onToggle(item.id),
+        onRemove: onChange ? () => onChange(removeItem(playlist, item.id)) : void 0,
+        quizGenerator
+      },
+      item.id
+    )) }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { style: s.row, children: onSaveCopy && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "button", style: s.primary, onClick: () => onSaveCopy(playlist), children: "Save to my playlists" }) }),
+    onChange && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SharingControls, { playlist, onChange, shareBaseHref })
+  ] });
+}
+
+// src/components/PlaylistPlanner.tsx
+var import_react2 = require("react");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var MODE_NOTE = {
+  llm: "Questions written by AI for your goal.",
+  offline: "AI is not connected here, so these are the standard questions."
+};
+function PlaylistPlanner({ planEndpoint, onPlanned, initialGoal = "" }) {
+  const [goal, setGoal] = (0, import_react2.useState)(initialGoal);
+  const [questions, setQuestions] = (0, import_react2.useState)(null);
+  const [mode, setMode] = (0, import_react2.useState)(null);
+  const [answers, setAnswers] = (0, import_react2.useState)({});
+  const [busy, setBusy] = (0, import_react2.useState)(null);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const abort = (0, import_react2.useRef)(null);
+  const run = async (kind, task) => {
+    abort.current?.abort();
+    const controller = new AbortController();
+    abort.current = controller;
+    setBusy(kind);
+    setError(null);
+    try {
+      return await task(controller.signal);
+    } catch (err) {
+      if (err.name !== "AbortError") setError(err.message);
+      return null;
+    } finally {
+      if (abort.current === controller) setBusy(null);
+    }
+  };
+  const askQuestions = async () => {
+    const result = await run("questions", (signal) => fetchFollowUps(goal, planEndpoint, signal));
+    if (!result) return;
+    setQuestions(result.questions);
+    setMode(result.mode);
+    setAnswers({});
+  };
+  const buildPlan = async () => {
+    const answered = (questions ?? []).map((question) => ({ question: question.question, answer: (answers[question.id] ?? "").trim() })).filter((entry) => entry.answer);
+    const result = await run("plan", (signal) => fetchPlan(goal, answered, planEndpoint, signal));
+    if (result) onPlanned(result);
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { style: s.section, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+      "form",
+      {
+        style: s.row,
+        onSubmit: (event) => {
+          event.preventDefault();
+          if (goal.trim()) void askQuestions();
+        },
+        children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+            "input",
+            {
+              style: s.input,
+              value: goal,
+              maxLength: MAX_GOAL_LENGTH,
+              onChange: (event) => setGoal(event.target.value),
+              placeholder: "What do you want to learn? e.g. machine learning from scratch",
+              "aria-label": "What do you want to learn?"
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("button", { type: "submit", style: s.primary, disabled: !goal.trim() || busy !== null, children: busy === "questions" ? "Thinking\u2026" : questions ? "Ask again" : "Start" })
+        ]
+      }
+    ),
+    questions && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { style: s.section, children: [
+      mode && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { style: s.muted, children: MODE_NOTE[mode] }),
+      questions.map((question) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("fieldset", { style: { border: "none", padding: 0, margin: 0, display: "flex", flexDirection: "column", gap: 4 }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("legend", { style: { fontWeight: 500, padding: 0, marginBottom: 4 }, children: question.question }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { style: s.row, children: question.options.map((option) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+          "button",
+          {
+            type: "button",
+            style: { ...s.chip, ...answers[question.id] === option ? s.chipActive : null },
+            "aria-pressed": answers[question.id] === option,
+            onClick: () => setAnswers((prev) => ({ ...prev, [question.id]: prev[question.id] === option ? "" : option })),
+            children: option
+          },
+          option
+        )) }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+          "input",
+          {
+            style: s.input,
+            value: answers[question.id] ?? "",
+            maxLength: MAX_ANSWER_LENGTH,
+            onChange: (event) => setAnswers((prev) => ({ ...prev, [question.id]: event.target.value })),
+            placeholder: "Or say it in your own words",
+            "aria-label": `Your answer: ${question.question}`
+          }
+        )
+      ] }, question.id)),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { style: s.row, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("button", { type: "button", style: s.primary, onClick: () => void buildPlan(), disabled: busy !== null, children: busy === "plan" ? "Planning\u2026" : "Build my playlist" }) })
+    ] }),
+    error && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { style: { ...s.muted, color: "#ef4444" }, children: error })
+  ] });
+}
+
+// src/components/EducationPlaylists.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+function ChevronIcon({ up }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("svg", { width: 14, height: 14, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: 2, strokeLinecap: "round", strokeLinejoin: "round", style: { transform: up ? "rotate(180deg)" : void 0, transition: "transform 150ms ease" }, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("polyline", { points: "6 9 12 15 18 9" }) });
+}
+function PlaylistCard({ playlist, done, onOpen, compact }) {
+  const time = playlistTime(playlist, done);
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("button", { type: "button", style: compact ? s.compactCard : s.card, onClick: onOpen, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { style: { ...s.title, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: compact ? "nowrap" : void 0 }, children: playlist.title }),
+    !compact && playlist.description && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { style: s.muted, children: playlist.description }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("span", { style: s.muted, children: [
+      time.itemCount,
+      " items \xB7 ~",
+      formatMinutes(time.totalMinutes),
+      time.percent > 0 ? ` \xB7 ${time.percent}% done` : ""
+    ] }),
+    time.percent > 0 && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { style: s.bar, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { style: { ...s.barFill, display: "block", width: `${time.percent}%` } }) })
+  ] });
+}
+function EducationPlaylists({
+  className,
+  style,
+  compact = false,
+  catalog: catalogProp,
+  planEndpoint,
+  openHref,
+  shareBaseHref,
+  importFromHash = false,
+  userId,
+  quizGenerator
+}) {
+  const catalog = (0, import_react3.useMemo)(() => catalogProp ?? getDefaultCatalog(), [catalogProp]);
+  const progressStore = (0, import_react3.useMemo)(() => createProgressStore(), []);
+  const playlistStore = (0, import_react3.useMemo)(() => createLocalPlaylistStore(), []);
+  const [expanded, setExpanded] = (0, import_react3.useState)(!compact);
+  const [tab, setTab] = (0, import_react3.useState)("browse");
+  const [done, setDone] = (0, import_react3.useState)(() => /* @__PURE__ */ new Set());
+  const [mine, setMine] = (0, import_react3.useState)([]);
+  const [categoryId, setCategoryId] = (0, import_react3.useState)();
+  const [majorId, setMajorId] = (0, import_react3.useState)();
+  const [programId, setProgramId] = (0, import_react3.useState)();
+  const [open, setOpen] = (0, import_react3.useState)(null);
+  (0, import_react3.useEffect)(() => {
+    setDone(progressStore.load());
+    setMine(playlistStore.list());
+  }, [progressStore, playlistStore]);
+  (0, import_react3.useEffect)(() => {
+    if (!importFromHash || typeof window === "undefined") return;
+    const shared = decodeShareFragment(window.location.hash);
+    if (shared) {
+      setExpanded(true);
+      setOpen({ playlist: shared, source: "shared" });
+    }
+  }, [importFromHash]);
+  const category = catalog.categories.find((c2) => c2.id === categoryId);
+  const major = category?.majors.find((m) => m.id === majorId);
+  const visible = filterPlaylists(catalog.playlists, { categoryId, majorId, programId });
+  const toggle = (itemId) => {
+    setDone((prev) => {
+      const next = toggleDone(prev, itemId);
+      progressStore.save(next);
+      return next;
+    });
+  };
+  const saveMine = (playlist) => {
+    setMine(playlistStore.save({ ...playlist, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }));
+    setOpen((current) => current?.playlist.id === playlist.id ? { ...current, playlist } : current);
+  };
+  const saveCopy = (playlist) => {
+    const copy = createPlaylist({
+      title: playlist.title,
+      description: playlist.description,
+      items: playlist.items,
+      ownerId: userId,
+      plannedFrom: playlist.plannedFrom
+    });
+    setMine(playlistStore.save(copy));
+    setOpen({ playlist: copy, source: "mine" });
+    setTab("mine");
+  };
+  const deleteMine = (id) => {
+    setMine(playlistStore.remove(id));
+    setOpen(null);
+  };
+  const openPlaylist = (playlist, source) => {
+    setExpanded(true);
+    setOpen({ playlist, source });
+  };
+  const shareBase = shareBaseHref ?? (openHref && typeof window !== "undefined" ? new URL(openHref, window.location.href).toString() : void 0);
+  const header = /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { style: s.headerRow, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { style: { display: "flex", alignItems: "baseline", gap: 8, minWidth: 0 }, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { style: s.label, children: "Learn" }),
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("span", { style: { ...s.muted, whiteSpace: "nowrap", overflow: "hidden", textOverflow: "ellipsis" }, children: [
+        catalog.playlists.length,
+        " playlists \xB7 MIT OpenCourseWare"
+      ] })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { style: { display: "flex", alignItems: "center", gap: 6 }, children: [
+      compact && !expanded && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+        "button",
+        {
+          type: "button",
+          style: s.chip,
+          onClick: () => {
+            setExpanded(true);
+            setTab("plan");
+            setOpen(null);
+          },
+          children: "Plan my own"
+        }
+      ),
+      compact && openHref && expanded && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("a", { href: openHref, style: { ...s.chip, textDecoration: "none" }, children: "Open full page" }),
+      compact && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("button", { type: "button", style: s.iconButton, onClick: () => setExpanded((v) => !v), "aria-expanded": expanded, "aria-label": expanded ? "Collapse education playlists" : "Expand education playlists", children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(ChevronIcon, { up: expanded }) })
+    ] })
+  ] });
+  if (compact && !expanded) {
+    return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("section", { className, style: { ...s.root, ...style }, "aria-label": "Education playlists", children: [
+      header,
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { style: s.scrollRow, children: [...mine, ...catalog.playlists].map((playlist) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(PlaylistCard, { playlist, done, compact: true, onOpen: () => openPlaylist(playlist, playlist.visibility === "preset" ? "preset" : "mine") }, playlist.id)) })
+    ] });
+  }
+  const tabs = [
+    { id: "browse", label: "Browse" },
+    { id: "mine", label: `My playlists${mine.length ? ` (${mine.length})` : ""}` },
+    { id: "plan", label: "Plan with AI" }
+  ];
+  let body;
+  if (open) {
+    const editable = open.source === "mine";
+    body = /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { style: s.section, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { style: s.row, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("button", { type: "button", style: s.button, onClick: () => setOpen(null), children: "\u2190 Back" }),
+        open.source === "shared" && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { style: s.muted, children: "Shared with you by link" }),
+        open.source === "planned" && open.plan && /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("span", { style: s.muted, children: [
+          open.plan.mode === "llm" ? "Planned by AI" : "Planned from the catalog (AI not connected)",
+          " from: ",
+          open.plan.searches.join(" \xB7 ")
+        ] }),
+        editable && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("button", { type: "button", style: s.button, onClick: () => deleteMine(open.playlist.id), children: "Delete" })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+        PlaylistView,
+        {
+          playlist: open.playlist,
+          done,
+          onToggle: toggle,
+          onChange: editable ? saveMine : void 0,
+          onSaveCopy: editable ? void 0 : saveCopy,
+          minutesPerWeek: open.plan?.minutesPerWeek,
+          shareBaseHref: shareBase,
+          quizGenerator
+        }
+      )
+    ] });
+  } else if (tab === "browse") {
+    body = /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { style: s.section, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { style: s.row, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("button", { type: "button", style: { ...s.chip, ...!categoryId ? s.chipActive : null }, onClick: () => {
+          setCategoryId(void 0);
+          setMajorId(void 0);
+          setProgramId(void 0);
+        }, children: "All" }),
+        catalog.categories.map((c2) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("button", { type: "button", style: { ...s.chip, ...categoryId === c2.id ? s.chipActive : null }, "aria-pressed": categoryId === c2.id, onClick: () => {
+          setCategoryId(c2.id);
+          setMajorId(void 0);
+          setProgramId(void 0);
+        }, children: c2.name }, c2.id))
+      ] }),
+      category && /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { style: s.row, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { style: s.muted, children: "Major:" }),
+        category.majors.map((m) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("button", { type: "button", style: { ...s.chip, ...majorId === m.id ? s.chipActive : null }, "aria-pressed": majorId === m.id, onClick: () => {
+          setMajorId(majorId === m.id ? void 0 : m.id);
+          setProgramId(void 0);
+        }, children: m.name }, m.id))
+      ] }),
+      major && major.programs.length > 1 && /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { style: s.row, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { style: s.muted, children: "Program:" }),
+        major.programs.map((p) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("button", { type: "button", style: { ...s.chip, ...programId === p.id ? s.chipActive : null }, "aria-pressed": programId === p.id, onClick: () => setProgramId(programId === p.id ? void 0 : p.id), children: p.name }, p.id))
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { style: { display: "grid", gridTemplateColumns: "repeat(auto-fill, minmax(200px, 1fr))", gap: 6 }, children: visible.map((playlist) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(PlaylistCard, { playlist, done, onOpen: () => openPlaylist(playlist, "preset") }, playlist.id)) })
+    ] });
+  } else if (tab === "mine") {
+    body = mine.length ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { style: { display: "grid", gridTemplateColumns: "repeat(auto-fill, minmax(200px, 1fr))", gap: 6 }, children: mine.map((playlist) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(PlaylistCard, { playlist, done, onOpen: () => openPlaylist(playlist, "mine") }, playlist.id)) }) : /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { style: s.muted, children: "Nothing saved yet. Save a preset playlist, or plan your own with AI." });
+  } else {
+    body = /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(PlaylistPlanner, { planEndpoint, onPlanned: (result) => setOpen({ playlist: result.playlist, source: "planned", plan: result }) });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("section", { className, style: { ...s.root, ...style }, "aria-label": "Education playlists", children: [
+    header,
+    !open && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { style: s.row, role: "tablist", children: tabs.map((t) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("button", { type: "button", role: "tab", "aria-selected": tab === t.id, style: { ...s.chip, ...tab === t.id ? s.chipActive : null }, onClick: () => setTab(t.id), children: t.label }, t.id)) }),
+    body
+  ] });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_FOLLOW_UPS,
+  EDUCATION_CATEGORIES,
+  EducationPlaylists,
+  MAX_ANSWERS,
+  MAX_ANSWER_LENGTH,
+  MAX_GOAL_LENGTH,
+  MAX_PLAN_ITEMS,
+  MAX_PLAYLIST_ITEMS,
+  MIT_OCW_PRESET_PLAYLISTS,
+  MIT_OCW_SEED_COURSES,
+  PLAYLISTS_STORAGE_KEY,
+  PROGRESS_STORAGE_KEY,
+  PlaylistPlanner,
+  PlaylistView,
+  SHARE_HASH_PARAM,
+  acceptInvite,
+  addItem,
+  buildQuizPrompt,
+  canEdit,
+  canView,
+  catalogItems,
+  createLocalPlaylistStore,
+  createPlaylist,
+  createProgressStore,
+  decodeShareFragment,
+  encodeShareFragment,
+  extractJson,
+  fetchFollowUps,
+  fetchPlan,
+  filterPlaylists,
+  formatMinutes,
+  getDefaultCatalog,
+  invite,
+  moveItem,
+  normalizePlanRequest,
+  parseQuiz,
+  planPlaylist,
+  playlistTime,
+  readPreferences,
+  removeItem,
+  removeMember,
+  safeUrl,
+  sanitizeItem,
+  sanitizePlaylist,
+  searchCatalog,
+  suggestFollowUps,
+  toggleDone,
+  tokenize,
+  weeksToFinish
+});
+//# sourceMappingURL=index.cjs.map