@churchapps/content-provider-helper 0.0.1 → 0.0.3

package/dist/index.cjs

@@ -21,20 +21,44 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   APlayProvider: () => APlayProvider,
+  ApiHelper: () => ApiHelper,
   B1ChurchProvider: () => B1ChurchProvider,
   BibleProjectProvider: () => BibleProjectProvider,
   ContentProvider: () => ContentProvider,
+  DeviceFlowHelper: () => DeviceFlowHelper,
+  FormatConverters: () => FormatConverters_exports,
+  FormatResolver: () => FormatResolver,
+  HighVoltageKidsProvider: () => HighVoltageKidsProvider,
   LessonsChurchProvider: () => LessonsChurchProvider,
+  OAuthHelper: () => OAuthHelper,
   PlanningCenterProvider: () => PlanningCenterProvider,
   SignPresenterProvider: () => SignPresenterProvider,
+  TokenHelper: () => TokenHelper,
   VERSION: () => VERSION,
+  appendToPath: () => appendToPath,
+  buildPath: () => buildPath,
+  collapseInstructions: () => collapseInstructions,
+  createFile: () => createFile,
+  createFolder: () => createFolder,
   detectMediaType: () => detectMediaType,
+  expandedInstructionsToPlaylist: () => expandedInstructionsToPlaylist,
+  expandedInstructionsToPresentations: () => expandedInstructionsToPresentations,
   getAllProviders: () => getAllProviders,
   getAvailableProviders: () => getAvailableProviders,
   getProvider: () => getProvider,
   getProviderConfig: () => getProviderConfig,
+  getSegment: () => getSegment,
+  instructionsToPlaylist: () => instructionsToPlaylist,
+  instructionsToPresentations: () => instructionsToPresentations,
   isContentFile: () => isContentFile,
   isContentFolder: () => isContentFolder,
+  parsePath: () => parsePath,
+  playlistToExpandedInstructions: () => playlistToExpandedInstructions,
+  playlistToInstructions: () => playlistToInstructions,
+  playlistToPresentations: () => playlistToPresentations,
+  presentationsToExpandedInstructions: () => presentationsToExpandedInstructions,
+  presentationsToInstructions: () => presentationsToInstructions,
+  presentationsToPlaylist: () => presentationsToPlaylist,
   registerProvider: () => registerProvider
 });
 module.exports = __toCommonJS(index_exports);
@@ -53,105 +77,379 @@ function detectMediaType(url, explicitType) {
   const videoPatterns = [".mp4", ".webm", ".m3u8", ".mov", "stream.mux.com"];
   return videoPatterns.some((p) => url.includes(p)) ? "video" : "image";
 }
+function createFolder(id, title, path, image, providerData, isLeaf) {
+  return { type: "folder", id, title, path, image, isLeaf, providerData };
+}
+function createFile(id, title, url, options) {
+  return { type: "file", id, title, url, mediaType: options?.mediaType ?? detectMediaType(url), image: options?.image, muxPlaybackId: options?.muxPlaybackId, providerData: options?.providerData };
+}
 
-// src/ContentProvider.ts
-var ContentProvider = class {
-  /**
-   * Get a flat list of media files (playlist) for a folder.
-   * Override in subclass if the provider supports playlists.
-   * @param _folder - The folder to get playlist for (typically a venue or playlist folder)
-   * @param _auth - Optional authentication data
-   * @param _resolution - Optional resolution hint for video quality
-   * @returns Array of ContentFile objects, or null if not supported
-   */
-  getPlaylist(_folder, _auth, _resolution) {
-    return Promise.resolve(null);
+// src/pathUtils.ts
+function parsePath(path) {
+  if (!path || path === "/" || path === "") {
+    return { segments: [], depth: 0 };
   }
-  /**
-   * Get instruction/run sheet data for a folder.
-   * Override in subclass if the provider supports instructions.
-   * @param _folder - The folder to get instructions for
-   * @param _auth - Optional authentication data
-   * @returns Instructions object, or null if not supported
-   */
-  getInstructions(_folder, _auth) {
-    return Promise.resolve(null);
+  const segments = path.replace(/^\//, "").split("/").filter(Boolean);
+  return { segments, depth: segments.length };
+}
+function getSegment(path, index) {
+  const { segments } = parsePath(path);
+  return segments[index] ?? null;
+}
+function buildPath(segments) {
+  if (segments.length === 0) return "";
+  return "/" + segments.join("/");
+}
+function appendToPath(basePath, segment) {
+  if (!basePath || basePath === "/" || basePath === "") {
+    return "/" + segment;
   }
-  /**
-   * Get expanded instruction data with actions for a folder.
-   * Override in subclass if the provider supports expanded instructions.
-   * @param _folder - The folder to get expanded instructions for
-   * @param _auth - Optional authentication data
-   * @returns Instructions object with expanded action data, or null if not supported
-   */
-  getExpandedInstructions(_folder, _auth) {
-    return Promise.resolve(null);
+  const cleanBase = basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
+  return cleanBase + "/" + segment;
+}
+
+// src/FormatConverters.ts
+var FormatConverters_exports = {};
+__export(FormatConverters_exports, {
+  collapseInstructions: () => collapseInstructions,
+  expandedInstructionsToPlaylist: () => expandedInstructionsToPlaylist,
+  expandedInstructionsToPresentations: () => expandedInstructionsToPresentations,
+  instructionsToPlaylist: () => instructionsToPlaylist,
+  instructionsToPresentations: () => instructionsToPresentations,
+  playlistToExpandedInstructions: () => playlistToExpandedInstructions,
+  playlistToInstructions: () => playlistToInstructions,
+  playlistToPresentations: () => playlistToPresentations,
+  presentationsToExpandedInstructions: () => presentationsToExpandedInstructions,
+  presentationsToInstructions: () => presentationsToInstructions,
+  presentationsToPlaylist: () => presentationsToPlaylist
+});
+function generateId() {
+  return "gen-" + Math.random().toString(36).substring(2, 11);
+}
+function mapItemTypeToActionType(itemType) {
+  switch (itemType) {
+    case "action":
+    case "lessonAction":
+    case "providerPresentation":
+    case "play":
+      return "play";
+    case "addon":
+    case "add-on":
+    case "lessonAddOn":
+    case "providerFile":
+      return "add-on";
+    default:
+      return "other";
   }
-  /**
-   * Check if this provider requires authentication.
-   * @returns true if authentication is required
-   */
-  requiresAuth() {
-    return !!this.config.clientId;
+}
+function mapActionTypeToItemType(actionType) {
+  switch (actionType) {
+    case "play":
+      return "action";
+    case "add-on":
+      return "addon";
+    default:
+      return "item";
   }
-  /**
-   * Get the capabilities supported by this provider.
-   * Override in subclass to indicate supported features.
-   * @returns ProviderCapabilities object
-   */
-  getCapabilities() {
+}
+function presentationsToPlaylist(plan) {
+  if (plan.allFiles && plan.allFiles.length > 0) {
+    return [...plan.allFiles];
+  }
+  const files = [];
+  for (const section of plan.sections) {
+    for (const presentation of section.presentations) {
+      files.push(...presentation.files);
+    }
+  }
+  return files;
+}
+function presentationsToInstructions(plan) {
+  return { venueName: plan.name, items: plan.sections.map((section) => ({ id: section.id, itemType: "section", label: section.name, children: section.presentations.map((pres) => {
+    const totalSeconds = pres.files.reduce((sum, f) => sum + (f.providerData?.seconds || 0), 0);
+    return { id: pres.id, itemType: mapActionTypeToItemType(pres.actionType), label: pres.name, seconds: totalSeconds || void 0, embedUrl: pres.files[0]?.embedUrl || pres.files[0]?.url };
+  }) })) };
+}
+function presentationsToExpandedInstructions(plan) {
+  return { venueName: plan.name, items: plan.sections.map((section) => ({ id: section.id, itemType: "section", label: section.name, children: section.presentations.map((pres) => ({ id: pres.id, itemType: mapActionTypeToItemType(pres.actionType), label: pres.name, description: pres.actionType !== "other" ? pres.actionType : void 0, seconds: pres.files.reduce((sum, f) => sum + (f.providerData?.seconds || 0), 0) || void 0, children: pres.files.map((f) => ({ id: f.id, itemType: "file", label: f.title, seconds: f.providerData?.seconds || void 0, embedUrl: f.embedUrl || f.url })) })) })) };
+}
+function instructionsToPlaylist(instructions) {
+  const files = [];
+  function extractFiles(items) {
+    for (const item of items) {
+      if (item.embedUrl && (item.itemType === "file" || !item.children?.length)) {
+        files.push({ type: "file", id: item.id || item.relatedId || generateId(), title: item.label || "Untitled", mediaType: detectMediaType(item.embedUrl), url: item.embedUrl, embedUrl: item.embedUrl, providerData: item.seconds ? { seconds: item.seconds } : void 0 });
+      }
+      if (item.children) {
+        extractFiles(item.children);
+      }
+    }
+  }
+  extractFiles(instructions.items);
+  return files;
+}
+var expandedInstructionsToPlaylist = instructionsToPlaylist;
+function instructionsToPresentations(instructions, planId) {
+  const allFiles = [];
+  const sections = instructions.items.filter((item) => item.children && item.children.length > 0).map((sectionItem) => {
+    const presentations = (sectionItem.children || []).map((presItem) => {
+      const files = [];
+      if (presItem.children && presItem.children.length > 0) {
+        for (const child of presItem.children) {
+          if (child.embedUrl) {
+            const file = { type: "file", id: child.id || child.relatedId || generateId(), title: child.label || "Untitled", mediaType: detectMediaType(child.embedUrl), url: child.embedUrl, embedUrl: child.embedUrl, providerData: child.seconds ? { seconds: child.seconds } : void 0 };
+            allFiles.push(file);
+            files.push(file);
+          }
+        }
+      }
+      if (files.length === 0 && presItem.embedUrl) {
+        const file = { type: "file", id: presItem.id || presItem.relatedId || generateId(), title: presItem.label || "Untitled", mediaType: detectMediaType(presItem.embedUrl), url: presItem.embedUrl, embedUrl: presItem.embedUrl, providerData: presItem.seconds ? { seconds: presItem.seconds } : void 0 };
+        allFiles.push(file);
+        files.push(file);
+      }
+      return { id: presItem.id || presItem.relatedId || generateId(), name: presItem.label || "Presentation", actionType: mapItemTypeToActionType(presItem.itemType), files };
+    });
+    return { id: sectionItem.id || sectionItem.relatedId || generateId(), name: sectionItem.label || "Section", presentations };
+  });
+  return { id: planId || generateId(), name: instructions.venueName || "Plan", sections, allFiles };
+}
+var expandedInstructionsToPresentations = instructionsToPresentations;
+function collapseInstructions(instructions, maxDepth = 2) {
+  function collapseItem(item, currentDepth) {
+    if (currentDepth >= maxDepth || !item.children || item.children.length === 0) {
+      const { children, ...rest } = item;
+      if (children && children.length > 0) {
+        const totalSeconds = children.reduce((sum, c) => sum + (c.seconds || 0), 0);
+        if (totalSeconds > 0) {
+          rest.seconds = totalSeconds;
+        }
+        if (!rest.embedUrl) {
+          const firstWithUrl = children.find((c) => c.embedUrl);
+          if (firstWithUrl) {
+            rest.embedUrl = firstWithUrl.embedUrl;
+          }
+        }
+      }
+      return rest;
+    }
     return {
-      browse: true,
-      presentations: false,
-      playlist: false,
-      instructions: false,
-      expandedInstructions: false,
-      mediaLicensing: false
+      ...item,
+      children: item.children.map((child) => collapseItem(child, currentDepth + 1))
     };
   }
-  /**
-   * Check the license status for a specific media item.
-   * Override in subclass if the provider requires license validation.
-   * @param _mediaId - The media ID to check
-   * @param _auth - Optional authentication data
-   * @returns MediaLicenseResult object, or null if not supported
-   */
-  checkMediaLicense(_mediaId, _auth) {
-    return Promise.resolve(null);
+  return {
+    venueName: instructions.venueName,
+    items: instructions.items.map((item) => collapseItem(item, 0))
+  };
+}
+function playlistToPresentations(files, planName = "Playlist", sectionName = "Content") {
+  const presentations = files.map((file, index) => ({ id: `pres-${index}-${file.id}`, name: file.title, actionType: "play", files: [file] }));
+  return { id: "playlist-plan-" + generateId(), name: planName, sections: [{ id: "main-section", name: sectionName, presentations }], allFiles: [...files] };
+}
+function playlistToInstructions(files, venueName = "Playlist") {
+  return { venueName, items: [{ id: "main-section", itemType: "section", label: "Content", children: files.map((file, index) => ({ id: file.id || `item-${index}`, itemType: "file", label: file.title, seconds: file.providerData?.seconds || void 0, embedUrl: file.embedUrl || file.url })) }] };
+}
+var playlistToExpandedInstructions = playlistToInstructions;
+
+// src/FormatResolver.ts
+var FormatResolver = class {
+  constructor(provider, options = {}) {
+    this.provider = provider;
+    this.options = { allowLossy: options.allowLossy ?? true };
   }
-  /**
-   * Get the authentication types supported by this provider.
-   * @returns Array of supported AuthType values ('none', 'oauth_pkce', 'device_flow')
-   */
-  getAuthTypes() {
-    if (!this.requiresAuth()) return ["none"];
-    const types = ["oauth_pkce"];
-    if (this.supportsDeviceFlow()) types.push("device_flow");
-    return types;
+  getProvider() {
+    return this.provider;
   }
-  /**
-   * Check if the provided auth data is still valid (not expired).
-   * @param auth - Authentication data to validate
-   * @returns true if auth is valid and not expired
-   */
-  isAuthValid(auth) {
-    if (!auth) return false;
-    return !this.isTokenExpired(auth);
+  /** Extract the last segment from a path to use as fallback ID/title */
+  getIdFromPath(path) {
+    const { segments } = parsePath(path);
+    return segments[segments.length - 1] || "content";
   }
-  /**
-   * Check if a token is expired (with 5-minute buffer).
-   * @param auth - Authentication data to check
-   * @returns true if token is expired or will expire within 5 minutes
-   */
-  isTokenExpired(auth) {
-    if (!auth.created_at || !auth.expires_in) return true;
-    const expiresAt = (auth.created_at + auth.expires_in) * 1e3;
-    return Date.now() > expiresAt - 5 * 60 * 1e3;
+  async getPlaylist(path, auth) {
+    const caps = this.provider.capabilities;
+    if (caps.playlist && this.provider.getPlaylist) {
+      const result = await this.provider.getPlaylist(path, auth);
+      if (result && result.length > 0) return result;
+    }
+    if (caps.presentations) {
+      const plan = await this.provider.getPresentations(path, auth);
+      if (plan) return presentationsToPlaylist(plan);
+    }
+    if (caps.expandedInstructions && this.provider.getExpandedInstructions) {
+      const expanded = await this.provider.getExpandedInstructions(path, auth);
+      if (expanded) return instructionsToPlaylist(expanded);
+    }
+    if (this.options.allowLossy && caps.instructions && this.provider.getInstructions) {
+      const instructions = await this.provider.getInstructions(path, auth);
+      if (instructions) return instructionsToPlaylist(instructions);
+    }
+    return null;
   }
-  /**
-   * Generate a random code verifier for PKCE.
-   * @returns A 64-character random string
-   */
+  async getPlaylistWithMeta(path, auth) {
+    const caps = this.provider.capabilities;
+    if (caps.playlist && this.provider.getPlaylist) {
+      const result = await this.provider.getPlaylist(path, auth);
+      if (result && result.length > 0) {
+        return { data: result, meta: { isNative: true, isLossy: false } };
+      }
+    }
+    if (caps.presentations) {
+      const plan = await this.provider.getPresentations(path, auth);
+      if (plan) return { data: presentationsToPlaylist(plan), meta: { isNative: false, sourceFormat: "presentations", isLossy: false } };
+    }
+    if (caps.expandedInstructions && this.provider.getExpandedInstructions) {
+      const expanded = await this.provider.getExpandedInstructions(path, auth);
+      if (expanded) return { data: instructionsToPlaylist(expanded), meta: { isNative: false, sourceFormat: "expandedInstructions", isLossy: false } };
+    }
+    if (this.options.allowLossy && caps.instructions && this.provider.getInstructions) {
+      const instructions = await this.provider.getInstructions(path, auth);
+      if (instructions) return { data: instructionsToPlaylist(instructions), meta: { isNative: false, sourceFormat: "instructions", isLossy: true } };
+    }
+    return { data: null, meta: { isNative: false, isLossy: false } };
+  }
+  async getPresentations(path, auth) {
+    const caps = this.provider.capabilities;
+    const fallbackId = this.getIdFromPath(path);
+    if (caps.presentations) {
+      const result = await this.provider.getPresentations(path, auth);
+      if (result) return result;
+    }
+    if (caps.expandedInstructions && this.provider.getExpandedInstructions) {
+      const expanded = await this.provider.getExpandedInstructions(path, auth);
+      if (expanded) return instructionsToPresentations(expanded, fallbackId);
+    }
+    if (caps.instructions && this.provider.getInstructions) {
+      const instructions = await this.provider.getInstructions(path, auth);
+      if (instructions) return instructionsToPresentations(instructions, fallbackId);
+    }
+    if (this.options.allowLossy && caps.playlist && this.provider.getPlaylist) {
+      const playlist = await this.provider.getPlaylist(path, auth);
+      if (playlist && playlist.length > 0) {
+        return playlistToPresentations(playlist, fallbackId);
+      }
+    }
+    return null;
+  }
+  async getPresentationsWithMeta(path, auth) {
+    const caps = this.provider.capabilities;
+    const fallbackId = this.getIdFromPath(path);
+    if (caps.presentations) {
+      const result = await this.provider.getPresentations(path, auth);
+      if (result) {
+        return { data: result, meta: { isNative: true, isLossy: false } };
+      }
+    }
+    if (caps.expandedInstructions && this.provider.getExpandedInstructions) {
+      const expanded = await this.provider.getExpandedInstructions(path, auth);
+      if (expanded) return { data: instructionsToPresentations(expanded, fallbackId), meta: { isNative: false, sourceFormat: "expandedInstructions", isLossy: false } };
+    }
+    if (caps.instructions && this.provider.getInstructions) {
+      const instructions = await this.provider.getInstructions(path, auth);
+      if (instructions) return { data: instructionsToPresentations(instructions, fallbackId), meta: { isNative: false, sourceFormat: "instructions", isLossy: true } };
+    }
+    if (this.options.allowLossy && caps.playlist && this.provider.getPlaylist) {
+      const playlist = await this.provider.getPlaylist(path, auth);
+      if (playlist && playlist.length > 0) return { data: playlistToPresentations(playlist, fallbackId), meta: { isNative: false, sourceFormat: "playlist", isLossy: true } };
+    }
+    return { data: null, meta: { isNative: false, isLossy: false } };
+  }
+  async getInstructions(path, auth) {
+    const caps = this.provider.capabilities;
+    const fallbackTitle = this.getIdFromPath(path);
+    if (caps.instructions && this.provider.getInstructions) {
+      const result = await this.provider.getInstructions(path, auth);
+      if (result) return result;
+    }
+    if (caps.expandedInstructions && this.provider.getExpandedInstructions) {
+      const expanded = await this.provider.getExpandedInstructions(path, auth);
+      if (expanded) return collapseInstructions(expanded);
+    }
+    if (caps.presentations) {
+      const plan = await this.provider.getPresentations(path, auth);
+      if (plan) return presentationsToInstructions(plan);
+    }
+    if (this.options.allowLossy && caps.playlist && this.provider.getPlaylist) {
+      const playlist = await this.provider.getPlaylist(path, auth);
+      if (playlist && playlist.length > 0) {
+        return playlistToInstructions(playlist, fallbackTitle);
+      }
+    }
+    return null;
+  }
+  async getInstructionsWithMeta(path, auth) {
+    const caps = this.provider.capabilities;
+    const fallbackTitle = this.getIdFromPath(path);
+    if (caps.instructions && this.provider.getInstructions) {
+      const result = await this.provider.getInstructions(path, auth);
+      if (result) {
+        return { data: result, meta: { isNative: true, isLossy: false } };
+      }
+    }
+    if (caps.expandedInstructions && this.provider.getExpandedInstructions) {
+      const expanded = await this.provider.getExpandedInstructions(path, auth);
+      if (expanded) return { data: collapseInstructions(expanded), meta: { isNative: false, sourceFormat: "expandedInstructions", isLossy: true } };
+    }
+    if (caps.presentations) {
+      const plan = await this.provider.getPresentations(path, auth);
+      if (plan) return { data: presentationsToInstructions(plan), meta: { isNative: false, sourceFormat: "presentations", isLossy: false } };
+    }
+    if (this.options.allowLossy && caps.playlist && this.provider.getPlaylist) {
+      const playlist = await this.provider.getPlaylist(path, auth);
+      if (playlist && playlist.length > 0) return { data: playlistToInstructions(playlist, fallbackTitle), meta: { isNative: false, sourceFormat: "playlist", isLossy: true } };
+    }
+    return { data: null, meta: { isNative: false, isLossy: false } };
+  }
+  async getExpandedInstructions(path, auth) {
+    const caps = this.provider.capabilities;
+    const fallbackTitle = this.getIdFromPath(path);
+    if (caps.expandedInstructions && this.provider.getExpandedInstructions) {
+      const result = await this.provider.getExpandedInstructions(path, auth);
+      if (result) return result;
+    }
+    if (caps.presentations) {
+      const plan = await this.provider.getPresentations(path, auth);
+      if (plan) return presentationsToExpandedInstructions(plan);
+    }
+    if (caps.instructions && this.provider.getInstructions) {
+      const instructions = await this.provider.getInstructions(path, auth);
+      if (instructions) return instructions;
+    }
+    if (this.options.allowLossy && caps.playlist && this.provider.getPlaylist) {
+      const playlist = await this.provider.getPlaylist(path, auth);
+      if (playlist && playlist.length > 0) {
+        return playlistToInstructions(playlist, fallbackTitle);
+      }
+    }
+    return null;
+  }
+  async getExpandedInstructionsWithMeta(path, auth) {
+    const caps = this.provider.capabilities;
+    const fallbackTitle = this.getIdFromPath(path);
+    if (caps.expandedInstructions && this.provider.getExpandedInstructions) {
+      const result = await this.provider.getExpandedInstructions(path, auth);
+      if (result) {
+        return { data: result, meta: { isNative: true, isLossy: false } };
+      }
+    }
+    if (caps.presentations) {
+      const plan = await this.provider.getPresentations(path, auth);
+      if (plan) return { data: presentationsToExpandedInstructions(plan), meta: { isNative: false, sourceFormat: "presentations", isLossy: false } };
+    }
+    if (caps.instructions && this.provider.getInstructions) {
+      const instructions = await this.provider.getInstructions(path, auth);
+      if (instructions) return { data: instructions, meta: { isNative: false, sourceFormat: "instructions", isLossy: true } };
+    }
+    if (this.options.allowLossy && caps.playlist && this.provider.getPlaylist) {
+      const playlist = await this.provider.getPlaylist(path, auth);
+      if (playlist && playlist.length > 0) return { data: playlistToInstructions(playlist, fallbackTitle), meta: { isNative: false, sourceFormat: "playlist", isLossy: true } };
+    }
+    return { data: null, meta: { isNative: false, isLossy: false } };
+  }
+};
+
+// src/helpers/OAuthHelper.ts
+var OAuthHelper = class {
   generateCodeVerifier() {
     const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~";
     const length = 64;
@@ -163,11 +461,6 @@ var ContentProvider = class {
     }
     return result;
   }
-  /**
-   * Generate a code challenge from a code verifier using SHA-256.
-   * @param verifier - The code verifier string
-   * @returns Base64url-encoded SHA-256 hash of the verifier
-   */
   async generateCodeChallenge(verifier) {
     const encoder = new TextEncoder();
     const data = encoder.encode(verifier);
@@ -180,142 +473,100 @@ var ContentProvider = class {
     const base64 = btoa(binary);
     return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
   }
-  /**
-   * Build the OAuth authorization URL for PKCE flow.
-   * @param codeVerifier - The code verifier (store this for token exchange)
-   * @param redirectUri - The redirect URI to return to after authorization
-   * @param state - Optional state parameter for CSRF protection (defaults to provider ID)
-   * @returns Object with authorization URL and challenge method
-   */
-  async buildAuthUrl(codeVerifier, redirectUri, state) {
+  async buildAuthUrl(config, codeVerifier, redirectUri, state) {
     const codeChallenge = await this.generateCodeChallenge(codeVerifier);
     const params = new URLSearchParams({
       response_type: "code",
-      client_id: this.config.clientId,
+      client_id: config.clientId,
       redirect_uri: redirectUri,
-      scope: this.config.scopes.join(" "),
+      scope: config.scopes.join(" "),
       code_challenge: codeChallenge,
       code_challenge_method: "S256",
-      state: state || this.id
+      state: state || ""
     });
-    return { url: `${this.config.oauthBase}/authorize?${params.toString()}`, challengeMethod: "S256" };
-  }
-  /**
-   * Exchange an authorization code for access and refresh tokens.
-   * @param code - The authorization code from the callback
-   * @param codeVerifier - The original code verifier used to generate the challenge
-   * @param redirectUri - The redirect URI (must match the one used in buildAuthUrl)
-   * @returns Authentication data, or null if exchange failed
-   */
-  async exchangeCodeForTokens(code, codeVerifier, redirectUri) {
+    return { url: `${config.oauthBase}/authorize?${params.toString()}`, challengeMethod: "S256" };
+  }
+  async exchangeCodeForTokens(config, providerId, code, codeVerifier, redirectUri) {
     try {
       const params = new URLSearchParams({
         grant_type: "authorization_code",
         code,
         redirect_uri: redirectUri,
-        client_id: this.config.clientId,
+        client_id: config.clientId,
         code_verifier: codeVerifier
       });
-      const tokenUrl = `${this.config.oauthBase}/token`;
-      console.log(`${this.id} token exchange request to: ${tokenUrl}`);
-      console.log(`  - client_id: ${this.config.clientId}`);
+      const tokenUrl = `${config.oauthBase}/token`;
+      console.log(`${providerId} token exchange request to: ${tokenUrl}`);
+      console.log(`  - client_id: ${config.clientId}`);
       console.log(`  - redirect_uri: ${redirectUri}`);
       console.log(`  - code: ${code.substring(0, 10)}...`);
       const response = await fetch(tokenUrl, { method: "POST", headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: params.toString() });
-      console.log(`${this.id} token response status: ${response.status}`);
+      console.log(`${providerId} token response status: ${response.status}`);
       if (!response.ok) {
         const errorText = await response.text();
-        console.error(`${this.id} token exchange failed: ${response.status} - ${errorText}`);
+        console.error(`${providerId} token exchange failed: ${response.status} - ${errorText}`);
         return null;
       }
       const data = await response.json();
-      console.log(`${this.id} token exchange successful, got access_token: ${!!data.access_token}`);
-      return {
-        access_token: data.access_token,
-        refresh_token: data.refresh_token,
-        token_type: data.token_type || "Bearer",
-        created_at: Math.floor(Date.now() / 1e3),
-        expires_in: data.expires_in,
-        scope: data.scope || this.config.scopes.join(" ")
-      };
+      console.log(`${providerId} token exchange successful, got access_token: ${!!data.access_token}`);
+      return { access_token: data.access_token, refresh_token: data.refresh_token, token_type: data.token_type || "Bearer", created_at: Math.floor(Date.now() / 1e3), expires_in: data.expires_in, scope: data.scope || config.scopes.join(" ") };
     } catch (error) {
-      console.error(`${this.id} token exchange error:`, error);
+      console.error(`${providerId} token exchange error:`, error);
       return null;
     }
   }
-  /**
-   * Refresh an expired access token using the refresh token.
-   * @param auth - The current authentication data (must include refresh_token)
-   * @returns New authentication data, or null if refresh failed
-   */
-  async refreshToken(auth) {
+};
+
+// src/helpers/TokenHelper.ts
+var TokenHelper = class {
+  isAuthValid(auth) {
+    if (!auth) return false;
+    return !this.isTokenExpired(auth);
+  }
+  isTokenExpired(auth) {
+    if (!auth.created_at || !auth.expires_in) return true;
+    const expiresAt = (auth.created_at + auth.expires_in) * 1e3;
+    return Date.now() > expiresAt - 5 * 60 * 1e3;
+  }
+  async refreshToken(config, auth) {
     if (!auth.refresh_token) return null;
     try {
       const params = new URLSearchParams({
         grant_type: "refresh_token",
         refresh_token: auth.refresh_token,
-        client_id: this.config.clientId
+        client_id: config.clientId
       });
-      const response = await fetch(`${this.config.oauthBase}/token`, { method: "POST", headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: params.toString() });
+      const response = await fetch(`${config.oauthBase}/token`, { method: "POST", headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: params.toString() });
       if (!response.ok) return null;
       const data = await response.json();
-      return {
-        access_token: data.access_token,
-        refresh_token: data.refresh_token || auth.refresh_token,
-        token_type: data.token_type || "Bearer",
-        created_at: Math.floor(Date.now() / 1e3),
-        expires_in: data.expires_in,
-        scope: data.scope || auth.scope
-      };
+      return { access_token: data.access_token, refresh_token: data.refresh_token || auth.refresh_token, token_type: data.token_type || "Bearer", created_at: Math.floor(Date.now() / 1e3), expires_in: data.expires_in, scope: data.scope || auth.scope };
     } catch {
       return null;
     }
   }
-  /**
-   * Check if this provider supports device flow authentication.
-   * @returns true if device flow is supported
-   */
-  supportsDeviceFlow() {
-    return !!this.config.supportsDeviceFlow && !!this.config.deviceAuthEndpoint;
+};
+
+// src/helpers/DeviceFlowHelper.ts
+var DeviceFlowHelper = class {
+  supportsDeviceFlow(config) {
+    return !!config.supportsDeviceFlow && !!config.deviceAuthEndpoint;
   }
-  /**
-   * Initiate the device authorization flow (RFC 8628).
-   * @returns Device authorization response with user_code and verification_uri, or null if not supported
-   */
-  async initiateDeviceFlow() {
-    if (!this.supportsDeviceFlow()) return null;
+  async initiateDeviceFlow(config) {
+    if (!this.supportsDeviceFlow(config)) return null;
     try {
-      const params = new URLSearchParams({ client_id: this.config.clientId, scope: this.config.scopes.join(" ") });
-      const response = await fetch(`${this.config.oauthBase}${this.config.deviceAuthEndpoint}`, { method: "POST", headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: params.toString() });
+      const response = await fetch(`${config.oauthBase}${config.deviceAuthEndpoint}`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ client_id: config.clientId, scope: config.scopes.join(" ") }) });
       if (!response.ok) return null;
       return await response.json();
     } catch {
       return null;
     }
   }
-  /**
-   * Poll for a token after user has authorized the device.
-   * @param deviceCode - The device_code from initiateDeviceFlow response
-   * @returns Auth data if successful, error object if pending/slow_down, or null if failed/expired
-   */
-  async pollDeviceFlowToken(deviceCode) {
+  async pollDeviceFlowToken(config, deviceCode) {
     try {
-      const params = new URLSearchParams({
-        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
-        device_code: deviceCode,
-        client_id: this.config.clientId
-      });
-      const response = await fetch(`${this.config.oauthBase}/token`, { method: "POST", headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: params.toString() });
+      const response = await fetch(`${config.oauthBase}/token`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ grant_type: "urn:ietf:params:oauth:grant-type:device_code", device_code: deviceCode, client_id: config.clientId }) });
       if (response.ok) {
         const data = await response.json();
-        return {
-          access_token: data.access_token,
-          refresh_token: data.refresh_token,
-          token_type: data.token_type || "Bearer",
-          created_at: Math.floor(Date.now() / 1e3),
-          expires_in: data.expires_in,
-          scope: data.scope || this.config.scopes.join(" ")
-        };
+        return { access_token: data.access_token, refresh_token: data.refresh_token, token_type: data.token_type || "Bearer", created_at: Math.floor(Date.now() / 1e3), expires_in: data.expires_in, scope: data.scope || config.scopes.join(" ") };
       }
       const errorData = await response.json();
       switch (errorData.error) {
@@ -334,221 +585,295 @@ var ContentProvider = class {
       return { error: "network_error" };
     }
   }
-  /**
-   * Calculate the delay between device flow poll attempts.
-   * @param baseInterval - Base interval in seconds (default: 5)
-   * @param slowDownCount - Number of slow_down responses received
-   * @returns Delay in milliseconds
-   */
   calculatePollDelay(baseInterval = 5, slowDownCount = 0) {
     return (baseInterval + slowDownCount * 5) * 1e3;
   }
-  /**
-   * Create authorization headers for API requests.
-   * @param auth - Authentication data
-   * @returns Headers object with Authorization header, or null if no auth
-   */
+};
+
+// src/helpers/ApiHelper.ts
+var ApiHelper = class {
   createAuthHeaders(auth) {
     if (!auth) return null;
     return { Authorization: `Bearer ${auth.access_token}`, Accept: "application/json" };
   }
-  /**
-   * Make an authenticated API request.
-   * @param path - API endpoint path (appended to config.apiBase)
-   * @param auth - Optional authentication data
-   * @param method - HTTP method (default: 'GET')
-   * @param body - Optional request body (for POST requests)
-   * @returns Parsed JSON response, or null if request failed
-   */
-  async apiRequest(path, auth, method = "GET", body) {
+  async apiRequest(config, providerId, path, auth, method = "GET", body) {
     try {
-      const url = `${this.config.apiBase}${path}`;
+      const url = `${config.apiBase}${path}`;
       const headers = { Accept: "application/json" };
       if (auth) headers["Authorization"] = `Bearer ${auth.access_token}`;
       if (body) headers["Content-Type"] = "application/json";
-      console.log(`${this.id} API request: ${method} ${url}`);
-      console.log(`${this.id} API auth present: ${!!auth}`);
+      console.log(`${providerId} API request: ${method} ${url}`);
+      console.log(`${providerId} API auth present: ${!!auth}`);
       const options = { method, headers, ...body ? { body: JSON.stringify(body) } : {} };
       const response = await fetch(url, options);
-      console.log(`${this.id} API response status: ${response.status}`);
+      console.log(`${providerId} API response status: ${response.status}`);
       if (!response.ok) {
         const errorText = await response.text();
-        console.error(`${this.id} API request failed: ${response.status} - ${errorText}`);
+        console.error(`${providerId} API request failed: ${response.status} - ${errorText}`);
         return null;
       }
       return await response.json();
     } catch (error) {
-      console.error(`${this.id} API request error:`, error);
+      console.error(`${providerId} API request error:`, error);
       return null;
     }
   }
-  /**
-   * Helper to create a ContentFolder object.
-   * @param id - Unique identifier
-   * @param title - Display title
-   * @param image - Optional image URL
-   * @param providerData - Optional provider-specific data
-   * @returns ContentFolder object
-   */
-  createFolder(id, title, image, providerData) {
-    return { type: "folder", id, title, image, providerData };
-  }
-  /**
-   * Helper to create a ContentFile object with automatic media type detection.
-   * @param id - Unique identifier
-   * @param title - Display title
-   * @param url - Media URL
-   * @param options - Optional properties (mediaType, image, muxPlaybackId, providerData)
-   * @returns ContentFile object
-   */
+};
+
+// src/ContentProvider.ts
+var ContentProvider = class {
+  constructor() {
+    this.oauthHelper = new OAuthHelper();
+    this.tokenHelper = new TokenHelper();
+    this.deviceFlowHelper = new DeviceFlowHelper();
+    this.apiHelper = new ApiHelper();
+  }
+  async getPlaylist(path, auth, _resolution) {
+    const caps = this.getCapabilities();
+    if (caps.presentations) {
+      const plan = await this.getPresentations(path, auth);
+      if (plan) return presentationsToPlaylist(plan);
+    }
+    return null;
+  }
+  async getInstructions(path, auth) {
+    const caps = this.getCapabilities();
+    if (caps.expandedInstructions) {
+      const expanded = await this.getExpandedInstructions(path, auth);
+      if (expanded) return collapseInstructions(expanded);
+    }
+    if (caps.presentations) {
+      const plan = await this.getPresentations(path, auth);
+      if (plan) return presentationsToInstructions(plan);
+    }
+    return null;
+  }
+  async getExpandedInstructions(path, auth) {
+    const caps = this.getCapabilities();
+    if (caps.presentations) {
+      const plan = await this.getPresentations(path, auth);
+      if (plan) return presentationsToExpandedInstructions(plan);
+    }
+    return null;
+  }
+  requiresAuth() {
+    return !!this.config.clientId;
+  }
+  getCapabilities() {
+    return { browse: true, presentations: false, playlist: false, instructions: false, expandedInstructions: false, mediaLicensing: false };
+  }
+  checkMediaLicense(_mediaId, _auth) {
+    return Promise.resolve(null);
+  }
+  getAuthTypes() {
+    if (!this.requiresAuth()) return ["none"];
+    const types = ["oauth_pkce"];
+    if (this.supportsDeviceFlow()) types.push("device_flow");
+    return types;
+  }
+  // Token management - delegated to TokenHelper
+  isAuthValid(auth) {
+    return this.tokenHelper.isAuthValid(auth);
+  }
+  isTokenExpired(auth) {
+    return this.tokenHelper.isTokenExpired(auth);
+  }
+  async refreshToken(auth) {
+    return this.tokenHelper.refreshToken(this.config, auth);
+  }
+  // OAuth PKCE - delegated to OAuthHelper
+  generateCodeVerifier() {
+    return this.oauthHelper.generateCodeVerifier();
+  }
+  async generateCodeChallenge(verifier) {
+    return this.oauthHelper.generateCodeChallenge(verifier);
+  }
+  async buildAuthUrl(codeVerifier, redirectUri, state) {
+    return this.oauthHelper.buildAuthUrl(this.config, codeVerifier, redirectUri, state || this.id);
+  }
+  async exchangeCodeForTokens(code, codeVerifier, redirectUri) {
+    return this.oauthHelper.exchangeCodeForTokens(this.config, this.id, code, codeVerifier, redirectUri);
+  }
+  // Device flow - delegated to DeviceFlowHelper
+  supportsDeviceFlow() {
+    return this.deviceFlowHelper.supportsDeviceFlow(this.config);
+  }
+  async initiateDeviceFlow() {
+    return this.deviceFlowHelper.initiateDeviceFlow(this.config);
+  }
+  async pollDeviceFlowToken(deviceCode) {
+    return this.deviceFlowHelper.pollDeviceFlowToken(this.config, deviceCode);
+  }
+  calculatePollDelay(baseInterval = 5, slowDownCount = 0) {
+    return this.deviceFlowHelper.calculatePollDelay(baseInterval, slowDownCount);
+  }
+  // API requests - delegated to ApiHelper
+  createAuthHeaders(auth) {
+    return this.apiHelper.createAuthHeaders(auth);
+  }
+  async apiRequest(path, auth, method = "GET", body) {
+    return this.apiHelper.apiRequest(this.config, this.id, path, auth, method, body);
+  }
+  // Content factories
+  createFolder(id, title, path, image, providerData, isLeaf) {
+    return { type: "folder", id, title, path, image, isLeaf, providerData };
+  }
   createFile(id, title, url, options) {
-    return {
-      type: "file",
-      id,
-      title,
-      url,
-      mediaType: options?.mediaType ?? detectMediaType(url),
-      image: options?.image,
-      muxPlaybackId: options?.muxPlaybackId,
-      providerData: options?.providerData
-    };
+    return { type: "file", id, title, url, mediaType: options?.mediaType ?? detectMediaType(url), image: options?.image, muxPlaybackId: options?.muxPlaybackId, providerData: options?.providerData };
   }
 };
 
-// src/providers/APlayProvider.ts
-var APlayProvider = class extends ContentProvider {
+// src/providers/aPlay/APlayProvider.ts
+var APlayProvider = class {
   constructor() {
-    super(...arguments);
+    this.apiHelper = new ApiHelper();
     this.id = "aplay";
     this.name = "APlay";
-    this.logos = {
-      light: "https://www.joinamazing.com/_assets/v11/3ba846c5afd7e73d27bc4d87b63d423e7ae2dc73.svg",
-      dark: "https://www.joinamazing.com/_assets/v11/3ba846c5afd7e73d27bc4d87b63d423e7ae2dc73.svg"
-    };
-    this.config = {
-      id: "aplay",
-      name: "APlay",
-      apiBase: "https://api-prod.amazingkids.app",
-      oauthBase: "https://api.joinamazing.com/prod/aims/oauth",
-      clientId: "xFJFq7yNYuXXXMx0YBiQ",
-      scopes: ["openid", "profile", "email"],
-      endpoints: {
-        modules: "/prod/curriculum/modules",
-        productLibraries: (productId) => `/prod/curriculum/modules/products/${productId}/libraries`,
-        libraryMedia: (libraryId) => `/prod/creators/libraries/${libraryId}/media`
-      }
-    };
+    this.logos = { light: "https://www.joinamazing.com/_assets/v11/3ba846c5afd7e73d27bc4d87b63d423e7ae2dc73.svg", dark: "https://www.joinamazing.com/_assets/v11/3ba846c5afd7e73d27bc4d87b63d423e7ae2dc73.svg" };
+    this.config = { id: "aplay", name: "APlay", apiBase: "https://api-prod.amazingkids.app", oauthBase: "https://api.joinamazing.com/prod/aims/oauth", clientId: "xFJFq7yNYuXXXMx0YBiQ", scopes: ["openid", "profile", "email"], endpoints: { modules: "/prod/curriculum/modules", productLibraries: (productId) => `/prod/curriculum/modules/products/${productId}/libraries`, libraryMedia: (libraryId) => `/prod/creators/libraries/${libraryId}/media` } };
+    this.requiresAuth = true;
+    this.authTypes = ["oauth_pkce"];
+    this.capabilities = { browse: true, presentations: true, playlist: false, instructions: false, expandedInstructions: false, mediaLicensing: true };
   }
-  getCapabilities() {
-    return {
-      browse: true,
-      presentations: true,
-      playlist: false,
-      instructions: false,
-      expandedInstructions: false,
-      mediaLicensing: true
-    };
+  async apiRequest(path, auth) {
+    return this.apiHelper.apiRequest(this.config, this.id, path, auth);
   }
-  async browse(folder, auth) {
-    console.log(`APlay browse called with folder:`, folder ? { id: folder.id, level: folder.providerData?.level } : "null");
-    console.log(`APlay browse auth present:`, !!auth);
-    if (!folder) {
-      console.log(`APlay fetching modules from: ${this.config.endpoints.modules}`);
-      const response = await this.apiRequest(this.config.endpoints.modules, auth);
-      console.log(`APlay modules response:`, response ? "received" : "null");
-      if (!response) return [];
-      const modules = response.data || response.modules || response;
-      console.log(`APlay modules count:`, Array.isArray(modules) ? modules.length : "not an array");
-      if (!Array.isArray(modules)) return [];
-      const items = [];
-      for (const m of modules) {
-        if (m.isLocked) continue;
-        const allProducts = m.products || [];
-        const products = allProducts.filter((p) => !p.isHidden);
-        if (products.length === 0) {
-          items.push({
-            type: "folder",
-            id: m.id || m.moduleId,
-            title: m.title || m.name,
-            image: m.image,
-            providerData: { level: "libraries", productId: m.id || m.moduleId }
-          });
-        } else if (products.length === 1) {
-          const product = products[0];
-          items.push({
-            type: "folder",
-            id: product.productId || product.id,
-            title: m.title || m.name,
-            image: m.image || product.image,
-            providerData: { level: "libraries", productId: product.productId || product.id }
-          });
-        } else {
-          items.push({
-            type: "folder",
-            id: m.id || m.moduleId,
-            title: m.title || m.name,
-            image: m.image,
-            providerData: {
-              level: "products",
-              products: products.map((p) => ({ id: p.productId || p.id, title: p.title || p.name, image: p.image }))
-            }
-          });
-        }
-      }
-      return items;
+  async browse(path, auth) {
+    const { segments, depth } = parsePath(path);
+    console.log("APlay browse called with path:", path, "depth:", depth);
+    if (depth === 0) {
+      return [{
+        type: "folder",
+        id: "modules-root",
+        title: "Modules",
+        path: "/modules"
+      }];
     }
-    const level = folder.providerData?.level;
-    switch (level) {
-      case "products":
-        return this.getProductFolders(folder);
-      case "libraries":
-        return this.getLibraryFolders(folder, auth);
-      case "media":
-        return this.getMediaFiles(folder, auth);
-      default:
-        return [];
+    const root = segments[0];
+    if (root !== "modules") return [];
+    if (depth === 1) {
+      return this.getModules(auth);
+    }
+    if (depth === 2) {
+      const moduleId = segments[1];
+      return this.getModuleContent(moduleId, path, auth);
+    }
+    if (depth === 4 && segments[2] === "products") {
+      const productId = segments[3];
+      return this.getLibraryFolders(productId, path, auth);
+    }
+    if (depth === 5 && segments[2] === "products") {
+      const libraryId = segments[4];
+      return this.getMediaFiles(libraryId, auth);
+    }
+    if (depth === 4 && segments[2] === "libraries") {
+      const libraryId = segments[3];
+      return this.getMediaFiles(libraryId, auth);
+    }
+    return [];
+  }
+  async getModules(auth) {
+    console.log(`APlay fetching modules from: ${this.config.endpoints.modules}`);
+    const response = await this.apiRequest(this.config.endpoints.modules, auth);
+    console.log("APlay modules response:", response ? "received" : "null");
+    if (!response) return [];
+    const modules = response.data || response.modules || response;
+    console.log("APlay modules count:", Array.isArray(modules) ? modules.length : "not an array");
+    if (!Array.isArray(modules)) return [];
+    const items = [];
+    for (const m of modules) {
+      if (m.isLocked) continue;
+      const moduleId = m.id || m.moduleId;
+      const moduleTitle = m.title || m.name;
+      const moduleImage = m.image;
+      const allProducts = m.products || [];
+      const products = allProducts.filter((p) => !p.isHidden);
+      if (products.length === 0) {
+        items.push({
+          type: "folder",
+          id: moduleId,
+          title: moduleTitle,
+          image: moduleImage,
+          path: `/modules/${moduleId}`,
+          providerData: { productCount: 0 }
+        });
+      } else if (products.length === 1) {
+        const product = products[0];
+        items.push({
+          type: "folder",
+          id: product.productId || product.id,
+          title: moduleTitle,
+          image: moduleImage || product.image,
+          path: `/modules/${moduleId}`,
+          providerData: { productCount: 1, productId: product.productId || product.id }
+        });
+      } else {
+        items.push({
+          type: "folder",
+          id: moduleId,
+          title: moduleTitle,
+          image: moduleImage,
+          path: `/modules/${moduleId}`,
+          providerData: {
+            productCount: products.length,
+            products: products.map((p) => ({
+              id: p.productId || p.id,
+              title: p.title || p.name,
+              image: p.image
+            }))
+          }
+        });
+      }
     }
+    return items;
   }
-  getProductFolders(folder) {
-    const products = folder.providerData?.products || [];
-    return products.map((p) => ({
-      type: "folder",
-      id: p.id,
-      title: p.title,
-      image: p.image,
-      providerData: { level: "libraries", productId: p.id }
-    }));
+  async getModuleContent(moduleId, currentPath, auth) {
+    const modules = await this.getModules(auth);
+    const module2 = modules.find((m) => m.id === moduleId || m.providerData?.productId === moduleId);
+    if (!module2) return [];
+    const providerData = module2.providerData;
+    const productCount = providerData?.productCount || 0;
+    if (productCount === 0 || productCount === 1) {
+      const productId = providerData?.productId || moduleId;
+      return this.getLibraryFolders(productId, `${currentPath}/libraries`, auth);
+    } else {
+      const products = providerData?.products || [];
+      return products.map((p) => ({
+        type: "folder",
+        id: p.id,
+        title: p.title,
+        image: p.image,
+        path: `${currentPath}/products/${p.id}`
+      }));
+    }
   }
-  async getLibraryFolders(folder, auth) {
-    const productId = folder.providerData?.productId;
-    console.log(`APlay getLibraryFolders called with productId:`, productId);
-    if (!productId) return [];
+  async getLibraryFolders(productId, currentPath, auth) {
+    console.log("APlay getLibraryFolders called with productId:", productId);
     const pathFn = this.config.endpoints.productLibraries;
-    const path = pathFn(productId);
-    console.log(`APlay fetching libraries from: ${path}`);
-    const response = await this.apiRequest(path, auth);
-    console.log(`APlay libraries response:`, response ? "received" : "null");
+    const apiPath = pathFn(productId);
+    console.log(`APlay fetching libraries from: ${apiPath}`);
+    const response = await this.apiRequest(apiPath, auth);
+    console.log("APlay libraries response:", response ? "received" : "null");
     if (!response) return [];
     const libraries = response.data || response.libraries || response;
-    console.log(`APlay libraries count:`, Array.isArray(libraries) ? libraries.length : "not an array");
+    console.log("APlay libraries count:", Array.isArray(libraries) ? libraries.length : "not an array");
     if (!Array.isArray(libraries)) return [];
     return libraries.map((l) => ({
       type: "folder",
       id: l.libraryId || l.id,
       title: l.title || l.name,
       image: l.image,
-      providerData: { level: "media", libraryId: l.libraryId || l.id }
+      isLeaf: true,
+      path: `${currentPath}/${l.libraryId || l.id}`
     }));
   }
-  async getMediaFiles(folder, auth) {
-    const libraryId = folder.providerData?.libraryId;
-    console.log(`APlay getMediaFiles called with libraryId:`, libraryId);
-    if (!libraryId) return [];
+  async getMediaFiles(libraryId, auth) {
+    console.log("APlay getMediaFiles called with libraryId:", libraryId);
     const pathFn = this.config.endpoints.libraryMedia;
-    const path = pathFn(libraryId);
-    console.log(`APlay fetching media from: ${path}`);
-    const response = await this.apiRequest(path, auth);
-    console.log(`APlay media response:`, response ? "received" : "null");
+    const apiPath = pathFn(libraryId);
+    console.log(`APlay fetching media from: ${apiPath}`);
+    const response = await this.apiRequest(apiPath, auth);
+    console.log("APlay media response:", response ? "received" : "null");
     if (!response) return [];
     const mediaItems = response.data || response.media || response;
     if (!Array.isArray(mediaItems)) return [];
@@ -578,144 +903,97 @@ var APlayProvider = class extends ContentProvider {
       if (!url) continue;
       const detectedMediaType = detectMediaType(url, mediaType);
       const fileId = item.mediaId || item.id;
-      files.push({
-        type: "file",
-        id: fileId,
-        title: item.title || item.name || item.fileName || "",
-        mediaType: detectedMediaType,
-        image: thumbnail,
-        url,
-        muxPlaybackId,
-        mediaId: fileId
-      });
+      files.push({ type: "file", id: fileId, title: item.title || item.name || item.fileName || "", mediaType: detectedMediaType, image: thumbnail, url, muxPlaybackId, mediaId: fileId });
     }
     return files;
   }
-  async getPresentations(folder, auth) {
-    const libraryId = folder.providerData?.libraryId;
-    if (!libraryId) return null;
-    const files = await this.getMediaFiles(folder, auth);
+  async getPresentations(path, auth) {
+    const { segments, depth } = parsePath(path);
+    if (depth < 4 || segments[0] !== "modules") return null;
+    let libraryId;
+    const title = "Library";
+    if (segments[2] === "products" && depth === 5) {
+      libraryId = segments[4];
+    } else if (segments[2] === "libraries" && depth === 4) {
+      libraryId = segments[3];
+    } else {
+      return null;
+    }
+    const files = await this.getMediaFiles(libraryId, auth);
     if (files.length === 0) return null;
-    const presentations = files.map((f) => ({
-      id: f.id,
-      name: f.title,
-      actionType: "play",
-      files: [f]
-    }));
-    return {
-      id: libraryId,
-      name: folder.title,
-      image: folder.image,
-      sections: [{
-        id: `section-${libraryId}`,
-        name: folder.title || "Library",
-        presentations
-      }],
-      allFiles: files
-    };
+    const presentations = files.map((f) => ({ id: f.id, name: f.title, actionType: "play", files: [f] }));
+    return { id: libraryId, name: title, sections: [{ id: `section-${libraryId}`, name: title, presentations }], allFiles: files };
   }
-  /**
-   * Check the license status for a specific media item.
-   * Returns license information including pingback URL if licensed.
-   */
   async checkMediaLicense(mediaId, auth) {
     if (!auth) return null;
     try {
       const url = `${this.config.apiBase}/prod/reports/media/license-check`;
-      const response = await fetch(url, {
-        method: "POST",
-        headers: {
-          "Authorization": `Bearer ${auth.access_token}`,
-          "Content-Type": "application/json",
-          "Accept": "application/json"
-        },
-        body: JSON.stringify({ mediaIds: [mediaId] })
-      });
+      const response = await fetch(url, { method: "POST", headers: { "Authorization": `Bearer ${auth.access_token}`, "Content-Type": "application/json", "Accept": "application/json" }, body: JSON.stringify({ mediaIds: [mediaId] }) });
       if (!response.ok) return null;
       const data = await response.json();
       const licenseData = Array.isArray(data) ? data : data.data || [];
       const result = licenseData.find((item) => item.mediaId === mediaId);
       if (result?.isLicensed) {
-        const pingbackUrl = `${this.config.apiBase}/prod/reports/media/${mediaId}/stream-count?source=aplay-pro`;
-        return {
-          mediaId,
-          status: "valid",
-          message: "Media is licensed for playback",
-          expiresAt: result.expiresAt
-        };
+        return { mediaId, status: "valid", message: "Media is licensed for playback", expiresAt: result.expiresAt };
       }
-      return {
-        mediaId,
-        status: "not_licensed",
-        message: "Media is not licensed"
-      };
+      return { mediaId, status: "not_licensed", message: "Media is not licensed" };
     } catch {
-      return {
-        mediaId,
-        status: "unknown",
-        message: "Unable to verify license status"
-      };
+      return { mediaId, status: "unknown", message: "Unable to verify license status" };
     }
   }
 };
 
-// src/providers/SignPresenterProvider.ts
-var SignPresenterProvider = class extends ContentProvider {
+// src/providers/signPresenter/SignPresenterProvider.ts
+var SignPresenterProvider = class {
   constructor() {
-    super(...arguments);
+    this.apiHelper = new ApiHelper();
     this.id = "signpresenter";
     this.name = "SignPresenter";
-    this.logos = {
-      light: "https://signpresenter.com/files/shared/images/logo.png",
-      dark: "https://signpresenter.com/files/shared/images/logo.png"
-    };
-    this.config = {
-      id: "signpresenter",
-      name: "SignPresenter",
-      apiBase: "https://api.signpresenter.com",
-      oauthBase: "https://api.signpresenter.com/oauth",
-      clientId: "lessonsscreen-tv",
-      scopes: ["openid", "profile", "content"],
-      supportsDeviceFlow: true,
-      deviceAuthEndpoint: "/device/authorize",
-      endpoints: {
-        playlists: "/content/playlists",
-        messages: (playlistId) => `/content/playlists/${playlistId}/messages`
-      }
-    };
+    this.logos = { light: "https://signpresenter.com/files/shared/images/logo.png", dark: "https://signpresenter.com/files/shared/images/logo.png" };
+    this.config = { id: "signpresenter", name: "SignPresenter", apiBase: "https://api.signpresenter.com", oauthBase: "https://api.signpresenter.com/oauth", clientId: "lessonsscreen-tv", scopes: ["openid", "profile", "content"], supportsDeviceFlow: true, deviceAuthEndpoint: "/device/authorize", endpoints: { playlists: "/content/playlists", messages: (playlistId) => `/content/playlists/${playlistId}/messages` } };
+    this.requiresAuth = true;
+    this.authTypes = ["oauth_pkce", "device_flow"];
+    this.capabilities = { browse: true, presentations: true, playlist: false, instructions: false, expandedInstructions: false, mediaLicensing: false };
   }
-  getCapabilities() {
-    return {
-      browse: true,
-      presentations: true,
-      playlist: false,
-      instructions: false,
-      expandedInstructions: false,
-      mediaLicensing: false
-    };
+  async apiRequest(path, auth) {
+    return this.apiHelper.apiRequest(this.config, this.id, path, auth);
   }
-  async browse(folder, auth) {
-    if (!folder) {
-      const path = this.config.endpoints.playlists;
-      const response = await this.apiRequest(path, auth);
-      if (!response) return [];
-      const playlists = Array.isArray(response) ? response : response.data || response.playlists || [];
-      if (!Array.isArray(playlists)) return [];
-      return playlists.map((p) => ({
+  async browse(path, auth) {
+    const { segments, depth } = parsePath(path);
+    if (depth === 0) {
+      return [{
         type: "folder",
-        id: p.id,
-        title: p.name,
-        image: p.image,
-        providerData: { level: "messages", playlistId: p.id }
-      }));
+        id: "playlists-root",
+        title: "Playlists",
+        path: "/playlists"
+      }];
+    }
+    const root = segments[0];
+    if (root !== "playlists") return [];
+    if (depth === 1) {
+      return this.getPlaylists(auth);
+    }
+    if (depth === 2) {
+      const playlistId = segments[1];
+      return this.getMessages(playlistId, auth);
     }
-    const level = folder.providerData?.level;
-    if (level === "messages") return this.getMessages(folder, auth);
     return [];
   }
-  async getMessages(folder, auth) {
-    const playlistId = folder.providerData?.playlistId;
-    if (!playlistId) return [];
+  async getPlaylists(auth) {
+    const apiPath = this.config.endpoints.playlists;
+    const response = await this.apiRequest(apiPath, auth);
+    if (!response) return [];
+    const playlists = Array.isArray(response) ? response : response.data || response.playlists || [];
+    if (!Array.isArray(playlists)) return [];
+    return playlists.map((p) => ({
+      type: "folder",
+      id: p.id,
+      title: p.name,
+      image: p.image,
+      path: `/playlists/${p.id}`
+    }));
+  }
+  async getMessages(playlistId, auth) {
     const pathFn = this.config.endpoints.messages;
     const response = await this.apiRequest(pathFn(playlistId), auth);
     if (!response) return [];
@@ -726,93 +1004,42 @@ var SignPresenterProvider = class extends ContentProvider {
       if (!msg.url) continue;
       const url = msg.url;
       const seconds = msg.seconds;
-      files.push({
-        type: "file",
-        id: msg.id,
-        title: msg.name,
-        mediaType: detectMediaType(url, msg.mediaType),
-        image: msg.thumbnail || msg.image,
-        url,
-        // For direct media providers, embedUrl is the media URL itself
-        embedUrl: url,
-        providerData: seconds !== void 0 ? { seconds } : void 0
-      });
+      files.push({ type: "file", id: msg.id, title: msg.name, mediaType: detectMediaType(url, msg.mediaType), image: msg.thumbnail || msg.image, url, embedUrl: url, providerData: seconds !== void 0 ? { seconds } : void 0 });
     }
     return files;
   }
-  async getPresentations(folder, auth) {
-    const playlistId = folder.providerData?.playlistId;
-    if (!playlistId) return null;
-    const files = await this.getMessages(folder, auth);
+  async getPresentations(path, auth) {
+    const { segments, depth } = parsePath(path);
+    if (depth < 2 || segments[0] !== "playlists") return null;
+    const playlistId = segments[1];
+    const files = await this.getMessages(playlistId, auth);
     if (files.length === 0) return null;
-    const presentations = files.map((f) => ({
-      id: f.id,
-      name: f.title,
-      actionType: "play",
-      files: [f]
-    }));
-    return {
-      id: playlistId,
-      name: folder.title,
-      image: folder.image,
-      sections: [{
-        id: `section-${playlistId}`,
-        name: folder.title || "Playlist",
-        presentations
-      }],
-      allFiles: files
-    };
+    const playlists = await this.getPlaylists(auth);
+    const playlist = playlists.find((p) => p.id === playlistId);
+    const title = playlist?.title || "Playlist";
+    const image = playlist?.image;
+    const presentations = files.map((f) => ({ id: f.id, name: f.title, actionType: "play", files: [f] }));
+    return { id: playlistId, name: title, image, sections: [{ id: `section-${playlistId}`, name: title, presentations }], allFiles: files };
   }
 };
 
-// src/providers/LessonsChurchProvider.ts
-var LessonsChurchProvider = class extends ContentProvider {
+// src/providers/lessonsChurch/LessonsChurchProvider.ts
+var LessonsChurchProvider = class {
   constructor() {
-    super(...arguments);
     this.id = "lessonschurch";
     this.name = "Lessons.church";
-    this.logos = {
-      light: "https://lessons.church/images/logo.png",
-      dark: "https://lessons.church/images/logo-dark.png"
-    };
-    this.config = {
-      id: "lessonschurch",
-      name: "Lessons.church",
-      apiBase: "https://api.lessons.church",
-      oauthBase: "",
-      clientId: "",
-      scopes: [],
-      endpoints: {
-        programs: "/programs/public",
-        studies: (programId) => `/studies/public/program/${programId}`,
-        lessons: (studyId) => `/lessons/public/study/${studyId}`,
-        venues: (lessonId) => `/venues/public/lesson/${lessonId}`,
-        playlist: (venueId) => `/venues/playlist/${venueId}`,
-        feed: (venueId) => `/venues/public/feed/${venueId}`,
-        addOns: "/addOns/public",
-        addOnDetail: (id) => `/addOns/public/${id}`
-      }
-    };
+    this.logos = { light: "https://lessons.church/images/logo.png", dark: "https://lessons.church/images/logo-dark.png" };
+    this.config = { id: "lessonschurch", name: "Lessons.church", apiBase: "https://api.lessons.church", oauthBase: "", clientId: "", scopes: [], endpoints: { programs: "/programs/public", studies: (programId) => `/studies/public/program/${programId}`, lessons: (studyId) => `/lessons/public/study/${studyId}`, venues: (lessonId) => `/venues/public/lesson/${lessonId}`, playlist: (venueId) => `/venues/playlist/${venueId}`, feed: (venueId) => `/venues/public/feed/${venueId}`, addOns: "/addOns/public", addOnDetail: (id) => `/addOns/public/${id}` } };
+    this.requiresAuth = false;
+    this.authTypes = ["none"];
+    this.capabilities = { browse: true, presentations: true, playlist: true, instructions: true, expandedInstructions: true, mediaLicensing: false };
   }
-  requiresAuth() {
-    return false;
-  }
-  getCapabilities() {
-    return {
-      browse: true,
-      presentations: true,
-      playlist: true,
-      instructions: true,
-      expandedInstructions: true,
-      mediaLicensing: false
-    };
-  }
-  async getPlaylist(folder, _auth, resolution) {
-    const venueId = folder.providerData?.venueId;
+  async getPlaylist(path, _auth, resolution) {
+    const venueId = getSegment(path, 4);
     if (!venueId) return null;
-    let path = `/venues/playlist/${venueId}`;
-    if (resolution) path += `?resolution=${resolution}`;
-    const response = await this.apiRequest(path);
+    let apiPath = `/venues/playlist/${venueId}`;
+    if (resolution) apiPath += `?resolution=${resolution}`;
+    const response = await this.apiRequest(apiPath);
     if (!response) return null;
     const files = [];
     const messages = response.messages || [];
@@ -824,15 +1051,7 @@ var LessonsChurchProvider = class extends ContentProvider {
         if (!f.url) continue;
         const url = f.url;
         const fileId = f.id || `playlist-${fileIndex++}`;
-        files.push({
-          type: "file",
-          id: fileId,
-          title: f.name || msg.name,
-          mediaType: detectMediaType(url, f.fileType),
-          image: response.lessonImage,
-          url,
-          providerData: { seconds: f.seconds, loop: f.loop, loopVideo: f.loopVideo }
-        });
+        files.push({ type: "file", id: fileId, title: f.name || msg.name, mediaType: detectMediaType(url, f.fileType), image: response.lessonImage, url, providerData: { seconds: f.seconds, loop: f.loop, loopVideo: f.loopVideo } });
       }
     }
     return files;
@@ -847,48 +1066,32 @@ var LessonsChurchProvider = class extends ContentProvider {
       return null;
     }
   }
-  async browse(folder, _auth, resolution) {
-    if (!folder) {
+  async browse(path, _auth) {
+    const { segments, depth } = parsePath(path);
+    console.log("[LessonsChurchProvider.browse] path:", path, "depth:", depth, "segments:", segments);
+    if (depth === 0) {
       return [
-        {
-          type: "folder",
-          id: "lessons-root",
-          title: "Lessons",
-          providerData: { level: "programs" }
-        },
-        {
-          type: "folder",
-          id: "addons-root",
-          title: "Add-Ons",
-          providerData: { level: "addOnCategories" }
-        }
+        { type: "folder", id: "lessons-root", title: "Lessons", path: "/lessons" },
+        { type: "folder", id: "addons-root", title: "Add-Ons", path: "/addons" }
       ];
     }
-    const level = folder.providerData?.level;
-    switch (level) {
-      // Lessons hierarchy
-      case "programs":
-        return this.getPrograms();
-      case "studies":
-        return this.getStudies(folder);
-      case "lessons":
-        return this.getLessons(folder);
-      case "venues":
-        return this.getVenues(folder);
-      case "playlist":
-        return this.getPlaylistFiles(folder, resolution);
-      // Add-ons hierarchy
-      case "addOnCategories":
-        return this.getAddOnCategories();
-      case "addOns":
-        return this.getAddOnsByCategory(folder);
-      default:
-        return [];
-    }
+    const root = segments[0];
+    if (root === "lessons") return this.browseLessons(path, segments);
+    if (root === "addons") return this.browseAddOns(path, segments);
+    return [];
+  }
+  async browseLessons(currentPath, segments) {
+    const depth = segments.length;
+    if (depth === 1) return this.getPrograms();
+    if (depth === 2) return this.getStudies(segments[1], currentPath);
+    if (depth === 3) return this.getLessons(segments[2], currentPath);
+    if (depth === 4) return this.getVenues(segments[3], currentPath);
+    if (depth === 5) return this.getPlaylistFiles(segments[4]);
+    return [];
   }
   async getPrograms() {
-    const path = this.config.endpoints.programs;
-    const response = await this.apiRequest(path);
+    const apiPath = this.config.endpoints.programs;
+    const response = await this.apiRequest(apiPath);
     if (!response) return [];
     const programs = Array.isArray(response) ? response : [];
     return programs.map((p) => ({
@@ -896,12 +1099,10 @@ var LessonsChurchProvider = class extends ContentProvider {
       id: p.id,
       title: p.name,
       image: p.image,
-      providerData: { level: "studies", programId: p.id }
+      path: `/lessons/${p.id}`
     }));
   }
-  async getStudies(folder) {
-    const programId = folder.providerData?.programId;
-    if (!programId) return [];
+  async getStudies(programId, currentPath) {
     const pathFn = this.config.endpoints.studies;
     const response = await this.apiRequest(pathFn(programId));
     if (!response) return [];
@@ -911,12 +1112,10 @@ var LessonsChurchProvider = class extends ContentProvider {
       id: s.id,
       title: s.name,
       image: s.image,
-      providerData: { level: "lessons", studyId: s.id }
+      path: `${currentPath}/${s.id}`
     }));
   }
-  async getLessons(folder) {
-    const studyId = folder.providerData?.studyId;
-    if (!studyId) return [];
+  async getLessons(studyId, currentPath) {
     const pathFn = this.config.endpoints.lessons;
     const response = await this.apiRequest(pathFn(studyId));
     if (!response) return [];
@@ -926,31 +1125,42 @@ var LessonsChurchProvider = class extends ContentProvider {
       id: l.id,
       title: l.name || l.title,
       image: l.image,
-      providerData: { level: "venues", lessonId: l.id, lessonImage: l.image }
+      path: `${currentPath}/${l.id}`,
+      providerData: { lessonImage: l.image }
+      // Keep for display on venues
     }));
   }
-  async getVenues(folder) {
-    const lessonId = folder.providerData?.lessonId;
-    if (!lessonId) return [];
+  async getVenues(lessonId, currentPath) {
     const pathFn = this.config.endpoints.venues;
     const response = await this.apiRequest(pathFn(lessonId));
     if (!response) return [];
+    const lessonResponse = await this.apiRequest(`/lessons/public/${lessonId}`);
+    const lessonImage = lessonResponse?.image;
     const venues = Array.isArray(response) ? response : [];
-    return venues.map((v) => ({
+    const result = venues.map((v) => ({
       type: "folder",
       id: v.id,
       title: v.name,
-      image: folder.providerData?.lessonImage,
-      providerData: { level: "playlist", venueId: v.id }
+      image: lessonImage,
+      isLeaf: true,
+      path: `${currentPath}/${v.id}`
     }));
+    console.log("[LessonsChurchProvider.getVenues] returning:", result.map((r) => ({ id: r.id, title: r.title, isLeaf: r.isLeaf })));
+    return result;
   }
-  async getPlaylistFiles(folder, resolution) {
-    const files = await this.getPlaylist(folder, null, resolution);
+  async getPlaylistFiles(venueId) {
+    const files = await this.getPlaylist(`/lessons/_/_/_/${venueId}`, null);
     return files || [];
   }
+  async browseAddOns(_currentPath, segments) {
+    const depth = segments.length;
+    if (depth === 1) return this.getAddOnCategories();
+    if (depth === 2) return this.getAddOnsByCategory(segments[1]);
+    return [];
+  }
   async getAddOnCategories() {
-    const path = this.config.endpoints.addOns;
-    const response = await this.apiRequest(path);
+    const apiPath = this.config.endpoints.addOns;
+    const response = await this.apiRequest(apiPath);
     if (!response) return [];
     const addOns = Array.isArray(response) ? response : [];
     const categories = Array.from(new Set(addOns.map((a) => a.category).filter(Boolean)));
@@ -958,17 +1168,16 @@ var LessonsChurchProvider = class extends ContentProvider {
       type: "folder",
       id: `category-${category}`,
       title: category,
-      providerData: {
-        level: "addOns",
-        category,
-        allAddOns: addOns
-      }
+      path: `/addons/${encodeURIComponent(category)}`
     }));
   }
-  async getAddOnsByCategory(folder) {
-    const category = folder.providerData?.category;
-    const allAddOns = folder.providerData?.allAddOns || [];
-    const filtered = allAddOns.filter((a) => a.category === category);
+  async getAddOnsByCategory(category) {
+    const decodedCategory = decodeURIComponent(category);
+    const apiPath = this.config.endpoints.addOns;
+    const response = await this.apiRequest(apiPath);
+    if (!response) return [];
+    const allAddOns = Array.isArray(response) ? response : [];
+    const filtered = allAddOns.filter((a) => a.category === decodedCategory);
     const files = [];
     for (const addOn of filtered) {
       const file = await this.convertAddOnToFile(addOn);
@@ -978,8 +1187,8 @@ var LessonsChurchProvider = class extends ContentProvider {
   }
   async convertAddOnToFile(addOn) {
     const pathFn = this.config.endpoints.addOnDetail;
-    const path = pathFn(addOn.id);
-    const detail = await this.apiRequest(path);
+    const apiPath = pathFn(addOn.id);
+    const detail = await this.apiRequest(apiPath);
     if (!detail) return null;
     let url = "";
     let mediaType = "video";
@@ -994,53 +1203,32 @@ var LessonsChurchProvider = class extends ContentProvider {
       const fileType = file.fileType;
       mediaType = fileType?.startsWith("video/") ? "video" : "image";
     } else {
-      return null;
-    }
-    return {
-      type: "file",
-      id: addOn.id,
-      title: addOn.name,
-      mediaType,
-      image: addOn.image,
-      url,
-      embedUrl: `https://lessons.church/embed/addon/${addOn.id}`,
-      providerData: {
-        seconds,
-        loopVideo: video?.loopVideo || false
-      }
-    };
+      return null;
+    }
+    return { type: "file", id: addOn.id, title: addOn.name, mediaType, image: addOn.image, url, embedUrl: `https://lessons.church/embed/addon/${addOn.id}`, providerData: { seconds, loopVideo: video?.loopVideo || false } };
   }
-  async getPresentations(folder, _auth, resolution) {
-    const venueId = folder.providerData?.venueId;
+  async getPresentations(path, _auth) {
+    const venueId = getSegment(path, 4);
     if (!venueId) return null;
-    let path = `/venues/public/feed/${venueId}`;
-    if (resolution) path += `?resolution=${resolution}`;
-    const venueData = await this.apiRequest(path);
+    const apiPath = `/venues/public/feed/${venueId}`;
+    const venueData = await this.apiRequest(apiPath);
     if (!venueData) return null;
     return this.convertVenueToPlan(venueData);
   }
-  async getInstructions(folder, _auth) {
-    const venueId = folder.providerData?.venueId;
+  async getInstructions(path, _auth) {
+    const venueId = getSegment(path, 4);
     if (!venueId) return null;
     const response = await this.apiRequest(`/venues/public/planItems/${venueId}`);
     if (!response) return null;
-    const processItem = (item) => ({
-      id: item.id,
-      itemType: item.itemType,
-      relatedId: item.relatedId,
-      label: item.label,
-      description: item.description,
-      seconds: item.seconds,
-      children: item.children?.map(processItem),
-      embedUrl: this.getEmbedUrl(item.itemType, item.relatedId)
-    });
-    return {
-      venueName: response.venueName,
-      items: (response.items || []).map(processItem)
+    const processItem = (item) => {
+      const itemType = this.normalizeItemType(item.itemType);
+      const relatedId = item.relatedId;
+      return { id: item.id, itemType, relatedId, label: item.label, description: item.description, seconds: item.seconds, children: item.children?.map(processItem), embedUrl: this.getEmbedUrl(itemType, relatedId) };
     };
+    return { venueName: response.venueName, items: (response.items || []).map(processItem) };
   }
-  async getExpandedInstructions(folder, _auth) {
-    const venueId = folder.providerData?.venueId;
+  async getExpandedInstructions(path, _auth) {
+    const venueId = getSegment(path, 4);
     if (!venueId) return null;
     const [planItemsResponse, actionsResponse] = await Promise.all([
       this.apiRequest(`/venues/public/planItems/${venueId}`),
@@ -1051,66 +1239,47 @@ var LessonsChurchProvider = class extends ContentProvider {
     if (actionsResponse?.sections) {
       for (const section of actionsResponse.sections) {
         if (section.id && section.actions) {
-          sectionActionsMap.set(section.id, section.actions.map((action) => ({
-            id: action.id,
-            itemType: "lessonAction",
-            relatedId: action.id,
-            label: action.name,
-            description: action.actionType,
-            seconds: action.seconds,
-            embedUrl: this.getEmbedUrl("lessonAction", action.id)
-          })));
+          sectionActionsMap.set(section.id, section.actions.map((action) => {
+            const embedUrl = this.getEmbedUrl("action", action.id);
+            return { id: action.id, itemType: "action", relatedId: action.id, label: action.name, description: action.actionType, seconds: action.seconds, children: [{ id: action.id + "-file", itemType: "file", label: action.name, seconds: action.seconds, embedUrl }] };
+          }));
         }
       }
     }
     const processItem = (item) => {
       const relatedId = item.relatedId;
-      const itemType = item.itemType;
+      const itemType = this.normalizeItemType(item.itemType);
       const children = item.children;
       let processedChildren;
       if (children) {
         processedChildren = children.map((child) => {
           const childRelatedId = child.relatedId;
+          const childItemType = this.normalizeItemType(child.itemType);
           if (childRelatedId && sectionActionsMap.has(childRelatedId)) {
-            return {
-              id: child.id,
-              itemType: child.itemType,
-              relatedId: childRelatedId,
-              label: child.label,
-              description: child.description,
-              seconds: child.seconds,
-              children: sectionActionsMap.get(childRelatedId),
-              embedUrl: this.getEmbedUrl(child.itemType, childRelatedId)
-            };
+            return { id: child.id, itemType: childItemType, relatedId: childRelatedId, label: child.label, description: child.description, seconds: child.seconds, children: sectionActionsMap.get(childRelatedId), embedUrl: this.getEmbedUrl(childItemType, childRelatedId) };
           }
           return processItem(child);
         });
       }
-      return {
-        id: item.id,
-        itemType,
-        relatedId,
-        label: item.label,
-        description: item.description,
-        seconds: item.seconds,
-        children: processedChildren,
-        embedUrl: this.getEmbedUrl(itemType, relatedId)
-      };
-    };
-    return {
-      venueName: planItemsResponse.venueName,
-      items: (planItemsResponse.items || []).map(processItem)
+      return { id: item.id, itemType, relatedId, label: item.label, description: item.description, seconds: item.seconds, children: processedChildren, embedUrl: this.getEmbedUrl(itemType, relatedId) };
     };
+    return { venueName: planItemsResponse.venueName, items: (planItemsResponse.items || []).map(processItem) };
+  }
+  normalizeItemType(type) {
+    if (type === "lessonSection") return "section";
+    if (type === "lessonAction") return "action";
+    if (type === "lessonAddOn") return "addon";
+    return type;
   }
   getEmbedUrl(itemType, relatedId) {
     if (!relatedId) return void 0;
     const baseUrl = "https://lessons.church";
     switch (itemType) {
-      case "lessonAction":
+      case "action":
         return `${baseUrl}/embed/action/${relatedId}`;
-      case "lessonAddOn":
+      case "addon":
         return `${baseUrl}/embed/addon/${relatedId}`;
-      case "lessonSection":
+      case "section":
         return `${baseUrl}/embed/section/${relatedId}`;
       default:
         return void 0;
@@ -1128,16 +1297,7 @@ var LessonsChurchProvider = class extends ContentProvider {
         for (const file of action.files || []) {
           if (!file.url) continue;
           const embedUrl = action.id ? `https://lessons.church/embed/action/${action.id}` : void 0;
-          const contentFile = {
-            type: "file",
-            id: file.id || "",
-            title: file.name || "",
-            mediaType: detectMediaType(file.url, file.fileType),
-            image: venue.lessonImage,
-            url: file.url,
-            embedUrl,
-            providerData: { seconds: file.seconds, streamUrl: file.streamUrl }
-          };
+          const contentFile = { type: "file", id: file.id || "", title: file.name || "", mediaType: detectMediaType(file.url, file.fileType), image: venue.lessonImage, url: file.url, embedUrl, providerData: { seconds: file.seconds, streamUrl: file.streamUrl } };
           files.push(contentFile);
           allFiles.push(contentFile);
         }
@@ -1149,51 +1309,69 @@ var LessonsChurchProvider = class extends ContentProvider {
         sections.push({ id: section.id || "", name: section.name || "Untitled Section", presentations });
       }
     }
-    return {
-      id: venue.id || "",
-      name: venue.lessonName || venue.name || "Plan",
-      description: venue.lessonDescription,
-      image: venue.lessonImage,
-      sections,
-      allFiles
-    };
+    return { id: venue.id || "", name: venue.lessonName || venue.name || "Plan", description: venue.lessonDescription, image: venue.lessonImage, sections, allFiles };
   }
 };
 
-// src/providers/b1church/auth.ts
-function buildB1AuthUrl(config, appBase, redirectUri, state) {
+// src/providers/b1Church/auth.ts
+async function generateCodeChallenge(verifier) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(verifier);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  const hashArray = new Uint8Array(hashBuffer);
+  let binary = "";
+  for (let i = 0; i < hashArray.length; i++) {
+    binary += String.fromCharCode(hashArray[i]);
+  }
+  const base64 = btoa(binary);
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+async function buildB1AuthUrl(config, appBase, redirectUri, codeVerifier, state) {
+  const codeChallenge = await generateCodeChallenge(codeVerifier);
   const oauthParams = new URLSearchParams({
+    response_type: "code",
     client_id: config.clientId,
     redirect_uri: redirectUri,
-    response_type: "code",
-    scope: config.scopes.join(" ")
+    scope: config.scopes.join(" "),
+    code_challenge: codeChallenge,
+    code_challenge_method: "S256",
+    state: state || ""
   });
-  if (state) {
-    oauthParams.set("state", state);
+  const url = `${appBase}/oauth?${oauthParams.toString()}`;
+  return { url, challengeMethod: "S256" };
+}
+async function exchangeCodeForTokensWithPKCE(config, code, redirectUri, codeVerifier) {
+  try {
+    const params = { grant_type: "authorization_code", code, client_id: config.clientId, code_verifier: codeVerifier, redirect_uri: redirectUri };
+    const tokenUrl = `${config.oauthBase}/token`;
+    console.log(`B1Church PKCE token exchange request to: ${tokenUrl}`);
+    console.log(`  - client_id: ${config.clientId}`);
+    console.log(`  - redirect_uri: ${redirectUri}`);
+    console.log(`  - code: ${code.substring(0, 10)}...`);
+    const response = await fetch(tokenUrl, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(params) });
+    console.log(`B1Church token response status: ${response.status}`);
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error(`B1Church token exchange failed: ${response.status} - ${errorText}`);
+      return null;
+    }
+    const data = await response.json();
+    console.log(`B1Church token exchange successful, got access_token: ${!!data.access_token}`);
+    return { access_token: data.access_token, refresh_token: data.refresh_token, token_type: data.token_type || "Bearer", created_at: Math.floor(Date.now() / 1e3), expires_in: data.expires_in, scope: data.scope || config.scopes.join(" ") };
+  } catch (error) {
+    console.error("B1Church token exchange error:", error);
+    return null;
   }
-  const returnUrl = `/oauth?${oauthParams.toString()}`;
-  const url = `${appBase}/login?returnUrl=${encodeURIComponent(returnUrl)}`;
-  return { url, challengeMethod: "none" };
 }
 async function exchangeCodeForTokensWithSecret(config, code, redirectUri, clientSecret) {
   try {
-    const params = {
-      grant_type: "authorization_code",
-      code,
-      client_id: config.clientId,
-      client_secret: clientSecret,
-      redirect_uri: redirectUri
-    };
+    const params = { grant_type: "authorization_code", code, client_id: config.clientId, client_secret: clientSecret, redirect_uri: redirectUri };
     const tokenUrl = `${config.oauthBase}/token`;
     console.log(`B1Church token exchange request to: ${tokenUrl}`);
     console.log(`  - client_id: ${config.clientId}`);
     console.log(`  - redirect_uri: ${redirectUri}`);
     console.log(`  - code: ${code.substring(0, 10)}...`);
-    const response = await fetch(tokenUrl, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(params)
-    });
+    const response = await fetch(tokenUrl, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(params) });
     console.log(`B1Church token response status: ${response.status}`);
     if (!response.ok) {
       const errorText = await response.text();
@@ -1202,14 +1380,7 @@ async function exchangeCodeForTokensWithSecret(config, code, redirectUri, client
     }
     const data = await response.json();
     console.log(`B1Church token exchange successful, got access_token: ${!!data.access_token}`);
-    return {
-      access_token: data.access_token,
-      refresh_token: data.refresh_token,
-      token_type: data.token_type || "Bearer",
-      created_at: Math.floor(Date.now() / 1e3),
-      expires_in: data.expires_in,
-      scope: data.scope || config.scopes.join(" ")
-    };
+    return { access_token: data.access_token, refresh_token: data.refresh_token, token_type: data.token_type || "Bearer", created_at: Math.floor(Date.now() / 1e3), expires_in: data.expires_in, scope: data.scope || config.scopes.join(" ") };
   } catch (error) {
     console.error("B1Church token exchange error:", error);
     return null;
@@ -1218,27 +1389,11 @@ async function exchangeCodeForTokensWithSecret(config, code, redirectUri, client
 async function refreshTokenWithSecret(config, auth, clientSecret) {
   if (!auth.refresh_token) return null;
   try {
-    const params = {
-      grant_type: "refresh_token",
-      refresh_token: auth.refresh_token,
-      client_id: config.clientId,
-      client_secret: clientSecret
-    };
-    const response = await fetch(`${config.oauthBase}/token`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(params)
-    });
+    const params = { grant_type: "refresh_token", refresh_token: auth.refresh_token, client_id: config.clientId, client_secret: clientSecret };
+    const response = await fetch(`${config.oauthBase}/token`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(params) });
     if (!response.ok) return null;
     const data = await response.json();
-    return {
-      access_token: data.access_token,
-      refresh_token: data.refresh_token || auth.refresh_token,
-      token_type: data.token_type || "Bearer",
-      created_at: Math.floor(Date.now() / 1e3),
-      expires_in: data.expires_in,
-      scope: data.scope || auth.scope
-    };
+    return { access_token: data.access_token, refresh_token: data.refresh_token || auth.refresh_token, token_type: data.token_type || "Bearer", created_at: Math.floor(Date.now() / 1e3), expires_in: data.expires_in, scope: data.scope || auth.scope };
   } catch {
     return null;
   }
@@ -1246,14 +1401,7 @@ async function refreshTokenWithSecret(config, auth, clientSecret) {
 async function initiateDeviceFlow(config) {
   if (!config.supportsDeviceFlow || !config.deviceAuthEndpoint) return null;
   try {
-    const response = await fetch(`${config.oauthBase}${config.deviceAuthEndpoint}`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        client_id: config.clientId,
-        scope: config.scopes.join(" ")
-      })
-    });
+    const response = await fetch(`${config.oauthBase}${config.deviceAuthEndpoint}`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ client_id: config.clientId, scope: config.scopes.join(" ") }) });
     if (!response.ok) {
       const errorText = await response.text();
       console.error(`B1Church device authorize failed: ${response.status} - ${errorText}`);
@@ -1267,25 +1415,10 @@ async function initiateDeviceFlow(config) {
 }
 async function pollDeviceFlowToken(config, deviceCode) {
   try {
-    const response = await fetch(`${config.oauthBase}/token`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
-        device_code: deviceCode,
-        client_id: config.clientId
-      })
-    });
+    const response = await fetch(`${config.oauthBase}/token`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ grant_type: "urn:ietf:params:oauth:grant-type:device_code", device_code: deviceCode, client_id: config.clientId }) });
     if (response.ok) {
       const data = await response.json();
-      return {
-        access_token: data.access_token,
-        refresh_token: data.refresh_token,
-        token_type: data.token_type || "Bearer",
-        created_at: Math.floor(Date.now() / 1e3),
-        expires_in: data.expires_in,
-        scope: data.scope || config.scopes.join(" ")
-      };
+      return { access_token: data.access_token, refresh_token: data.refresh_token, token_type: data.token_type || "Bearer", created_at: Math.floor(Date.now() / 1e3), expires_in: data.expires_in, scope: data.scope || config.scopes.join(" ") };
     }
     const errorData = await response.json();
     switch (errorData.error) {
@@ -1305,7 +1438,7 @@ async function pollDeviceFlowToken(config, deviceCode) {
   }
 }
 
-// src/providers/b1church/api.ts
+// src/providers/b1Church/api.ts
 var API_BASE = "https://api.churchapps.org";
 var LESSONS_API_BASE = "https://api.lessons.church";
 var CONTENT_API_BASE = "https://contentapi.churchapps.org";
@@ -1337,10 +1470,7 @@ async function fetchPlans(planTypeId, auth) {
 async function fetchVenueFeed(venueId) {
   try {
     const url = `${LESSONS_API_BASE}/venues/public/feed/${venueId}`;
-    const response = await fetch(url, {
-      method: "GET",
-      headers: { Accept: "application/json" }
-    });
+    const response = await fetch(url, { method: "GET", headers: { Accept: "application/json" } });
     if (!response.ok) return null;
     return await response.json();
   } catch {
@@ -1350,9 +1480,29 @@ async function fetchVenueFeed(venueId) {
 async function fetchArrangementKey(churchId, arrangementId) {
   try {
     const url = `${CONTENT_API_BASE}/arrangementKeys/presenter/${churchId}/${arrangementId}`;
+    const response = await fetch(url, { method: "GET", headers: { Accept: "application/json" } });
+    if (!response.ok) return null;
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+async function fetchFromProviderProxy(method, ministryId, providerId, path, authData, resolution) {
+  try {
+    const url = `${API_BASE}/doing/providerProxy/${method}`;
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    };
+    if (authData) {
+      headers["Authorization"] = `Bearer ${authData.access_token}`;
+    }
+    const body = { ministryId, providerId, path };
+    if (resolution !== void 0) body.resolution = resolution;
     const response = await fetch(url, {
-      method: "GET",
-      headers: { Accept: "application/json" }
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
     });
     if (!response.ok) return null;
     return await response.json();
@@ -1361,107 +1511,39 @@ async function fetchArrangementKey(churchId, arrangementId) {
   }
 }
 
-// src/providers/b1church/converters.ts
+// src/providers/b1Church/converters.ts
 function ministryToFolder(ministry) {
-  return {
-    type: "folder",
-    id: ministry.id,
-    title: ministry.name,
-    image: ministry.photoUrl,
-    providerData: {
-      level: "ministry",
-      ministryId: ministry.id,
-      churchId: ministry.churchId
-    }
-  };
+  return { type: "folder", id: ministry.id, title: ministry.name, path: "", image: ministry.photoUrl, providerData: { level: "ministry", ministryId: ministry.id, churchId: ministry.churchId } };
 }
 function planTypeToFolder(planType, ministryId) {
-  return {
-    type: "folder",
-    id: planType.id,
-    title: planType.name,
-    providerData: {
-      level: "planType",
-      planTypeId: planType.id,
-      ministryId,
-      churchId: planType.churchId
-    }
-  };
+  return { type: "folder", id: planType.id, title: planType.name, path: "", providerData: { level: "planType", planTypeId: planType.id, ministryId, churchId: planType.churchId } };
 }
 function planToFolder(plan) {
-  return {
-    type: "folder",
-    id: plan.id,
-    title: plan.name,
-    providerData: {
-      isLeaf: true,
-      level: "plan",
-      planId: plan.id,
-      planTypeId: plan.planTypeId,
-      ministryId: plan.ministryId,
-      churchId: plan.churchId,
-      serviceDate: plan.serviceDate,
-      contentType: plan.contentType,
-      contentId: plan.contentId
-    }
-  };
+  return { type: "folder", id: plan.id, title: plan.name, path: "", isLeaf: true, providerData: { level: "plan", planId: plan.id, planTypeId: plan.planTypeId, ministryId: plan.ministryId, churchId: plan.churchId, serviceDate: plan.serviceDate, contentType: plan.contentType, contentId: plan.contentId } };
 }
 async function planItemToPresentation(item, venueFeed) {
   const itemType = item.itemType;
   if (itemType === "arrangementKey" && item.churchId && item.relatedId) {
     const songData = await fetchArrangementKey(item.churchId, item.relatedId);
-    if (songData) {
-      return arrangementToPresentation(item, songData);
-    }
+    if (songData) return arrangementToPresentation(item, songData);
   }
-  if ((itemType === "lessonSection" || itemType === "lessonAction" || itemType === "lessonAddOn") && venueFeed) {
+  if ((itemType === "lessonSection" || itemType === "section" || itemType === "lessonAction" || itemType === "action" || itemType === "lessonAddOn" || itemType === "addon") && venueFeed) {
     const files = getFilesFromVenueFeed(venueFeed, itemType, item.relatedId);
-    if (files.length > 0) {
-      return {
-        id: item.id,
-        name: item.label || "Lesson Content",
-        actionType: itemType === "lessonAddOn" ? "add-on" : "play",
-        files
-      };
-    }
+    if (files.length > 0) return { id: item.id, name: item.label || "Lesson Content", actionType: itemType === "lessonAddOn" || itemType === "addon" ? "add-on" : "play", files };
   }
   if (itemType === "item" || itemType === "header") {
-    return {
-      id: item.id,
-      name: item.label || "",
-      actionType: "other",
-      files: [],
-      providerData: {
-        itemType,
-        description: item.description,
-        seconds: item.seconds
-      }
-    };
+    return { id: item.id, name: item.label || "", actionType: "other", files: [], providerData: { itemType, description: item.description, seconds: item.seconds } };
   }
   return null;
 }
 function arrangementToPresentation(item, songData) {
   const title = songData.songDetail?.title || item.label || "Song";
-  return {
-    id: item.id,
-    name: title,
-    actionType: "other",
-    files: [],
-    providerData: {
-      itemType: "song",
-      title,
-      artist: songData.songDetail?.artist,
-      lyrics: songData.arrangement?.lyrics,
-      keySignature: songData.arrangementKey?.keySignature,
-      arrangementName: songData.arrangement?.name,
-      seconds: songData.songDetail?.seconds || item.seconds
-    }
-  };
+  return { id: item.id, name: title, actionType: "other", files: [], providerData: { itemType: "song", title, artist: songData.songDetail?.artist, lyrics: songData.arrangement?.lyrics, keySignature: songData.arrangementKey?.keySignature, arrangementName: songData.arrangement?.name, seconds: songData.songDetail?.seconds || item.seconds } };
 }
 function getFilesFromVenueFeed(venueFeed, itemType, relatedId) {
   const files = [];
   if (!relatedId) return files;
-  if (itemType === "lessonSection") {
+  if (itemType === "lessonSection" || itemType === "section") {
     for (const section of venueFeed.sections || []) {
       if (section.id === relatedId) {
         for (const action of section.actions || []) {
@@ -1473,7 +1555,7 @@ function getFilesFromVenueFeed(venueFeed, itemType, relatedId) {
         break;
       }
     }
-  } else if (itemType === "lessonAction") {
+  } else if (itemType === "lessonAction" || itemType === "action") {
     for (const section of venueFeed.sections || []) {
       for (const action of section.actions || []) {
         if (action.id === relatedId) {
@@ -1486,75 +1568,51 @@ function getFilesFromVenueFeed(venueFeed, itemType, relatedId) {
   return files;
 }
 function convertFeedFiles(feedFiles, thumbnailImage) {
-  return feedFiles.filter((f) => f.url).map((f) => ({
-    type: "file",
-    id: f.id || "",
-    title: f.name || "",
-    mediaType: detectMediaType(f.url || "", f.fileType),
-    image: thumbnailImage,
-    url: f.url || "",
-    providerData: { seconds: f.seconds, streamUrl: f.streamUrl }
-  }));
+  return feedFiles.filter((f) => f.url).map((f) => ({ type: "file", id: f.id || "", title: f.name || "", mediaType: detectMediaType(f.url || "", f.fileType), image: thumbnailImage, url: f.url || "", providerData: { seconds: f.seconds, streamUrl: f.streamUrl } }));
 }
 function planItemToInstruction(item) {
-  return {
-    id: item.id,
-    itemType: item.itemType,
-    relatedId: item.relatedId,
-    label: item.label,
-    description: item.description,
-    seconds: item.seconds,
-    children: item.children?.map(planItemToInstruction)
-  };
+  let itemType = item.itemType;
+  switch (item.itemType) {
+    case "lessonSection":
+      itemType = "section";
+      break;
+    case "lessonAction":
+      itemType = "action";
+      break;
+    case "lessonAddOn":
+      itemType = "addon";
+      break;
+  }
+  return { id: item.id, itemType, relatedId: item.relatedId, label: item.label, description: item.description, seconds: item.seconds, children: item.children?.map(planItemToInstruction) };
 }
 
-// src/providers/b1church/B1ChurchProvider.ts
-var B1ChurchProvider = class extends ContentProvider {
+// src/providers/b1Church/B1ChurchProvider.ts
+var INTERNAL_PROVIDERS = ["b1church", "lessonschurch"];
+function isExternalProviderItem(item) {
+  if (!item.providerId || INTERNAL_PROVIDERS.includes(item.providerId)) return false;
+  const itemType = item.itemType || "";
+  return itemType.startsWith("provider");
+}
+var B1ChurchProvider = class {
   constructor() {
-    super(...arguments);
+    this.apiHelper = new ApiHelper();
     this.id = "b1church";
     this.name = "B1.Church";
-    this.logos = {
-      light: "https://b1.church/b1-church-logo.png",
-      dark: "https://b1.church/b1-church-logo.png"
-    };
-    this.config = {
-      id: "b1church",
-      name: "B1.Church",
-      apiBase: `${API_BASE}/doing`,
-      oauthBase: `${API_BASE}/membership/oauth`,
-      clientId: "",
-      // Consumer must provide client_id
-      scopes: ["plans"],
-      supportsDeviceFlow: true,
-      deviceAuthEndpoint: "/device/authorize",
-      endpoints: {
-        planItems: (churchId, planId) => `/planItems/presenter/${churchId}/${planId}`
-      }
-    };
+    this.logos = { light: "https://b1.church/b1-church-logo.png", dark: "https://b1.church/b1-church-logo.png" };
+    this.config = { id: "b1church", name: "B1.Church", apiBase: `${API_BASE}/doing`, oauthBase: `${API_BASE}/membership/oauth`, clientId: "nsowldn58dk", scopes: ["plans"], supportsDeviceFlow: true, deviceAuthEndpoint: "/device/authorize", endpoints: { planItems: (churchId, planId) => `/planItems/presenter/${churchId}/${planId}` } };
     this.appBase = "https://admin.b1.church";
+    this.requiresAuth = true;
+    this.authTypes = ["oauth_pkce", "device_flow"];
+    this.capabilities = { browse: true, presentations: true, playlist: true, instructions: true, expandedInstructions: true, mediaLicensing: false };
   }
-  // ============================================================
-  // Provider Info
-  // ============================================================
-  requiresAuth() {
-    return true;
+  async apiRequest(path, authData) {
+    return this.apiHelper.apiRequest(this.config, this.id, path, authData);
   }
-  getCapabilities() {
-    return {
-      browse: true,
-      presentations: true,
-      playlist: true,
-      instructions: true,
-      expandedInstructions: true,
-      mediaLicensing: false
-    };
+  async buildAuthUrl(codeVerifier, redirectUri, state) {
+    return buildB1AuthUrl(this.config, this.appBase, redirectUri, codeVerifier, state);
   }
-  // ============================================================
-  // Authentication
-  // ============================================================
-  async buildAuthUrl(_codeVerifier, redirectUri, state) {
-    return buildB1AuthUrl(this.config, this.appBase, redirectUri, state);
+  async exchangeCodeForTokensWithPKCE(code, redirectUri, codeVerifier) {
+    return exchangeCodeForTokensWithPKCE(this.config, code, redirectUri, codeVerifier);
   }
   async exchangeCodeForTokensWithSecret(code, redirectUri, clientSecret) {
     return exchangeCodeForTokensWithSecret(this.config, code, redirectUri, clientSecret);
@@ -1568,48 +1626,69 @@ var B1ChurchProvider = class extends ContentProvider {
   async pollDeviceFlowToken(deviceCode) {
     return pollDeviceFlowToken(this.config, deviceCode);
   }
-  // ============================================================
-  // Content Browsing
-  // ============================================================
-  /**
-   * Browse content hierarchy:
-   * - Root: List of ministries (groups with "ministry" tag)
-   * - Ministry: List of plan types
-   * - PlanType: List of plans (leaf nodes)
-   *
-   * Plans are leaf nodes - use getPresentations(), getPlaylist(), getInstructions()
-   * to get plan content.
-   */
-  async browse(folder, authData) {
-    if (!folder) {
+  async browse(path, authData) {
+    const { segments, depth } = parsePath(path);
+    if (depth === 0) {
+      return [{
+        type: "folder",
+        id: "ministries-root",
+        title: "Ministries",
+        path: "/ministries"
+      }];
+    }
+    const root = segments[0];
+    if (root !== "ministries") return [];
+    if (depth === 1) {
       const ministries = await fetchMinistries(authData);
-      return ministries.map(ministryToFolder);
+      return ministries.map((m) => {
+        const folder = ministryToFolder(m);
+        const ministryId = folder.providerData?.ministryId || folder.id;
+        return { ...folder, path: `/ministries/${ministryId}` };
+      });
     }
-    const level = folder.providerData?.level;
-    if (level === "ministry") {
-      const ministryId = folder.providerData?.ministryId;
-      if (!ministryId) return [];
+    if (depth === 2) {
+      const ministryId = segments[1];
       const planTypes = await fetchPlanTypes(ministryId, authData);
-      return planTypes.map((pt) => planTypeToFolder(pt, ministryId));
+      return planTypes.map((pt) => {
+        const folder = planTypeToFolder(pt, ministryId);
+        const planTypeId = folder.providerData?.planTypeId || folder.id;
+        return { ...folder, path: `/ministries/${ministryId}/${planTypeId}` };
+      });
     }
-    if (level === "planType") {
-      const planTypeId = folder.providerData?.planTypeId;
-      if (!planTypeId) return [];
+    if (depth === 3) {
+      const ministryId = segments[1];
+      const planTypeId = segments[2];
       const plans = await fetchPlans(planTypeId, authData);
-      return plans.map(planToFolder);
+      return plans.map((p) => {
+        const folder = planToFolder(p);
+        const planId = folder.providerData?.planId || folder.id;
+        return {
+          ...folder,
+          isLeaf: true,
+          path: `/ministries/${ministryId}/${planTypeId}/${planId}`
+        };
+      });
     }
     return [];
   }
-  // ============================================================
-  // Presentations
-  // ============================================================
-  async getPresentations(folder, authData) {
-    const level = folder.providerData?.level;
-    if (level !== "plan") return null;
-    const planId = folder.providerData?.planId;
-    const churchId = folder.providerData?.churchId;
-    const venueId = folder.providerData?.contentId;
-    if (!planId || !churchId) return null;
+  async getPresentations(path, authData) {
+    const { segments, depth } = parsePath(path);
+    if (depth < 4 || segments[0] !== "ministries") return null;
+    const ministryId = segments[1];
+    const planId = segments[3];
+    const planTypeId = segments[2];
+    const plans = await fetchPlans(planTypeId, authData);
+    const planFolder = plans.find((p) => {
+      const folder2 = planToFolder(p);
+      return folder2.providerData?.planId === planId || folder2.id === planId;
+    });
+    if (!planFolder) return null;
+    const folder = planToFolder(planFolder);
+    const providerData = folder.providerData;
+    const churchId = providerData?.churchId;
+    const venueId = providerData?.contentId;
+    const planTitle = folder.title || "Plan";
+    if (!churchId) return null;
     const pathFn = this.config.endpoints.planItems;
     const planItems = await this.apiRequest(pathFn(churchId, planId), authData);
     if (!planItems || !Array.isArray(planItems)) return null;
@@ -1619,49 +1698,101 @@ var B1ChurchProvider = class extends ContentProvider {
     for (const sectionItem of planItems) {
       const presentations = [];
       for (const child of sectionItem.children || []) {
-        const presentation = await planItemToPresentation(child, venueFeed);
-        if (presentation) {
-          presentations.push(presentation);
-          allFiles.push(...presentation.files);
+        if (isExternalProviderItem(child) && child.providerId && child.providerPath) {
+          const externalPlan = await fetchFromProviderProxy(
+            "getPresentations",
+            ministryId,
+            child.providerId,
+            child.providerPath,
+            authData
+          );
+          if (externalPlan) {
+            for (const section of externalPlan.sections) {
+              presentations.push(...section.presentations);
+            }
+            allFiles.push(...externalPlan.allFiles);
+          }
+        } else {
+          const presentation = await planItemToPresentation(child, venueFeed);
+          if (presentation) {
+            presentations.push(presentation);
+            allFiles.push(...presentation.files);
+          }
         }
       }
       if (presentations.length > 0 || sectionItem.label) {
-        sections.push({
-          id: sectionItem.id,
-          name: sectionItem.label || "Section",
-          presentations
-        });
+        sections.push({ id: sectionItem.id, name: sectionItem.label || "Section", presentations });
       }
     }
-    return { id: planId, name: folder.title, sections, allFiles };
-  }
-  // ============================================================
-  // Instructions
-  // ============================================================
-  async getInstructions(folder, authData) {
-    const level = folder.providerData?.level;
-    if (level !== "plan") return null;
-    const planId = folder.providerData?.planId;
-    const churchId = folder.providerData?.churchId;
-    if (!planId || !churchId) return null;
+    return { id: planId, name: planTitle, sections, allFiles };
+  }
+  async getInstructions(path, authData) {
+    const { segments, depth } = parsePath(path);
+    if (depth < 4 || segments[0] !== "ministries") return null;
+    const ministryId = segments[1];
+    const planId = segments[3];
+    const planTypeId = segments[2];
+    const plans = await fetchPlans(planTypeId, authData);
+    const planFolder = plans.find((p) => {
+      const folder2 = planToFolder(p);
+      return folder2.providerData?.planId === planId || folder2.id === planId;
+    });
+    if (!planFolder) return null;
+    const folder = planToFolder(planFolder);
+    const providerData = folder.providerData;
+    const churchId = providerData?.churchId;
+    const planTitle = folder.title || "Plan";
+    if (!churchId) return null;
     const pathFn = this.config.endpoints.planItems;
     const planItems = await this.apiRequest(pathFn(churchId, planId), authData);
     if (!planItems || !Array.isArray(planItems)) return null;
-    return {
-      venueName: folder.title,
-      items: planItems.map(planItemToInstruction)
-    };
+    const processedItems = await this.processInstructionItems(planItems, ministryId, authData);
+    return { venueName: planTitle, items: processedItems };
+  }
+  async getExpandedInstructions(path, authData) {
+    return this.getInstructions(path, authData);
+  }
+  async processInstructionItems(items, ministryId, authData) {
+    const result = [];
+    for (const item of items) {
+      if (isExternalProviderItem(item) && item.providerId && item.providerPath) {
+        const externalInstructions = await fetchFromProviderProxy(
+          "getExpandedInstructions",
+          ministryId,
+          item.providerId,
+          item.providerPath,
+          authData
+        );
+        if (externalInstructions) {
+          result.push(...externalInstructions.items);
+        }
+      } else {
+        const instructionItem = planItemToInstruction(item);
+        if (item.children && item.children.length > 0) {
+          instructionItem.children = await this.processInstructionItems(item.children, ministryId, authData);
+        }
+        result.push(instructionItem);
+      }
+    }
+    return result;
   }
-  // ============================================================
-  // Playlist
-  // ============================================================
-  async getPlaylist(folder, authData) {
-    const level = folder.providerData?.level;
-    if (level !== "plan") return [];
-    const planId = folder.providerData?.planId;
-    const churchId = folder.providerData?.churchId;
-    const venueId = folder.providerData?.contentId;
-    if (!planId || !churchId) return [];
+  async getPlaylist(path, authData, resolution) {
+    const { segments, depth } = parsePath(path);
+    if (depth < 4 || segments[0] !== "ministries") return [];
+    const ministryId = segments[1];
+    const planId = segments[3];
+    const planTypeId = segments[2];
+    const plans = await fetchPlans(planTypeId, authData);
+    const planFolder = plans.find((p) => {
+      const folder2 = planToFolder(p);
+      return folder2.providerData?.planId === planId || folder2.id === planId;
+    });
+    if (!planFolder) return [];
+    const folder = planToFolder(planFolder);
+    const providerData = folder.providerData;
+    const churchId = providerData?.churchId;
+    const venueId = providerData?.contentId;
+    if (!churchId) return [];
     const pathFn = this.config.endpoints.planItems;
     const planItems = await this.apiRequest(pathFn(churchId, planId), authData);
     if (!planItems || !Array.isArray(planItems)) return [];
@@ -1669,10 +1800,24 @@ var B1ChurchProvider = class extends ContentProvider {
     const files = [];
     for (const sectionItem of planItems) {
       for (const child of sectionItem.children || []) {
-        const itemType = child.itemType;
-        if ((itemType === "lessonSection" || itemType === "lessonAction" || itemType === "lessonAddOn") && venueFeed) {
-          const itemFiles = getFilesFromVenueFeed(venueFeed, itemType, child.relatedId);
-          files.push(...itemFiles);
+        if (isExternalProviderItem(child) && child.providerId && child.providerPath) {
+          const externalFiles = await fetchFromProviderProxy(
+            "getPlaylist",
+            ministryId,
+            child.providerId,
+            child.providerPath,
+            authData,
+            resolution
+          );
+          if (externalFiles) {
+            files.push(...externalFiles);
+          }
+        } else {
+          const itemType = child.itemType;
+          if ((itemType === "lessonSection" || itemType === "section" || itemType === "lessonAction" || itemType === "action" || itemType === "lessonAddOn" || itemType === "addon") && venueFeed) {
+            const itemFiles = getFilesFromVenueFeed(venueFeed, itemType, child.relatedId);
+            files.push(...itemFiles);
+          }
         }
       }
     }
@@ -1680,81 +1825,62 @@ var B1ChurchProvider = class extends ContentProvider {
   }
 };
 
-// src/providers/PlanningCenterProvider.ts
-var PlanningCenterProvider = class extends ContentProvider {
+// src/providers/planningCenter/PlanningCenterProvider.ts
+var PlanningCenterProvider = class {
   constructor() {
-    super(...arguments);
+    this.apiHelper = new ApiHelper();
     this.id = "planningcenter";
     this.name = "Planning Center";
-    this.logos = {
-      light: "https://www.planningcenter.com/icons/icon-512x512.png",
-      dark: "https://www.planningcenter.com/icons/icon-512x512.png"
-    };
-    // Planning Center uses OAuth 2.0 with PKCE (handled by base ContentProvider class)
-    this.config = {
-      id: "planningcenter",
-      name: "Planning Center",
-      apiBase: "https://api.planningcenteronline.com",
-      oauthBase: "https://api.planningcenteronline.com/oauth",
-      clientId: "",
-      // Consumer must provide client_id
-      scopes: ["services"],
-      endpoints: {
-        serviceTypes: "/services/v2/service_types",
-        plans: (serviceTypeId) => `/services/v2/service_types/${serviceTypeId}/plans`,
-        planItems: (serviceTypeId, planId) => `/services/v2/service_types/${serviceTypeId}/plans/${planId}/items`,
-        song: (itemId) => `/services/v2/songs/${itemId}`,
-        arrangement: (songId, arrangementId) => `/services/v2/songs/${songId}/arrangements/${arrangementId}`,
-        arrangementSections: (songId, arrangementId) => `/services/v2/songs/${songId}/arrangements/${arrangementId}/sections`,
-        media: (mediaId) => `/services/v2/media/${mediaId}`,
-        mediaAttachments: (mediaId) => `/services/v2/media/${mediaId}/attachments`
-      }
-    };
+    this.logos = { light: "https://www.planningcenter.com/icons/icon-512x512.png", dark: "https://www.planningcenter.com/icons/icon-512x512.png" };
+    this.config = { id: "planningcenter", name: "Planning Center", apiBase: "https://api.planningcenteronline.com", oauthBase: "https://api.planningcenteronline.com/oauth", clientId: "", scopes: ["services"], endpoints: { serviceTypes: "/services/v2/service_types", plans: (serviceTypeId) => `/services/v2/service_types/${serviceTypeId}/plans`, planItems: (serviceTypeId, planId) => `/services/v2/service_types/${serviceTypeId}/plans/${planId}/items`, song: (itemId) => `/services/v2/songs/${itemId}`, arrangement: (songId, arrangementId) => `/services/v2/songs/${songId}/arrangements/${arrangementId}`, arrangementSections: (songId, arrangementId) => `/services/v2/songs/${songId}/arrangements/${arrangementId}/sections`, media: (mediaId) => `/services/v2/media/${mediaId}`, mediaAttachments: (mediaId) => `/services/v2/media/${mediaId}/attachments` } };
     this.ONE_WEEK_MS = 6048e5;
+    this.requiresAuth = true;
+    this.authTypes = ["oauth_pkce"];
+    this.capabilities = { browse: true, presentations: true, playlist: false, instructions: false, expandedInstructions: false, mediaLicensing: false };
   }
-  requiresAuth() {
-    return true;
-  }
-  getCapabilities() {
-    return {
-      browse: true,
-      presentations: true,
-      playlist: false,
-      instructions: false,
-      expandedInstructions: false,
-      mediaLicensing: false
-    };
+  async apiRequest(path, auth) {
+    return this.apiHelper.apiRequest(this.config, this.id, path, auth);
   }
-  async browse(folder, auth) {
-    if (!folder) {
-      const response = await this.apiRequest(
-        this.config.endpoints.serviceTypes,
-        auth
-      );
-      if (!response?.data) return [];
-      return response.data.map((serviceType) => ({
+  async browse(path, auth) {
+    const { segments, depth } = parsePath(path);
+    if (depth === 0) {
+      return [{
         type: "folder",
-        id: serviceType.id,
-        title: serviceType.attributes.name,
-        providerData: {
-          level: "serviceType",
-          serviceTypeId: serviceType.id
-        }
-      }));
+        id: "serviceTypes-root",
+        title: "Service Types",
+        path: "/serviceTypes"
+      }];
     }
-    const level = folder.providerData?.level;
-    switch (level) {
-      case "serviceType":
-        return this.getPlans(folder, auth);
-      case "plan":
-        return this.getPlanItems(folder, auth);
-      default:
-        return [];
+    const root = segments[0];
+    if (root !== "serviceTypes") return [];
+    if (depth === 1) {
+      return this.getServiceTypes(auth);
     }
+    if (depth === 2) {
+      const serviceTypeId = segments[1];
+      return this.getPlans(serviceTypeId, path, auth);
+    }
+    if (depth === 3) {
+      const serviceTypeId = segments[1];
+      const planId = segments[2];
+      return this.getPlanItems(serviceTypeId, planId, auth);
+    }
+    return [];
+  }
+  async getServiceTypes(auth) {
+    const response = await this.apiRequest(
+      this.config.endpoints.serviceTypes,
+      auth
+    );
+    if (!response?.data) return [];
+    return response.data.map((serviceType) => ({
+      type: "folder",
+      id: serviceType.id,
+      title: serviceType.attributes.name,
+      path: `/serviceTypes/${serviceType.id}`
+    }));
   }
-  async getPlans(folder, auth) {
-    const serviceTypeId = folder.providerData?.serviceTypeId;
-    if (!serviceTypeId) return [];
+  async getPlans(serviceTypeId, currentPath, auth) {
     const pathFn = this.config.endpoints.plans;
     const response = await this.apiRequest(
       `${pathFn(serviceTypeId)}?filter=future&order=sort_date`,
@@ -1771,73 +1897,46 @@ var PlanningCenterProvider = class extends ContentProvider {
       type: "folder",
       id: plan.id,
       title: plan.attributes.title || this.formatDate(plan.attributes.sort_date),
-      providerData: {
-        level: "plan",
-        serviceTypeId,
-        planId: plan.id,
-        sortDate: plan.attributes.sort_date
-      }
+      isLeaf: true,
+      path: `${currentPath}/${plan.id}`,
+      providerData: { sortDate: plan.attributes.sort_date }
     }));
   }
-  async getPlanItems(folder, auth) {
-    const serviceTypeId = folder.providerData?.serviceTypeId;
-    const planId = folder.providerData?.planId;
-    if (!serviceTypeId || !planId) return [];
+  async getPlanItems(serviceTypeId, planId, auth) {
     const pathFn = this.config.endpoints.planItems;
     const response = await this.apiRequest(
       `${pathFn(serviceTypeId, planId)}?per_page=100`,
       auth
     );
     if (!response?.data) return [];
-    return response.data.map((item) => ({
-      type: "file",
-      id: item.id,
-      title: item.attributes.title || "",
-      mediaType: "image",
-      url: "",
-      providerData: {
-        itemType: item.attributes.item_type,
-        description: item.attributes.description,
-        length: item.attributes.length,
-        songId: item.relationships?.song?.data?.id,
-        arrangementId: item.relationships?.arrangement?.data?.id
-      }
-    }));
+    return response.data.map((item) => ({ type: "file", id: item.id, title: item.attributes.title || "", mediaType: "image", url: "", providerData: { itemType: item.attributes.item_type, description: item.attributes.description, length: item.attributes.length, songId: item.relationships?.song?.data?.id, arrangementId: item.relationships?.arrangement?.data?.id } }));
   }
-  async getPresentations(folder, auth) {
-    const level = folder.providerData?.level;
-    if (level !== "plan") return null;
-    const serviceTypeId = folder.providerData?.serviceTypeId;
-    const planId = folder.providerData?.planId;
-    if (!serviceTypeId || !planId) return null;
+  async getPresentations(path, auth) {
+    const { segments, depth } = parsePath(path);
+    if (depth < 3 || segments[0] !== "serviceTypes") return null;
+    const serviceTypeId = segments[1];
+    const planId = segments[2];
     const pathFn = this.config.endpoints.planItems;
     const response = await this.apiRequest(
       `${pathFn(serviceTypeId, planId)}?per_page=100`,
       auth
     );
     if (!response?.data) return null;
+    const plans = await this.getPlans(serviceTypeId, `/serviceTypes/${serviceTypeId}`, auth);
+    const plan = plans.find((p) => p.id === planId);
+    const planTitle = plan?.title || "Plan";
     const sections = [];
     const allFiles = [];
     let currentSection = null;
     for (const item of response.data) {
       const itemType = item.attributes.item_type;
       if (itemType === "header") {
-        if (currentSection && currentSection.presentations.length > 0) {
-          sections.push(currentSection);
-        }
-        currentSection = {
-          id: item.id,
-          name: item.attributes.title || "Section",
-          presentations: []
-        };
+        if (currentSection && currentSection.presentations.length > 0) sections.push(currentSection);
+        currentSection = { id: item.id, name: item.attributes.title || "Section", presentations: [] };
         continue;
       }
       if (!currentSection) {
-        currentSection = {
-          id: `default-${planId}`,
-          name: "Service",
-          presentations: []
-        };
+        currentSection = { id: `default-${planId}`, name: "Service", presentations: [] };
       }
       const presentation = await this.convertToPresentation(item, auth);
       if (presentation) {
@@ -1848,12 +1947,7 @@ var PlanningCenterProvider = class extends ContentProvider {
     if (currentSection && currentSection.presentations.length > 0) {
       sections.push(currentSection);
     }
-    return {
-      id: planId,
-      name: folder.title,
-      sections,
-      allFiles
-    };
+    return { id: planId, name: planTitle, sections, allFiles };
   }
   async convertToPresentation(item, auth) {
     const itemType = item.attributes.item_type;
@@ -1864,17 +1958,7 @@ var PlanningCenterProvider = class extends ContentProvider {
       return this.convertMediaToPresentation(item, auth);
     }
     if (itemType === "item") {
-      return {
-        id: item.id,
-        name: item.attributes.title || "",
-        actionType: "other",
-        files: [],
-        providerData: {
-          itemType: "item",
-          description: item.attributes.description,
-          length: item.attributes.length
-        }
-      };
+      return { id: item.id, name: item.attributes.title || "", actionType: "other", files: [], providerData: { itemType: "item", description: item.attributes.description, length: item.attributes.length } };
     }
     return null;
   }
@@ -1882,13 +1966,7 @@ var PlanningCenterProvider = class extends ContentProvider {
     const songId = item.relationships?.song?.data?.id;
     const arrangementId = item.relationships?.arrangement?.data?.id;
     if (!songId) {
-      return {
-        id: item.id,
-        name: item.attributes.title || "Song",
-        actionType: "other",
-        files: [],
-        providerData: { itemType: "song" }
-      };
+      return { id: item.id, name: item.attributes.title || "Song", actionType: "other", files: [], providerData: { itemType: "song" } };
     }
     const songFn = this.config.endpoints.song;
     const songResponse = await this.apiRequest(songFn(songId), auth);
@@ -1910,25 +1988,7 @@ var PlanningCenterProvider = class extends ContentProvider {
     }
     const song = songResponse?.data;
     const title = song?.attributes?.title || item.attributes.title || "Song";
-    return {
-      id: item.id,
-      name: title,
-      actionType: "other",
-      files: [],
-      providerData: {
-        itemType: "song",
-        title,
-        author: song?.attributes?.author,
-        copyright: song?.attributes?.copyright,
-        ccliNumber: song?.attributes?.ccli_number,
-        arrangementName: arrangement?.attributes?.name,
-        keySignature: arrangement?.attributes?.chord_chart_key,
-        bpm: arrangement?.attributes?.bpm,
-        sequence: arrangement?.attributes?.sequence,
-        sections: sections.map((s) => ({ label: s.label, lyrics: s.lyrics })),
-        length: item.attributes.length
-      }
-    };
+    return { id: item.id, name: title, actionType: "other", files: [], providerData: { itemType: "song", title, author: song?.attributes?.author, copyright: song?.attributes?.copyright, ccliNumber: song?.attributes?.ccli_number, arrangementName: arrangement?.attributes?.name, keySignature: arrangement?.attributes?.chord_chart_key, bpm: arrangement?.attributes?.bpm, sequence: arrangement?.attributes?.sequence, sections: sections.map((s) => ({ label: s.label, lyrics: s.lyrics })), length: item.attributes.length } };
   }
   async convertMediaToPresentation(item, auth) {
     const files = [];
@@ -1948,25 +2008,10 @@ var PlanningCenterProvider = class extends ContentProvider {
         if (!url) continue;
         const contentType = attachment.attributes.content_type;
         const explicitType = contentType?.startsWith("video/") ? "video" : void 0;
-        files.push({
-          type: "file",
-          id: attachment.id,
-          title: attachment.attributes.filename,
-          mediaType: detectMediaType(url, explicitType),
-          url
-        });
+        files.push({ type: "file", id: attachment.id, title: attachment.attributes.filename, mediaType: detectMediaType(url, explicitType), url });
       }
     }
-    return {
-      id: item.id,
-      name: item.attributes.title || "Media",
-      actionType: "play",
-      files,
-      providerData: {
-        itemType: "media",
-        length: item.attributes.length
-      }
-    };
+    return { id: item.id, name: item.attributes.title || "Media", actionType: "play", files, providerData: { itemType: "media", length: item.attributes.length } };
   }
   formatDate(dateString) {
     const date = new Date(dateString);
@@ -1974,7 +2019,7 @@ var PlanningCenterProvider = class extends ContentProvider {
   }
 };
 
-// src/providers/bibleproject/data.json
+// src/providers/bibleProject/data.json
 var data_default = {
   collections: [
     {
@@ -4082,10 +4127,9 @@ var data_default = {
   ]
 };
 
-// src/providers/bibleproject/BibleProjectProvider.ts
-var BibleProjectProvider = class extends ContentProvider {
+// src/providers/bibleProject/BibleProjectProvider.ts
+var BibleProjectProvider = class {
   constructor() {
-    super(...arguments);
     this.id = "bibleproject";
     this.name = "The Bible Project";
     this.logos = {
@@ -4104,74 +4148,109 @@ var BibleProjectProvider = class extends ContentProvider {
       }
     };
     this.data = data_default;
-  }
-  requiresAuth() {
-    return false;
-  }
-  getCapabilities() {
-    return {
+    this.requiresAuth = false;
+    this.authTypes = ["none"];
+    this.capabilities = {
       browse: true,
-      presentations: false,
-      playlist: false,
+      presentations: true,
+      playlist: true,
       instructions: false,
       expandedInstructions: false,
       mediaLicensing: false
     };
   }
-  async browse(folder, _auth) {
-    if (!folder) {
-      return this.data.collections.filter((collection) => collection.videos.length > 0).map((collection) => this.createFolder(
-        this.slugify(collection.name),
-        collection.name,
-        collection.image || void 0,
-        { level: "collection", collectionName: collection.name }
-      ));
+  async browse(path, _auth) {
+    const { segments, depth } = parsePath(path);
+    if (depth === 0) {
+      return this.getCollections();
     }
-    const level = folder.providerData?.level;
-    const collectionName = folder.providerData?.collectionName;
-    if (level === "collection") {
-      return this.getLessonFolders(collectionName);
+    if (depth === 1) {
+      const collectionSlug = segments[0];
+      return this.getLessonFolders(collectionSlug, path);
     }
-    if (level === "lesson") {
-      const videoData = folder.providerData?.videoData;
-      if (videoData) {
-        return [this.createFile(
-          videoData.id,
-          videoData.title,
-          videoData.videoUrl,
-          {
-            mediaType: "video",
-            muxPlaybackId: videoData.muxPlaybackId
-          }
-        )];
-      }
-      return [];
+    if (depth === 2) {
+      const collectionSlug = segments[0];
+      const videoId = segments[1];
+      return this.getVideoFile(collectionSlug, videoId);
     }
     return [];
   }
-  async getPresentations(_folder, _auth) {
-    return null;
+  getCollections() {
+    return this.data.collections.filter((collection) => collection.videos.length > 0).map((collection) => ({
+      type: "folder",
+      id: this.slugify(collection.name),
+      title: collection.name,
+      image: collection.image || void 0,
+      path: `/${this.slugify(collection.name)}`
+    }));
   }
-  getLessonFolders(collectionName) {
-    const collection = this.data.collections.find((c) => c.name === collectionName);
+  getLessonFolders(collectionSlug, currentPath) {
+    const collection = this.data.collections.find((c) => this.slugify(c.name) === collectionSlug);
     if (!collection) return [];
-    return collection.videos.map((video) => this.createFolder(
-      video.id,
-      video.title,
-      video.thumbnailUrl,
-      {
-        level: "lesson",
-        collectionName,
-        videoData: video
-      }
-    ));
+    return collection.videos.map((video) => ({
+      type: "folder",
+      id: video.id,
+      title: video.title,
+      image: video.thumbnailUrl,
+      isLeaf: true,
+      path: `${currentPath}/${video.id}`,
+      providerData: { videoData: video }
+    }));
+  }
+  getVideoFile(collectionSlug, videoId) {
+    const collection = this.data.collections.find((c) => this.slugify(c.name) === collectionSlug);
+    if (!collection) return [];
+    const video = collection.videos.find((v) => v.id === videoId);
+    if (!video) return [];
+    return [createFile(video.id, video.title, video.videoUrl, { mediaType: "video", muxPlaybackId: video.muxPlaybackId })];
+  }
+  async getPresentations(path, _auth) {
+    const { segments, depth } = parsePath(path);
+    if (depth < 1) return null;
+    const collectionSlug = segments[0];
+    const collection = this.data.collections.find((c) => this.slugify(c.name) === collectionSlug);
+    if (!collection) return null;
+    if (depth === 1) {
+      const allFiles = [];
+      const presentations = collection.videos.map((video) => {
+        const file = { type: "file", id: video.id, title: video.title, mediaType: "video", url: video.videoUrl, image: video.thumbnailUrl, muxPlaybackId: video.muxPlaybackId };
+        allFiles.push(file);
+        return { id: video.id, name: video.title, actionType: "play", files: [file] };
+      });
+      return { id: this.slugify(collection.name), name: collection.name, image: collection.image || void 0, sections: [{ id: "videos", name: "Videos", presentations }], allFiles };
+    }
+    if (depth === 2) {
+      const videoId = segments[1];
+      const video = collection.videos.find((v) => v.id === videoId);
+      if (!video) return null;
+      const file = { type: "file", id: video.id, title: video.title, mediaType: "video", url: video.videoUrl, image: video.thumbnailUrl, muxPlaybackId: video.muxPlaybackId };
+      return { id: video.id, name: video.title, image: video.thumbnailUrl, sections: [{ id: "main", name: "Content", presentations: [{ id: video.id, name: video.title, actionType: "play", files: [file] }] }], allFiles: [file] };
+    }
+    return null;
+  }
+  async getPlaylist(path, _auth, _resolution) {
+    const { segments, depth } = parsePath(path);
+    if (depth < 1) return null;
+    const collectionSlug = segments[0];
+    const collection = this.data.collections.find((c) => this.slugify(c.name) === collectionSlug);
+    if (!collection) return null;
+    if (depth === 1) {
+      return collection.videos.map((video) => ({ type: "file", id: video.id, title: video.title, mediaType: "video", url: video.videoUrl, image: video.thumbnailUrl, muxPlaybackId: video.muxPlaybackId }));
+    }
+    if (depth === 2) {
+      const videoId = segments[1];
+      const video = collection.videos.find((v) => v.id === videoId);
+      if (!video) return null;
+      return [{ type: "file", id: video.id, title: video.title, mediaType: "video", url: video.videoUrl, image: video.thumbnailUrl, muxPlaybackId: video.muxPlaybackId }];
+    }
+    return null;
   }
   slugify(text) {
     return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
   }
 };
 
-// src/providers/highvoltage/data.json
+// src/providers/highVoltage/data.json
 var data_default2 = {
   collections: [
     {
@@ -11675,10 +11754,9 @@ var data_default2 = {
   ]
 };
 
-// src/providers/HighVoltageKidsProvider.ts
-var HighVoltageKidsProvider = class extends ContentProvider {
+// src/providers/highVoltage/HighVoltageKidsProvider.ts
+var HighVoltageKidsProvider = class {
   constructor() {
-    super(...arguments);
     this.id = "highvoltagekids";
     this.name = "High Voltage Kids";
     this.logos = {
@@ -11697,87 +11775,211 @@ var HighVoltageKidsProvider = class extends ContentProvider {
       }
     };
     this.data = data_default2;
-  }
-  requiresAuth() {
-    return false;
-  }
-  getCapabilities() {
-    return {
+    this.requiresAuth = false;
+    this.authTypes = ["none"];
+    this.capabilities = {
       browse: true,
-      presentations: false,
-      playlist: false,
+      presentations: true,
+      playlist: true,
       instructions: false,
-      expandedInstructions: false,
+      expandedInstructions: true,
       mediaLicensing: false
     };
   }
-  async browse(folder, _auth) {
-    if (!folder) {
-      return this.data.collections.filter((collection) => collection.folders.length > 0).map((collection) => this.createFolder(
-        this.slugify(collection.name),
-        collection.name,
-        void 0,
-        { level: "collection", collectionName: collection.name }
-      ));
+  async browse(path, _auth) {
+    const { segments, depth } = parsePath(path);
+    if (depth === 0) {
+      return this.getCollections();
     }
-    const level = folder.providerData?.level;
-    const collectionName = folder.providerData?.collectionName;
-    if (level === "collection") {
-      return this.getStudyFolders(collectionName);
+    if (depth === 1) {
+      const collectionSlug = segments[0];
+      return this.getStudyFolders(collectionSlug, path);
     }
-    if (level === "study") {
-      const studyData = folder.providerData?.studyData;
-      if (studyData) {
-        return this.getLessonFolders(studyData);
-      }
-      return [];
+    if (depth === 2) {
+      const collectionSlug = segments[0];
+      const studyId = segments[1];
+      return this.getLessonFolders(collectionSlug, studyId, path);
     }
-    if (level === "lesson") {
-      const lessonData = folder.providerData?.lessonData;
-      if (lessonData?.files) {
-        return lessonData.files.map((file) => this.createFile(
-          file.id,
-          file.title,
-          file.url,
-          { mediaType: file.mediaType }
-        ));
-      }
-      return [];
+    if (depth === 3) {
+      const collectionSlug = segments[0];
+      const studyId = segments[1];
+      const lessonId = segments[2];
+      return this.getLessonFiles(collectionSlug, studyId, lessonId);
     }
     return [];
   }
-  async getPresentations(_folder, _auth) {
-    return null;
+  getCollections() {
+    return this.data.collections.filter((collection) => collection.folders.length > 0).map((collection) => ({
+      type: "folder",
+      id: this.slugify(collection.name),
+      title: collection.name,
+      path: `/${this.slugify(collection.name)}`
+    }));
   }
-  getStudyFolders(collectionName) {
-    const collection = this.data.collections.find((c) => c.name === collectionName);
+  getStudyFolders(collectionSlug, currentPath) {
+    const collection = this.data.collections.find((c) => this.slugify(c.name) === collectionSlug);
     if (!collection) return [];
-    return collection.folders.map((study) => this.createFolder(
-      study.id,
-      study.name,
-      study.image || void 0,
-      {
-        level: "study",
-        collectionName,
-        studyData: study
-      }
-    ));
-  }
-  getLessonFolders(study) {
-    return study.lessons.map((lesson) => this.createFolder(
-      lesson.id,
-      lesson.name,
-      lesson.image || void 0,
-      {
-        level: "lesson",
-        studyId: study.id,
-        lessonData: lesson
+    return collection.folders.map((study) => ({
+      type: "folder",
+      id: study.id,
+      title: study.name,
+      image: study.image || void 0,
+      path: `${currentPath}/${study.id}`,
+      providerData: { studyData: study }
+    }));
+  }
+  getLessonFolders(collectionSlug, studyId, currentPath) {
+    const collection = this.data.collections.find((c) => this.slugify(c.name) === collectionSlug);
+    if (!collection) return [];
+    const study = collection.folders.find((s) => s.id === studyId);
+    if (!study) return [];
+    return study.lessons.map((lesson) => ({
+      type: "folder",
+      id: lesson.id,
+      title: lesson.name,
+      image: lesson.image || void 0,
+      isLeaf: true,
+      path: `${currentPath}/${lesson.id}`,
+      providerData: { lessonData: lesson, studyName: study.name }
+    }));
+  }
+  getLessonFiles(collectionSlug, studyId, lessonId) {
+    const collection = this.data.collections.find((c) => this.slugify(c.name) === collectionSlug);
+    if (!collection) return [];
+    const study = collection.folders.find((s) => s.id === studyId);
+    if (!study) return [];
+    const lesson = study.lessons.find((l) => l.id === lessonId);
+    if (!lesson?.files) return [];
+    return lesson.files.map((file) => createFile(file.id, file.title, file.url, { mediaType: file.mediaType }));
+  }
+  async getPresentations(path, _auth) {
+    const { segments, depth } = parsePath(path);
+    if (depth < 2) return null;
+    const collectionSlug = segments[0];
+    const studyId = segments[1];
+    const collection = this.data.collections.find((c) => this.slugify(c.name) === collectionSlug);
+    if (!collection) return null;
+    const study = collection.folders.find((s) => s.id === studyId);
+    if (!study) return null;
+    if (depth === 2) {
+      const allFiles = [];
+      const sections = study.lessons.map((lesson) => {
+        const files = lesson.files.map((file) => {
+          const contentFile = { type: "file", id: file.id, title: file.title, mediaType: file.mediaType, url: file.url, image: lesson.image };
+          allFiles.push(contentFile);
+          return contentFile;
+        });
+        const presentation = { id: lesson.id, name: lesson.name, actionType: "play", files };
+        return { id: lesson.id, name: lesson.name, presentations: [presentation] };
+      });
+      return { id: study.id, name: study.name, description: study.description, image: study.image, sections, allFiles };
+    }
+    if (depth === 3) {
+      const lessonId = segments[2];
+      const lesson = study.lessons.find((l) => l.id === lessonId);
+      if (!lesson?.files) return null;
+      const files = lesson.files.map((file) => ({ type: "file", id: file.id, title: file.title, mediaType: file.mediaType, url: file.url, image: lesson.image }));
+      const presentation = { id: lesson.id, name: lesson.name, actionType: "play", files };
+      return { id: lesson.id, name: lesson.name, image: lesson.image, sections: [{ id: "main", name: "Content", presentations: [presentation] }], allFiles: files };
+    }
+    return null;
+  }
+  async getPlaylist(path, _auth, _resolution) {
+    const { segments, depth } = parsePath(path);
+    if (depth < 2) return null;
+    const collectionSlug = segments[0];
+    const studyId = segments[1];
+    const collection = this.data.collections.find((c) => this.slugify(c.name) === collectionSlug);
+    if (!collection) return null;
+    const study = collection.folders.find((s) => s.id === studyId);
+    if (!study) return null;
+    if (depth === 2) {
+      const allFiles = [];
+      for (const lesson of study.lessons) {
+        for (const file of lesson.files) {
+          allFiles.push({ type: "file", id: file.id, title: file.title, mediaType: file.mediaType, url: file.url, image: lesson.image });
+        }
       }
-    ));
+      return allFiles;
+    }
+    if (depth === 3) {
+      const lessonId = segments[2];
+      const lesson = study.lessons.find((l) => l.id === lessonId);
+      if (!lesson?.files) return null;
+      return lesson.files.map((file) => ({ type: "file", id: file.id, title: file.title, mediaType: file.mediaType, url: file.url, image: lesson.image }));
+    }
+    return null;
+  }
+  async getExpandedInstructions(path, _auth) {
+    const { segments, depth } = parsePath(path);
+    if (depth < 2) return null;
+    const collectionSlug = segments[0];
+    const studyId = segments[1];
+    const collection = this.data.collections.find((c) => this.slugify(c.name) === collectionSlug);
+    if (!collection) return null;
+    const study = collection.folders.find((s) => s.id === studyId);
+    if (!study) return null;
+    if (depth === 2) {
+      const lessonItems = study.lessons.map((lesson) => {
+        const fileItems = lesson.files.map((file) => ({ id: file.id, itemType: "file", label: file.title, embedUrl: file.url }));
+        return { id: lesson.id, itemType: "action", label: lesson.name, description: "play", children: fileItems };
+      });
+      return { venueName: study.name, items: [{ id: study.id, itemType: "header", label: study.name, children: [{ id: "main", itemType: "section", label: "Content", children: lessonItems }] }] };
+    }
+    if (depth === 3) {
+      const lessonId = segments[2];
+      const lesson = study.lessons.find((l) => l.id === lessonId);
+      if (!lesson?.files) return null;
+      const headerLabel = `${study.name} - ${lesson.name}`;
+      const actionItems = this.groupFilesIntoActions(lesson.files);
+      return { venueName: lesson.name, items: [{ id: lesson.id, itemType: "header", label: headerLabel, children: [{ id: "main", itemType: "section", label: lesson.name, children: actionItems }] }] };
+    }
+    return null;
   }
   slugify(text) {
     return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
   }
+  groupFilesIntoActions(files) {
+    const actionItems = [];
+    let currentGroup = [];
+    let currentBaseName = null;
+    const flushGroup = () => {
+      if (currentGroup.length === 0) return;
+      const children = currentGroup.map((file) => ({
+        id: file.id,
+        itemType: "file",
+        label: file.title,
+        embedUrl: file.url
+      }));
+      const label = currentGroup.length > 1 && currentBaseName ? currentBaseName : currentGroup[0].title;
+      actionItems.push({
+        id: currentGroup[0].id + "-action",
+        itemType: "action",
+        label,
+        description: "play",
+        children
+      });
+      currentGroup = [];
+      currentBaseName = null;
+    };
+    for (const file of files) {
+      const baseName = this.getBaseName(file.title);
+      const isNumbered = baseName !== file.title;
+      if (isNumbered && baseName === currentBaseName) {
+        currentGroup.push(file);
+      } else {
+        flushGroup();
+        currentGroup = [file];
+        currentBaseName = isNumbered ? baseName : null;
+      }
+    }
+    flushGroup();
+    return actionItems;
+  }
+  getBaseName(title) {
+    const match = title.match(/^(.+?)\s*\d+$/);
+    return match ? match[1].trim() : title;
+  }
 };
 
 // src/providers/index.ts
@@ -11862,15 +12064,15 @@ function getProviderConfig(providerId) {
   const provider = getProvider(providerId);
   return provider?.config || null;
 }
-function getAvailableProviders() {
+function getAvailableProviders(ids) {
   const implemented = getAllProviders().map((provider) => ({
     id: provider.id,
     name: provider.name,
     logos: provider.logos,
     implemented: true,
-    requiresAuth: provider.requiresAuth(),
-    authTypes: provider.getAuthTypes(),
-    capabilities: provider.getCapabilities()
+    requiresAuth: provider.requiresAuth,
+    authTypes: provider.authTypes,
+    capabilities: provider.capabilities
   }));
   const comingSoon = unimplementedProviders.map((p) => ({
     id: p.id,
@@ -11881,7 +12083,12 @@ function getAvailableProviders() {
     authTypes: [],
     capabilities: { browse: false, presentations: false, playlist: false, instructions: false, expandedInstructions: false, mediaLicensing: false }
   }));
-  return [...implemented, ...comingSoon];
+  const all = [...implemented, ...comingSoon];
+  if (ids && ids.length > 0) {
+    const idSet = new Set(ids);
+    return all.filter((provider) => idSet.has(provider.id));
+  }
+  return all;
 }
 
 // src/index.ts
@@ -11889,20 +12096,44 @@ var VERSION = "0.0.1";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   APlayProvider,
+  ApiHelper,
   B1ChurchProvider,
   BibleProjectProvider,
   ContentProvider,
+  DeviceFlowHelper,
+  FormatConverters,
+  FormatResolver,
+  HighVoltageKidsProvider,
   LessonsChurchProvider,
+  OAuthHelper,
   PlanningCenterProvider,
   SignPresenterProvider,
+  TokenHelper,
   VERSION,
+  appendToPath,
+  buildPath,
+  collapseInstructions,
+  createFile,
+  createFolder,
   detectMediaType,
+  expandedInstructionsToPlaylist,
+  expandedInstructionsToPresentations,
   getAllProviders,
   getAvailableProviders,
   getProvider,
   getProviderConfig,
+  getSegment,
+  instructionsToPlaylist,
+  instructionsToPresentations,
   isContentFile,
   isContentFolder,
+  parsePath,
+  playlistToExpandedInstructions,
+  playlistToInstructions,
+  playlistToPresentations,
+  presentationsToExpandedInstructions,
+  presentationsToInstructions,
+  presentationsToPlaylist,
   registerProvider
 });
 //# sourceMappingURL=index.cjs.map