@iflow-mcp/kdcokenny-lsbible 0.3.0

package/dist/mcp/stdio.js

@@ -0,0 +1,2707 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { parseHTML } from 'linkedom';
+
+function registerPrompts(server) {
+  server.registerPrompt(
+    "bible_study",
+    {
+      title: "Bible Study Guide",
+      description: "Generate a comprehensive Bible study guide for a passage",
+      argsSchema: {
+        passage: z.string().describe('Bible passage reference (e.g., "John 3:16-21")'),
+        focusAreas: z.string().optional().describe(
+          'Optional comma-separated areas to focus on (e.g., "context, application, cross-references")'
+        )
+      }
+    },
+    (args) => {
+      const { passage, focusAreas } = args;
+      const focusText = focusAreas ? `
+
+Focus areas: ${focusAreas}` : "";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Create a comprehensive Bible study guide for ${passage}.
+
+Include:
+1. Historical and cultural context
+2. Key themes and theological insights
+3. Practical applications for modern readers
+4. Discussion questions
+5. Cross-references to related passages${focusText}`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server.registerPrompt(
+    "cross_reference",
+    {
+      title: "Find Cross References",
+      description: "Find verses related to a specific verse",
+      argsSchema: {
+        verse: z.string().describe('Bible verse reference (e.g., "Romans 8:28")'),
+        maxResults: z.string().optional().describe("Maximum number of results (default: 10)")
+      }
+    },
+    (args) => {
+      const { verse, maxResults: maxResultsStr } = args;
+      const maxResults = maxResultsStr ? Number.parseInt(maxResultsStr, 10) : 10;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Find up to ${maxResults} Bible verses that are thematically related to ${verse}.
+
+For each related verse:
+1. Explain the thematic connection
+2. Note any parallel language or concepts
+3. Highlight complementary or contrasting perspectives`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/books.ts
+var BIBLE_STRUCTURE = {
+  1: {
+    number: 1,
+    name: "Genesis",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 50,
+    verses: [
+      31,
+      25,
+      24,
+      26,
+      32,
+      22,
+      24,
+      22,
+      29,
+      32,
+      32,
+      20,
+      18,
+      24,
+      21,
+      16,
+      27,
+      33,
+      38,
+      18,
+      34,
+      24,
+      20,
+      67,
+      34,
+      35,
+      46,
+      22,
+      35,
+      43,
+      55,
+      32,
+      20,
+      31,
+      29,
+      43,
+      36,
+      30,
+      23,
+      23,
+      57,
+      38,
+      34,
+      34,
+      28,
+      34,
+      31,
+      22,
+      33,
+      26
+    ]
+  },
+  2: {
+    number: 2,
+    name: "Exodus",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 40,
+    verses: [
+      22,
+      25,
+      22,
+      31,
+      23,
+      30,
+      25,
+      32,
+      35,
+      29,
+      10,
+      51,
+      22,
+      31,
+      27,
+      36,
+      16,
+      27,
+      25,
+      26,
+      36,
+      31,
+      33,
+      18,
+      40,
+      37,
+      21,
+      43,
+      46,
+      38,
+      18,
+      35,
+      23,
+      35,
+      35,
+      38,
+      29,
+      31,
+      43,
+      38
+    ]
+  },
+  3: {
+    number: 3,
+    name: "Leviticus",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 27,
+    verses: [
+      17,
+      16,
+      17,
+      35,
+      19,
+      30,
+      38,
+      36,
+      24,
+      20,
+      47,
+      8,
+      59,
+      57,
+      33,
+      34,
+      16,
+      30,
+      37,
+      27,
+      24,
+      33,
+      44,
+      23,
+      55,
+      46,
+      34
+    ]
+  },
+  4: {
+    number: 4,
+    name: "Numbers",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 36,
+    verses: [
+      54,
+      34,
+      51,
+      49,
+      31,
+      27,
+      89,
+      26,
+      23,
+      36,
+      35,
+      16,
+      33,
+      45,
+      41,
+      50,
+      13,
+      32,
+      22,
+      29,
+      35,
+      41,
+      30,
+      25,
+      18,
+      65,
+      23,
+      31,
+      40,
+      16,
+      54,
+      42,
+      56,
+      29,
+      34,
+      13
+    ]
+  },
+  5: {
+    number: 5,
+    name: "Deuteronomy",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 34,
+    verses: [
+      46,
+      37,
+      29,
+      49,
+      33,
+      25,
+      26,
+      20,
+      29,
+      22,
+      32,
+      32,
+      18,
+      29,
+      23,
+      22,
+      20,
+      22,
+      21,
+      20,
+      23,
+      30,
+      25,
+      22,
+      19,
+      19,
+      26,
+      68,
+      29,
+      20,
+      30,
+      52,
+      29,
+      12
+    ]
+  },
+  6: {
+    number: 6,
+    name: "Joshua",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 24,
+    verses: [
+      18,
+      24,
+      17,
+      24,
+      15,
+      27,
+      26,
+      35,
+      27,
+      43,
+      23,
+      24,
+      33,
+      15,
+      63,
+      10,
+      18,
+      28,
+      51,
+      9,
+      45,
+      34,
+      16,
+      33
+    ]
+  },
+  7: {
+    number: 7,
+    name: "Judges",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 21,
+    verses: [36, 23, 31, 24, 31, 40, 25, 35, 57, 18, 40, 15, 25, 20, 20, 31, 13, 31, 30, 48, 25]
+  },
+  8: {
+    number: 8,
+    name: "Ruth",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 4,
+    verses: [22, 23, 18, 22]
+  },
+  9: {
+    number: 9,
+    name: "1 Samuel",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 31,
+    verses: [
+      28,
+      36,
+      21,
+      22,
+      12,
+      21,
+      17,
+      22,
+      27,
+      27,
+      15,
+      25,
+      23,
+      52,
+      35,
+      23,
+      58,
+      30,
+      24,
+      42,
+      15,
+      23,
+      29,
+      22,
+      44,
+      25,
+      12,
+      25,
+      11,
+      31,
+      13
+    ]
+  },
+  10: {
+    number: 10,
+    name: "2 Samuel",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 24,
+    verses: [
+      27,
+      32,
+      39,
+      12,
+      25,
+      23,
+      29,
+      18,
+      13,
+      19,
+      27,
+      31,
+      39,
+      33,
+      37,
+      23,
+      29,
+      33,
+      43,
+      26,
+      22,
+      51,
+      39,
+      25
+    ]
+  },
+  11: {
+    number: 11,
+    name: "1 Kings",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 22,
+    verses: [
+      53,
+      46,
+      28,
+      34,
+      18,
+      38,
+      51,
+      66,
+      28,
+      29,
+      43,
+      33,
+      34,
+      31,
+      34,
+      34,
+      24,
+      46,
+      21,
+      43,
+      29,
+      53
+    ]
+  },
+  12: {
+    number: 12,
+    name: "2 Kings",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 25,
+    verses: [
+      18,
+      25,
+      27,
+      44,
+      27,
+      33,
+      20,
+      29,
+      37,
+      36,
+      21,
+      21,
+      25,
+      29,
+      38,
+      20,
+      41,
+      37,
+      37,
+      21,
+      26,
+      20,
+      37,
+      20,
+      30
+    ]
+  },
+  13: {
+    number: 13,
+    name: "1 Chronicles",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 29,
+    verses: [
+      54,
+      55,
+      24,
+      43,
+      26,
+      81,
+      40,
+      40,
+      44,
+      14,
+      47,
+      40,
+      14,
+      17,
+      29,
+      43,
+      27,
+      17,
+      19,
+      8,
+      30,
+      19,
+      32,
+      31,
+      31,
+      32,
+      34,
+      21,
+      30
+    ]
+  },
+  14: {
+    number: 14,
+    name: "2 Chronicles",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 36,
+    verses: [
+      17,
+      18,
+      17,
+      22,
+      14,
+      42,
+      22,
+      18,
+      31,
+      19,
+      23,
+      16,
+      22,
+      15,
+      19,
+      14,
+      19,
+      34,
+      11,
+      37,
+      20,
+      12,
+      21,
+      27,
+      28,
+      23,
+      9,
+      27,
+      36,
+      27,
+      21,
+      33,
+      25,
+      33,
+      27,
+      23
+    ]
+  },
+  15: {
+    number: 15,
+    name: "Ezra",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 10,
+    verses: [11, 70, 13, 24, 17, 22, 28, 36, 15, 44]
+  },
+  16: {
+    number: 16,
+    name: "Nehemiah",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 13,
+    verses: [11, 20, 32, 23, 19, 19, 73, 18, 38, 39, 36, 47, 31]
+  },
+  17: {
+    number: 17,
+    name: "Esther",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 10,
+    verses: [22, 23, 15, 17, 14, 14, 10, 17, 32, 3]
+  },
+  18: {
+    number: 18,
+    name: "Job",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 42,
+    verses: [
+      22,
+      13,
+      26,
+      21,
+      27,
+      30,
+      21,
+      22,
+      35,
+      22,
+      20,
+      25,
+      28,
+      22,
+      35,
+      22,
+      16,
+      21,
+      29,
+      29,
+      34,
+      30,
+      17,
+      25,
+      6,
+      14,
+      23,
+      28,
+      25,
+      31,
+      40,
+      22,
+      33,
+      37,
+      16,
+      33,
+      24,
+      41,
+      30,
+      24,
+      34,
+      17
+    ]
+  },
+  19: {
+    number: 19,
+    name: "Psalms",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 150,
+    verses: [
+      6,
+      12,
+      8,
+      8,
+      12,
+      10,
+      17,
+      9,
+      20,
+      18,
+      7,
+      8,
+      6,
+      7,
+      5,
+      11,
+      15,
+      50,
+      14,
+      9,
+      13,
+      31,
+      6,
+      10,
+      22,
+      12,
+      14,
+      9,
+      11,
+      12,
+      24,
+      11,
+      22,
+      22,
+      28,
+      12,
+      40,
+      22,
+      13,
+      17,
+      13,
+      11,
+      5,
+      26,
+      17,
+      11,
+      9,
+      14,
+      20,
+      23,
+      19,
+      9,
+      6,
+      7,
+      23,
+      13,
+      11,
+      11,
+      17,
+      12,
+      8,
+      12,
+      11,
+      10,
+      13,
+      20,
+      7,
+      35,
+      36,
+      5,
+      24,
+      20,
+      28,
+      23,
+      10,
+      12,
+      20,
+      72,
+      13,
+      19,
+      16,
+      8,
+      18,
+      12,
+      13,
+      17,
+      7,
+      18,
+      52,
+      17,
+      16,
+      15,
+      5,
+      23,
+      11,
+      13,
+      12,
+      9,
+      9,
+      5,
+      8,
+      28,
+      22,
+      35,
+      45,
+      48,
+      43,
+      13,
+      31,
+      7,
+      10,
+      10,
+      9,
+      8,
+      18,
+      19,
+      2,
+      29,
+      176,
+      7,
+      8,
+      9,
+      4,
+      8,
+      5,
+      6,
+      5,
+      6,
+      8,
+      8,
+      3,
+      18,
+      3,
+      3,
+      21,
+      26,
+      9,
+      8,
+      24,
+      13,
+      10,
+      7,
+      12,
+      15,
+      21,
+      10,
+      20,
+      14,
+      9,
+      6
+    ]
+  },
+  20: {
+    number: 20,
+    name: "Proverbs",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 31,
+    verses: [
+      33,
+      22,
+      35,
+      27,
+      23,
+      35,
+      27,
+      36,
+      18,
+      32,
+      31,
+      28,
+      25,
+      35,
+      33,
+      33,
+      28,
+      24,
+      29,
+      30,
+      31,
+      29,
+      35,
+      34,
+      28,
+      28,
+      27,
+      28,
+      27,
+      33,
+      31
+    ]
+  },
+  21: {
+    number: 21,
+    name: "Ecclesiastes",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 12,
+    verses: [18, 26, 22, 16, 20, 12, 29, 17, 18, 20, 10, 14]
+  },
+  22: {
+    number: 22,
+    name: "Song of Songs",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 8,
+    verses: [17, 17, 11, 16, 16, 13, 13, 14]
+  },
+  23: {
+    number: 23,
+    name: "Isaiah",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 66,
+    verses: [
+      31,
+      22,
+      26,
+      6,
+      30,
+      13,
+      25,
+      22,
+      21,
+      34,
+      16,
+      6,
+      22,
+      32,
+      9,
+      14,
+      14,
+      7,
+      25,
+      6,
+      17,
+      25,
+      18,
+      23,
+      12,
+      21,
+      13,
+      29,
+      24,
+      33,
+      9,
+      20,
+      24,
+      17,
+      10,
+      22,
+      38,
+      22,
+      8,
+      31,
+      29,
+      25,
+      28,
+      28,
+      25,
+      13,
+      15,
+      22,
+      26,
+      11,
+      23,
+      15,
+      12,
+      17,
+      13,
+      12,
+      21,
+      14,
+      21,
+      22,
+      11,
+      12,
+      19,
+      12,
+      25,
+      24
+    ]
+  },
+  24: {
+    number: 24,
+    name: "Jeremiah",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 52,
+    verses: [
+      19,
+      37,
+      25,
+      31,
+      31,
+      30,
+      34,
+      22,
+      26,
+      25,
+      23,
+      17,
+      27,
+      22,
+      21,
+      21,
+      27,
+      23,
+      15,
+      18,
+      14,
+      30,
+      40,
+      10,
+      38,
+      24,
+      22,
+      17,
+      32,
+      24,
+      40,
+      44,
+      26,
+      22,
+      19,
+      32,
+      21,
+      28,
+      18,
+      16,
+      18,
+      22,
+      13,
+      30,
+      5,
+      28,
+      7,
+      47,
+      39,
+      46,
+      64,
+      34
+    ]
+  },
+  25: {
+    number: 25,
+    name: "Lamentations",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 5,
+    verses: [22, 22, 66, 22, 22]
+  },
+  26: {
+    number: 26,
+    name: "Ezekiel",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 48,
+    verses: [
+      28,
+      10,
+      27,
+      17,
+      17,
+      14,
+      27,
+      18,
+      11,
+      22,
+      25,
+      28,
+      23,
+      23,
+      8,
+      63,
+      24,
+      32,
+      14,
+      49,
+      32,
+      31,
+      49,
+      27,
+      17,
+      21,
+      36,
+      26,
+      21,
+      26,
+      18,
+      32,
+      33,
+      31,
+      15,
+      38,
+      28,
+      23,
+      29,
+      49,
+      26,
+      20,
+      27,
+      31,
+      25,
+      24,
+      23,
+      35
+    ]
+  },
+  27: {
+    number: 27,
+    name: "Daniel",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 12,
+    verses: [21, 49, 30, 37, 31, 28, 28, 27, 27, 21, 45, 13]
+  },
+  28: {
+    number: 28,
+    name: "Hosea",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 14,
+    verses: [11, 23, 5, 19, 15, 11, 16, 14, 17, 15, 12, 14, 16, 9]
+  },
+  29: {
+    number: 29,
+    name: "Joel",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 3,
+    verses: [20, 32, 21]
+  },
+  30: {
+    number: 30,
+    name: "Amos",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 9,
+    verses: [15, 16, 15, 13, 27, 14, 17, 14, 15]
+  },
+  31: {
+    number: 31,
+    name: "Obadiah",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 1,
+    verses: [21]
+  },
+  32: {
+    number: 32,
+    name: "Jonah",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 4,
+    verses: [17, 10, 10, 11]
+  },
+  33: {
+    number: 33,
+    name: "Micah",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 7,
+    verses: [16, 13, 12, 13, 15, 16, 20]
+  },
+  34: {
+    number: 34,
+    name: "Nahum",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 3,
+    verses: [15, 13, 19]
+  },
+  35: {
+    number: 35,
+    name: "Habakkuk",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 3,
+    verses: [17, 20, 19]
+  },
+  36: {
+    number: 36,
+    name: "Zephaniah",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 3,
+    verses: [18, 15, 20]
+  },
+  37: {
+    number: 37,
+    name: "Haggai",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 2,
+    verses: [15, 23]
+  },
+  38: {
+    number: 38,
+    name: "Zechariah",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 14,
+    verses: [21, 13, 10, 14, 11, 15, 14, 23, 17, 12, 17, 14, 9, 21]
+  },
+  39: {
+    number: 39,
+    name: "Malachi",
+    testament: "OT" /* OLD_TESTAMENT */,
+    chapters: 4,
+    verses: [14, 17, 18, 6]
+  },
+  40: {
+    number: 40,
+    name: "Matthew",
+    testament: "NT" /* NEW_TESTAMENT */,
+    chapters: 28,
+    verses: [
+      25,
+      23,
+      17,
+      25,
+      48,
+      34,
+      29,
+      34,
+      38,
+      42,
+      30,
+      50,
+      58,
+      36,
+      39,
+      28,
+      27,
+      35,
+      30,
+      34,
+      46,
+      46,
+      39,
+      51,
+      46,
+      75,
+      66,
+      20
+    ]
+  },
+  41: {
+    number: 41,
+    name: "Mark",
+    testament: "NT" /* NEW_TESTAMENT */,
+    chapters: 16,
+    verses: [45, 28, 35, 41, 43, 56, 37, 38, 50, 52, 33, 44, 37, 72, 47, 20]
+  },
+  42: {
+    number: 42,
+    name: "Luke",
+    testament: "NT" /* NEW_TESTAMENT */,
+    chapters: 24,
+    verses: [
+      80,
+      52,
+      38,
+      44,
+      39,
+      49,
+      50,
+      56,
+      62,
+      42,
+      54,
+      59,
+      35,
+      35,
+      32,
+      31,
+      37,
+      43,
+      48,
+      47,
+      38,
+      71,
+      56,
+      53
+    ]
+  },
+  43: {
+    number: 43,
+    name: "John",
+    testament: "NT" /* NEW_TESTAMENT */,
+    chapters: 21,
+    verses: [51, 25, 36, 54, 47, 71, 53, 59, 41, 42, 57, 50, 38, 31, 27, 33, 26, 40, 42, 31, 25]
+  },
+  44: {
+    number: 44,
+    name: "Acts",
+    testament: "NT" /* NEW_TESTAMENT */,
+    chapters: 28,
+    verses: [
+      26,
+      47,
+      26,
+      37,
+      42,
+      15,
+      60,
+      40,
+      43,
+      48,
+      30,
+      25,
+      52,
+      28,
+      41,
+      40,
+      34,
+      28,
+      41,
+      38,
+      40,
+      30,
+      35,
+      27,
+      27,
+      32,
+      44,
+      31
+    ]
+  },
+  45: {
+    number: 45,
+    name: "Romans",
+    testament: "NT" /* NEW_TESTAMENT */,
+    chapters: 16,
+    verses: [32, 29, 31, 25, 21, 23, 25, 39, 33, 21, 36, 21, 14, 23, 33, 27]
+  },
+  46: {
+    number: 46,
+    name: "1 Corinthians",
+    testament: "NT" /* NEW_TESTAMENT */,
+    chapters: 16,
+    verses: [31, 16, 23, 21, 13, 20, 40, 13, 27, 33, 34, 31, 13, 40, 58, 24]
+  },
+  47: {
+    number: 47,
+    name: "2 Corinthians",
+    testament: "NT" /* NEW_TESTAMENT */,
+    chapters: 13,
+    verses: [24, 17, 18, 18, 21, 18, 16, 24, 15, 18, 33, 21, 14]
+  },
+  48: {
+    number: 48,
+    name: "Galatians",
+    testament: "NT" /* NEW_TESTAMENT */,
+    chapters: 6,
+    verses: [24, 21, 29, 31, 26, 18]
+  },
+  49: {
+    number: 49,
+    name: "Ephesians",
+    testament: "NT" /* NEW_TESTAMENT */,
+    chapters: 6,
+    verses: [23, 22, 21, 32, 33, 24]
+  },
+  50: {
+    number: 50,
+    name: "Philippians",
+    testament: "NT" /* NEW_TESTAMENT */,
+    chapters: 4,
+    verses: [30, 30, 21, 23]
+  },
+  51: {
+    number: 51,
+    name: "Colossians",
+    testament: "NT" /* NEW_TESTAMENT */,
+    chapters: 4,
+    verses: [29, 23, 25, 18]
+  },
+  52: {
+    number: 52,
+    name: "1 Thessalonians",
+    testament: "NT" /* NEW_TESTAMENT */,
+    chapters: 5,
+    verses: [10, 20, 13, 18, 28]
+  },
+  53: {
+    number: 53,
+    name: "2 Thessalonians",
+    testament: "NT" /* NEW_TESTAMENT */,
+    chapters: 3,
+    verses: [12, 17, 18]
+  },
+  54: {
+    number: 54,
+    name: "1 Timothy",
+    testament: "NT" /* NEW_TESTAMENT */,
+    chapters: 6,
+    verses: [20, 15, 16, 16, 25, 21]
+  },
+  55: {
+    number: 55,
+    name: "2 Timothy",
+    testament: "NT" /* NEW_TESTAMENT */,
+    chapters: 4,
+    verses: [18, 26, 17, 22]
+  },
+  56: {
+    number: 56,
+    name: "Titus",
+    testament: "NT" /* NEW_TESTAMENT */,
+    chapters: 3,
+    verses: [16, 15, 15]
+  },
+  57: {
+    number: 57,
+    name: "Philemon",
+    testament: "NT" /* NEW_TESTAMENT */,
+    chapters: 1,
+    verses: [25]
+  },
+  58: {
+    number: 58,
+    name: "Hebrews",
+    testament: "NT" /* NEW_TESTAMENT */,
+    chapters: 13,
+    verses: [14, 18, 19, 16, 14, 20, 28, 13, 28, 39, 40, 29, 25]
+  },
+  59: {
+    number: 59,
+    name: "James",
+    testament: "NT" /* NEW_TESTAMENT */,
+    chapters: 5,
+    verses: [27, 26, 18, 17, 20]
+  },
+  60: {
+    number: 60,
+    name: "1 Peter",
+    testament: "NT" /* NEW_TESTAMENT */,
+    chapters: 5,
+    verses: [25, 25, 22, 19, 14]
+  },
+  61: {
+    number: 61,
+    name: "2 Peter",
+    testament: "NT" /* NEW_TESTAMENT */,
+    chapters: 3,
+    verses: [21, 22, 18]
+  },
+  62: {
+    number: 62,
+    name: "1 John",
+    testament: "NT" /* NEW_TESTAMENT */,
+    chapters: 5,
+    verses: [10, 29, 24, 21, 21]
+  },
+  63: {
+    number: 63,
+    name: "2 John",
+    testament: "NT" /* NEW_TESTAMENT */,
+    chapters: 1,
+    verses: [13]
+  },
+  64: {
+    number: 64,
+    name: "3 John",
+    testament: "NT" /* NEW_TESTAMENT */,
+    chapters: 1,
+    verses: [14]
+  },
+  65: {
+    number: 65,
+    name: "Jude",
+    testament: "NT" /* NEW_TESTAMENT */,
+    chapters: 1,
+    verses: [25]
+  },
+  66: {
+    number: 66,
+    name: "Revelation",
+    testament: "NT" /* NEW_TESTAMENT */,
+    chapters: 22,
+    verses: [20, 29, 22, 11, 14, 17, 17, 13, 21, 11, 19, 17, 18, 20, 8, 21, 18, 24, 21, 15, 27, 21]
+  }
+};
+var BOOK_NAMES = Object.fromEntries(
+  Object.values(BIBLE_STRUCTURE).map((book) => [book.number, book.name])
+);
+var BOOK_NUMBERS = Object.fromEntries(
+  Object.values(BIBLE_STRUCTURE).map((book) => [book.name.toLowerCase(), book.number])
+);
+var BookName = /* @__PURE__ */ ((BookName2) => {
+  BookName2["GENESIS"] = "Genesis";
+  BookName2["EXODUS"] = "Exodus";
+  BookName2["LEVITICUS"] = "Leviticus";
+  BookName2["NUMBERS"] = "Numbers";
+  BookName2["DEUTERONOMY"] = "Deuteronomy";
+  BookName2["JOSHUA"] = "Joshua";
+  BookName2["JUDGES"] = "Judges";
+  BookName2["RUTH"] = "Ruth";
+  BookName2["SAMUEL_1"] = "1 Samuel";
+  BookName2["SAMUEL_2"] = "2 Samuel";
+  BookName2["KINGS_1"] = "1 Kings";
+  BookName2["KINGS_2"] = "2 Kings";
+  BookName2["CHRONICLES_1"] = "1 Chronicles";
+  BookName2["CHRONICLES_2"] = "2 Chronicles";
+  BookName2["EZRA"] = "Ezra";
+  BookName2["NEHEMIAH"] = "Nehemiah";
+  BookName2["ESTHER"] = "Esther";
+  BookName2["JOB"] = "Job";
+  BookName2["PSALMS"] = "Psalms";
+  BookName2["PROVERBS"] = "Proverbs";
+  BookName2["ECCLESIASTES"] = "Ecclesiastes";
+  BookName2["SONG_OF_SONGS"] = "Song of Songs";
+  BookName2["ISAIAH"] = "Isaiah";
+  BookName2["JEREMIAH"] = "Jeremiah";
+  BookName2["LAMENTATIONS"] = "Lamentations";
+  BookName2["EZEKIEL"] = "Ezekiel";
+  BookName2["DANIEL"] = "Daniel";
+  BookName2["HOSEA"] = "Hosea";
+  BookName2["JOEL"] = "Joel";
+  BookName2["AMOS"] = "Amos";
+  BookName2["OBADIAH"] = "Obadiah";
+  BookName2["JONAH"] = "Jonah";
+  BookName2["MICAH"] = "Micah";
+  BookName2["NAHUM"] = "Nahum";
+  BookName2["HABAKKUK"] = "Habakkuk";
+  BookName2["ZEPHANIAH"] = "Zephaniah";
+  BookName2["HAGGAI"] = "Haggai";
+  BookName2["ZECHARIAH"] = "Zechariah";
+  BookName2["MALACHI"] = "Malachi";
+  BookName2["MATTHEW"] = "Matthew";
+  BookName2["MARK"] = "Mark";
+  BookName2["LUKE"] = "Luke";
+  BookName2["JOHN"] = "John";
+  BookName2["ACTS"] = "Acts";
+  BookName2["ROMANS"] = "Romans";
+  BookName2["CORINTHIANS_1"] = "1 Corinthians";
+  BookName2["CORINTHIANS_2"] = "2 Corinthians";
+  BookName2["GALATIANS"] = "Galatians";
+  BookName2["EPHESIANS"] = "Ephesians";
+  BookName2["PHILIPPIANS"] = "Philippians";
+  BookName2["COLOSSIANS"] = "Colossians";
+  BookName2["THESSALONIANS_1"] = "1 Thessalonians";
+  BookName2["THESSALONIANS_2"] = "2 Thessalonians";
+  BookName2["TIMOTHY_1"] = "1 Timothy";
+  BookName2["TIMOTHY_2"] = "2 Timothy";
+  BookName2["TITUS"] = "Titus";
+  BookName2["PHILEMON"] = "Philemon";
+  BookName2["HEBREWS"] = "Hebrews";
+  BookName2["JAMES"] = "James";
+  BookName2["PETER_1"] = "1 Peter";
+  BookName2["PETER_2"] = "2 Peter";
+  BookName2["JOHN_1"] = "1 John";
+  BookName2["JOHN_2"] = "2 John";
+  BookName2["JOHN_3"] = "3 John";
+  BookName2["JUDE"] = "Jude";
+  BookName2["REVELATION"] = "Revelation";
+  return BookName2;
+})(BookName || {});
+var VerseReferenceSchema = z.object({
+  bookNumber: z.number().int().min(1).max(66),
+  chapter: z.number().int().min(1),
+  verse: z.number().int().min(1)
+}).refine(
+  (data) => {
+    const bookInfo = BIBLE_STRUCTURE[data.bookNumber];
+    if (!bookInfo) return false;
+    return data.chapter <= bookInfo.chapters;
+  },
+  (data) => {
+    const bookInfo = BIBLE_STRUCTURE[data.bookNumber];
+    const bookName = BOOK_NAMES[data.bookNumber];
+    return {
+      message: `${bookName} only has ${bookInfo?.chapters} chapters, but chapter ${data.chapter} was requested`,
+      path: ["chapter"]
+    };
+  }
+).refine(
+  (data) => {
+    const bookInfo = BIBLE_STRUCTURE[data.bookNumber];
+    if (!bookInfo) return false;
+    const maxVerse = bookInfo.verses[data.chapter - 1];
+    if (!maxVerse) return false;
+    return data.verse <= maxVerse;
+  },
+  (data) => {
+    const bookInfo = BIBLE_STRUCTURE[data.bookNumber];
+    const bookName = BOOK_NAMES[data.bookNumber];
+    const maxVerse = bookInfo?.verses[data.chapter - 1];
+    return {
+      message: `${bookName} ${data.chapter} only has ${maxVerse} verses, but verse ${data.verse} was requested`,
+      path: ["verse"]
+    };
+  }
+);
+function createVerseReference(data) {
+  const validated = VerseReferenceSchema.parse(data);
+  return {
+    ...validated,
+    get bookName() {
+      return BookName[BOOK_NAMES[this.bookNumber]] || BOOK_NAMES[this.bookNumber];
+    },
+    toString() {
+      return `${BOOK_NAMES[this.bookNumber]} ${this.chapter}:${this.verse}`;
+    }
+  };
+}
+var TextSegmentSchema = z.object({
+  text: z.string(),
+  isRedLetter: z.boolean().default(false),
+  // Words of Jesus in red
+  isItalic: z.boolean().default(false),
+  // Italicized text (clarifications)
+  isBold: z.boolean().default(false),
+  // Bold text
+  isSmallCaps: z.boolean().default(false)
+  // LORD (Yahweh) in small caps
+});
+var VerseContentSchema = z.object({
+  reference: VerseReferenceSchema,
+  verseNumber: z.number().int().min(1),
+  segments: z.array(TextSegmentSchema),
+  hasSubheading: z.boolean().default(false),
+  subheadingText: z.string().nullable().default(null),
+  isPoetry: z.boolean().default(false),
+  isProse: z.boolean().default(false),
+  chapterStart: z.boolean().default(false)
+  // First verse of chapter
+});
+function createVerseContent(data) {
+  const validated = VerseContentSchema.parse(data);
+  const reference = createVerseReference(validated.reference);
+  return {
+    ...validated,
+    reference,
+    get plainText() {
+      return this.segments.map((seg) => seg.text).join(" ");
+    },
+    get formattedText() {
+      const parts = this.segments.map((seg) => {
+        let text = seg.text;
+        if (seg.isItalic) text = `[${text}]`;
+        if (seg.isRedLetter) text = `"${text}"`;
+        return text;
+      });
+      return parts.join(" ");
+    }
+  };
+}
+var PassageSchema = z.object({
+  fromRef: VerseReferenceSchema,
+  toRef: VerseReferenceSchema,
+  title: z.string(),
+  verses: z.array(VerseContentSchema)
+});
+function createPassage(data) {
+  const validated = PassageSchema.parse(data);
+  const fromRef = createVerseReference(validated.fromRef);
+  const toRef = createVerseReference(validated.toRef);
+  const verses = validated.verses.map((v) => createVerseContent(v));
+  return {
+    ...validated,
+    fromRef,
+    toRef,
+    verses,
+    get isSingleVerse() {
+      return this.fromRef.bookNumber === this.toRef.bookNumber && this.fromRef.chapter === this.toRef.chapter && this.fromRef.verse === this.toRef.verse;
+    },
+    get verseCount() {
+      return this.verses.length;
+    }
+  };
+}
+var SearchResponseSchema = z.object({
+  query: z.string(),
+  matchCount: z.number().int().min(0),
+  passages: z.array(PassageSchema),
+  durationMs: z.number().int().min(0),
+  timestamp: z.number().int(),
+  // Optional metadata for text searches
+  totalCount: z.number().int().min(0).optional(),
+  filteredCount: z.number().int().min(0).optional(),
+  countsByBook: z.record(z.string(), z.number()).optional(),
+  countsBySection: z.record(z.string(), z.number()).optional()
+});
+function createSearchResponse(data) {
+  const validated = SearchResponseSchema.parse(data);
+  const passages = validated.passages.map((p) => createPassage(p));
+  return {
+    ...validated,
+    passages,
+    get passageCount() {
+      return this.passages.length;
+    },
+    get totalVerses() {
+      return this.passages.reduce((sum, p) => sum + p.verseCount, 0);
+    },
+    get hasSearchMetadata() {
+      return this.totalCount !== void 0;
+    }
+  };
+}
+
+// src/mcp/resources.ts
+function registerResources(server) {
+  server.registerResource(
+    "books",
+    "bible://books",
+    {
+      title: "Bible Books",
+      description: "List of all 66 books in the Bible",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      const books = Object.values(BIBLE_STRUCTURE).map(
+        (bookInfo) => ({
+          name: bookInfo.name,
+          testament: bookInfo.testament,
+          chapters: bookInfo.chapters,
+          verses: bookInfo.verses.reduce((sum, count) => sum + count, 0)
+        })
+      );
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: "application/json",
+            text: JSON.stringify(books, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.registerResource(
+    "structure",
+    new ResourceTemplate("bible://structure/{book}", {
+      list: void 0,
+      complete: {
+        book: (value) => {
+          return Object.values(BookName).filter((bookName) => bookName.toLowerCase().startsWith(value.toLowerCase())).slice(0, 10);
+        }
+      }
+    }),
+    {
+      title: "Bible Book Structure",
+      description: "Chapter and verse counts for a specific book",
+      mimeType: "application/json"
+    },
+    async (uri, { book }) => {
+      const bookName = book;
+      const bookEntry = Object.values(BIBLE_STRUCTURE).find(
+        (b) => b.name.toLowerCase() === bookName.toLowerCase()
+      );
+      if (!bookEntry) {
+        throw new Error(`Unknown book: ${bookName}`);
+      }
+      const data = {
+        uri: uri.href,
+        book: bookEntry.name,
+        testament: bookEntry.testament,
+        totalChapters: bookEntry.chapters,
+        totalVerses: bookEntry.verses.reduce((sum, verses) => sum + verses, 0),
+        chapters: bookEntry.verses.map((verses, index) => ({
+          chapter: index + 1,
+          verses
+        }))
+      };
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: "application/json",
+            text: JSON.stringify(data, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/cache/memory.ts
+var MemoryCacheProvider = class {
+  cache = /* @__PURE__ */ new Map();
+  async get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return void 0;
+    }
+    if (Date.now() > entry.expires) {
+      this.cache.delete(key);
+      return void 0;
+    }
+    return entry.data;
+  }
+  async set(key, value, ttl) {
+    const expires = Date.now() + ttl * 1e3;
+    this.cache.set(key, { data: value, expires });
+  }
+  /**
+   * Clear all cache entries.
+   *
+   * Useful for testing or manual cache invalidation.
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * Get the number of entries in the cache.
+   *
+   * Includes expired entries that haven't been accessed yet.
+   */
+  size() {
+    return this.cache.size;
+  }
+};
+
+// src/cache/interface.ts
+var CacheTTL = {
+  /** 1 month - for immutable Bible content (verses, passages, chapters) */
+  BIBLE_CONTENT: 2592e3,
+  /** 1 week - for search results that may change with API updates */
+  SEARCH_RESULTS: 604800};
+
+// src/exceptions.ts
+var LSBibleError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LSBibleError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+};
+var InvalidReferenceError = class extends LSBibleError {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidReferenceError";
+  }
+};
+var APIError = class extends LSBibleError {
+  constructor(message) {
+    super(message);
+    this.name = "APIError";
+  }
+};
+var BuildIDError = class extends LSBibleError {
+  constructor(message) {
+    super(message);
+    this.name = "BuildIDError";
+  }
+};
+function parseSearchResultHtml(html) {
+  const { document } = parseHTML(`<!DOCTYPE html><html><body>${html}</body></html>`);
+  return document.body.textContent?.trim() ?? "";
+}
+function parsePassageHtml(html) {
+  const { document } = parseHTML(`<!DOCTYPE html><html><body>${html}</body></html>`);
+  const verses = [];
+  const verseSpans = document.querySelectorAll("span.verse");
+  for (const verseSpan of verseSpans) {
+    const verse = parseVerse(verseSpan);
+    verses.push(verse);
+  }
+  return verses;
+}
+function parseVerse(verseSpan, _document) {
+  const dataKey = verseSpan.getAttribute("data-key");
+  if (!dataKey) {
+    throw new Error("Verse span missing data-key attribute");
+  }
+  const reference = parseVerseReference(dataKey);
+  const verseNumElem = verseSpan.querySelector("small[data-verse]");
+  let verseNumber;
+  if (verseNumElem) {
+    verseNumber = Number.parseInt(verseNumElem.getAttribute("data-verse") ?? "0", 10);
+  } else {
+    verseNumber = reference.verse;
+  }
+  let hasSubheading = false;
+  let subheadingText = null;
+  const prevSibling = verseSpan.previousElementSibling;
+  if (prevSibling?.classList.contains("subhead")) {
+    hasSubheading = true;
+    subheadingText = prevSibling.textContent?.trim() ?? null;
+  }
+  let currentNode = verseSpan;
+  let isPoetry = false;
+  while (currentNode) {
+    if (currentNode.classList?.contains("poetry")) {
+      isPoetry = true;
+      break;
+    }
+    currentNode = currentNode.parentElement;
+  }
+  const isProse = verseSpan.querySelector(".prose") !== null;
+  const chapterStart = verseSpan.querySelector(".chapter-number") !== null;
+  const segments = extractSegments(verseSpan);
+  return createVerseContent({
+    reference,
+    verseNumber,
+    segments,
+    hasSubheading,
+    subheadingText,
+    isPoetry,
+    isProse,
+    chapterStart
+  });
+}
+function parseVerseReference(dataKey) {
+  const parts = dataKey.split("-");
+  if (parts.length !== 3) {
+    throw new Error(`Invalid data-key format: ${dataKey}`);
+  }
+  const bookNumber = Number.parseInt(parts[0] ?? "0", 10);
+  const chapter = Number.parseInt(parts[1] ?? "0", 10);
+  const verse = Number.parseInt(parts[2] ?? "0", 10);
+  return createVerseReference({ bookNumber, chapter, verse });
+}
+function extractSegments(element) {
+  const segments = [];
+  for (const smallElem of element.querySelectorAll("small[data-verse]")) {
+    smallElem.remove();
+  }
+  for (const chapterElem of element.querySelectorAll(".chapter-number")) {
+    chapterElem.remove();
+  }
+  for (const subheadElem of element.querySelectorAll(".subhead")) {
+    subheadElem.remove();
+  }
+  extractTextNodes(element, segments);
+  return segments;
+}
+function extractTextNodes(node, segments) {
+  for (const child of node.childNodes) {
+    if (child.nodeType === 3) {
+      const text = child.textContent?.trim();
+      if (!text) continue;
+      let isRedLetter = false;
+      let isItalic = false;
+      let isBold = false;
+      let isSmallCaps = false;
+      let parent = child.parentElement;
+      while (parent) {
+        if (parent.classList.contains("red-letter")) {
+          isRedLetter = true;
+        }
+        if (parent.tagName === "I" || parent.classList.contains("italic")) {
+          isItalic = true;
+        }
+        if (parent.tagName === "B" || parent.classList.contains("bold")) {
+          isBold = true;
+        }
+        if (parent.classList.contains("small-caps")) {
+          isSmallCaps = true;
+        }
+        parent = parent.parentElement;
+      }
+      segments.push({
+        text,
+        isRedLetter,
+        isItalic,
+        isBold,
+        isSmallCaps
+      });
+    } else if (child.nodeType === 1) {
+      extractTextNodes(child, segments);
+    }
+  }
+}
+
+// src/validators.ts
+function normalizeBookName(book) {
+  if (typeof book === "string" && Object.values(BookName).includes(book)) {
+    return book;
+  }
+  if (typeof book !== "string") {
+    throw new InvalidReferenceError(`Invalid book type: ${typeof book}`);
+  }
+  const bookStr = book.trim();
+  const bookLower = bookStr.toLowerCase();
+  if (bookLower in BOOK_NUMBERS) {
+    const bookNum = BOOK_NUMBERS[bookLower];
+    if (bookNum) {
+      return BIBLE_STRUCTURE[bookNum]?.name ?? book;
+    }
+  }
+  const normalized = bookLower.split(/\s+/).join(" ");
+  if (normalized in BOOK_NUMBERS) {
+    const bookNum = BOOK_NUMBERS[normalized];
+    if (bookNum) {
+      return BIBLE_STRUCTURE[bookNum]?.name ?? book;
+    }
+  }
+  if (/^\d/.test(bookLower)) {
+    const spaced = bookLower.replace(/^(\d+)([a-z])/, "$1 $2");
+    if (spaced in BOOK_NUMBERS) {
+      const bookNum = BOOK_NUMBERS[spaced];
+      if (bookNum) {
+        return BIBLE_STRUCTURE[bookNum]?.name ?? book;
+      }
+    }
+  }
+  throw new InvalidReferenceError(`Unknown book: ${book}`);
+}
+function getBookNumber(book) {
+  const normalized = normalizeBookName(book);
+  const bookNum = BOOK_NUMBERS[normalized.toLowerCase()];
+  if (!bookNum) {
+    throw new InvalidReferenceError(`Unknown book: ${book}`);
+  }
+  return bookNum;
+}
+function validateReference(book, chapter, verse) {
+  try {
+    const bookNumber = getBookNumber(book);
+    return createVerseReference({
+      bookNumber,
+      chapter,
+      verse
+    });
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new InvalidReferenceError(error.message);
+    }
+    throw error;
+  }
+}
+
+// src/client.ts
+function getSdkVersion() {
+  return "0.1.0";
+}
+function getUserAgent() {
+  const version = getSdkVersion();
+  const runtime = "Bun" in globalThis ? "Bun" : "Deno" in globalThis ? "Deno" : "Node.js";
+  return `lsbible-typescript/${version} (${runtime}; +https://github.com/kdcokenny/lsbible)`;
+}
+var LSBibleClient = class _LSBibleClient {
+  static BASE_URL = "https://read.lsbible.org";
+  cacheProvider;
+  cacheTtls;
+  timeout;
+  buildId;
+  buildIdFetched;
+  headers;
+  /**
+   * Create a new LSBible client.
+   *
+   * @param options - Client configuration options
+   */
+  constructor(options = {}) {
+    this.cacheProvider = options.cache?.provider ?? void 0;
+    this.cacheTtls = {
+      verse: options.cache?.ttl?.verse ?? CacheTTL.BIBLE_CONTENT,
+      passage: options.cache?.ttl?.passage ?? CacheTTL.BIBLE_CONTENT,
+      chapter: options.cache?.ttl?.chapter ?? CacheTTL.BIBLE_CONTENT,
+      search: options.cache?.ttl?.search ?? CacheTTL.SEARCH_RESULTS
+    };
+    this.timeout = (options.timeout ?? 30) * 1e3;
+    this.buildId = options.buildId;
+    this.buildIdFetched = options.buildId !== void 0;
+    this.headers = {
+      "User-Agent": getUserAgent(),
+      Accept: "*/*",
+      ...options.headers
+    };
+  }
+  /**
+   * Get the Next.js build ID.
+   *
+   * Strategies:
+   * 1. Use cached/provided build ID
+   * 2. Extract from homepage HTML (__NEXT_DATA__ script)
+   * 3. Try to find it in script tags
+   *
+   * @throws BuildIDError if build ID cannot be determined
+   */
+  async getBuildId() {
+    if (this.buildId && this.buildIdFetched) {
+      return this.buildId;
+    }
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      const response = await fetch(_LSBibleClient.BASE_URL, {
+        signal: controller.signal,
+        headers: this.headers
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const html = await response.text();
+      const buildIdMatch = html.match(/"buildId":"([^"]+)"/);
+      if (buildIdMatch?.[1]) {
+        this.buildId = buildIdMatch[1];
+        this.buildIdFetched = true;
+        return this.buildId;
+      }
+      const scriptMatch = html.match(/\/_next\/data\/([^/]+)\//);
+      if (scriptMatch?.[1]) {
+        this.buildId = scriptMatch[1];
+        this.buildIdFetched = true;
+        return this.buildId;
+      }
+    } catch (error) {
+      throw new BuildIDError(
+        `Failed to fetch build ID: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    throw new BuildIDError("Could not determine build ID from homepage");
+  }
+  /**
+   * Cache wrapper for async operations.
+   *
+   * @param key - Cache key
+   * @param ttl - Time to live in seconds
+   * @param fetcher - Function to fetch fresh data
+   * @returns Cached or fresh data
+   */
+  async withCache(key, ttl, fetcher) {
+    if (!this.cacheProvider) {
+      return fetcher();
+    }
+    const cached = await this.cacheProvider.get(key);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const data = await fetcher();
+    await this.cacheProvider.set(key, data, ttl);
+    return data;
+  }
+  /**
+   * Make a request to the LSBible API.
+   *
+   * @param query - Search query or verse reference
+   * @returns API response JSON
+   * @throws APIError if request fails
+   */
+  async makeRequest(query) {
+    const buildId = await this.getBuildId();
+    const url = new URL(`${_LSBibleClient.BASE_URL}/_next/data/${buildId}/index.json`);
+    url.searchParams.set("q", query);
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      const response = await fetch(url.toString(), {
+        signal: controller.signal,
+        headers: {
+          ...this.headers,
+          referer: `${_LSBibleClient.BASE_URL}/`,
+          "x-nextjs-data": "1"
+        }
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        throw new APIError(
+          `API request failed with status ${response.status}: ${response.statusText}`
+        );
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof APIError) {
+        throw error;
+      }
+      throw new APIError(
+        `API request failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Detect if response is from text search or Bible reference lookup.
+   *
+   * Text searches have initialItems array with metadata.
+   * Bible reference lookups have passages array with full HTML.
+   */
+  isTextSearch(pageProps) {
+    return "initialItems" in pageProps && "totalCount" in pageProps;
+  }
+  /**
+   * Parse text search results from initialItems format.
+   */
+  parseSearchResults(pageProps, query) {
+    const passages = [];
+    const initialItems = pageProps.initialItems ?? [];
+    for (const item of initialItems) {
+      const key = item.key;
+      const parts = key.split("-");
+      if (parts.length !== 3) continue;
+      const bookNumber = Number.parseInt(parts[0] ?? "0", 10);
+      const chapter = Number.parseInt(parts[1] ?? "0", 10);
+      const verse = Number.parseInt(parts[2] ?? "0", 10);
+      const verseRef = createVerseReference({ bookNumber, chapter, verse });
+      const htmlSnippet = item.html ?? "";
+      const plainText = parseSearchResultHtml(htmlSnippet);
+      const segment = {
+        text: plainText,
+        isRedLetter: false,
+        isItalic: false,
+        isBold: false,
+        isSmallCaps: false
+      };
+      const verseContent = createVerseContent({
+        reference: verseRef,
+        verseNumber: verse,
+        segments: [segment],
+        hasSubheading: false,
+        subheadingText: null,
+        isPoetry: false,
+        isProse: false,
+        chapterStart: false
+      });
+      passages.push(
+        createPassage({
+          fromRef: verseRef,
+          toRef: verseRef,
+          title: verseRef.toString(),
+          verses: [verseContent]
+        })
+      );
+    }
+    const totalCount = pageProps.totalCount ?? 0;
+    const filteredCount = pageProps.filteredCount ?? 0;
+    const countsByBook = pageProps.countsByBook;
+    const countsBySection = pageProps.countsBySection;
+    return createSearchResponse({
+      query,
+      matchCount: totalCount,
+      passages,
+      durationMs: pageProps.duration ?? 0,
+      timestamp: pageProps.start ?? 0,
+      totalCount,
+      filteredCount,
+      countsByBook,
+      countsBySection
+    });
+  }
+  /**
+   * Parse Bible reference lookup results from passages format.
+   */
+  parseReferenceResults(pageProps, query) {
+    const passages = [];
+    const passagesData = pageProps.passages ?? [];
+    for (const passageData of passagesData) {
+      const fromData = passageData.from;
+      const toData = passageData.to;
+      const fromRef = createVerseReference({
+        bookNumber: fromData.bn ?? 0,
+        chapter: fromData.cn ?? 0,
+        verse: fromData.vn ?? 0
+      });
+      const toRef = createVerseReference({
+        bookNumber: toData.bn ?? 0,
+        chapter: toData.cn ?? 0,
+        verse: toData.vn ?? 0
+      });
+      const passageHtml = passageData.passageHtml ?? "";
+      const verses = parsePassageHtml(passageHtml);
+      passages.push(
+        createPassage({
+          fromRef,
+          toRef,
+          title: passageData.title ?? "",
+          verses
+        })
+      );
+    }
+    return createSearchResponse({
+      query,
+      matchCount: pageProps.searchMatchCount ?? 0,
+      passages,
+      durationMs: pageProps.duration ?? 0,
+      timestamp: pageProps.start ?? 0
+    });
+  }
+  /**
+   * Parse API response into SearchResponse.
+   */
+  parseResponse(data, query) {
+    const responseData = data;
+    const pageProps = responseData.pageProps ?? {};
+    if (this.isTextSearch(pageProps)) {
+      return this.parseSearchResults(pageProps, query);
+    }
+    return this.parseReferenceResults(pageProps, query);
+  }
+  /**
+   * Search for passages containing text.
+   *
+   * @param query - Search text (e.g., "love", "faith")
+   * @returns SearchResponse with structured passage data
+   * @throws APIError if API request fails
+   */
+  async search(query) {
+    return this.withCache(`search:${query}`, this.cacheTtls.search, async () => {
+      const data = await this.makeRequest(query);
+      return this.parseResponse(data, query);
+    });
+  }
+  /**
+   * Get a specific verse with validated parameters.
+   *
+   * @param book - Book name as enum or string
+   * @param chapter - Chapter number (validated against book)
+   * @param verse - Verse number (validated against chapter)
+   * @returns Single Passage containing the verse
+   * @throws InvalidReferenceError if book/chapter/verse combination is invalid
+   * @throws APIError if API request fails
+   *
+   * @example
+   * ```ts
+   * // Using enum (recommended - type-safe with autocomplete)
+   * const passage = await client.getVerse(BookName.JOHN, 3, 16);
+   *
+   * // Using string (validated at runtime)
+   * const passage2 = await client.getVerse("John", 3, 16);
+   * ```
+   */
+  async getVerse(book, chapter, verse) {
+    validateReference(book, chapter, verse);
+    const bookName = normalizeBookName(book);
+    const query = `${bookName} ${chapter}:${verse}`;
+    return this.withCache(`verse:${query}`, this.cacheTtls.verse, async () => {
+      const response = await this.search(query);
+      if (response.passages.length === 0) {
+        throw new APIError(`No passage found for ${query}`);
+      }
+      const passage = response.passages[0];
+      if (!passage) {
+        throw new APIError(`No passage found for ${query}`);
+      }
+      return passage;
+    });
+  }
+  /**
+   * Get a passage spanning multiple verses.
+   *
+   * @param fromBook - Starting book
+   * @param fromChapter - Starting chapter
+   * @param fromVerse - Starting verse
+   * @param toBook - Ending book
+   * @param toChapter - Ending chapter
+   * @param toVerse - Ending verse
+   * @returns Passage containing all verses in range
+   * @throws InvalidReferenceError if any reference is invalid
+   * @throws APIError if API request fails
+   *
+   * @example
+   * ```ts
+   * // Get John 3:16-18
+   * const passage = await client.getPassage(
+   *   BookName.JOHN, 3, 16,
+   *   BookName.JOHN, 3, 18
+   * );
+   * ```
+   */
+  async getPassage(fromBook, fromChapter, fromVerse, toBook, toChapter, toVerse) {
+    const fromRef = validateReference(fromBook, fromChapter, fromVerse);
+    const toRef = validateReference(toBook, toChapter, toVerse);
+    const fromBookName = normalizeBookName(fromBook);
+    const toBookName = normalizeBookName(toBook);
+    let query;
+    if (fromRef.bookNumber === toRef.bookNumber) {
+      if (fromChapter === toChapter) {
+        query = `${fromBookName} ${fromChapter}:${fromVerse}-${toVerse}`;
+      } else {
+        query = `${fromBookName} ${fromChapter}:${fromVerse}-${toChapter}:${toVerse}`;
+      }
+    } else {
+      query = `${fromBookName} ${fromChapter}:${fromVerse}-${toBookName} ${toChapter}:${toVerse}`;
+    }
+    return this.withCache(`passage:${query}`, this.cacheTtls.passage, async () => {
+      const response = await this.search(query);
+      if (response.passages.length === 0) {
+        throw new APIError(`No passage found for ${query}`);
+      }
+      const passage = response.passages[0];
+      if (!passage) {
+        throw new APIError(`No passage found for ${query}`);
+      }
+      return passage;
+    });
+  }
+  /**
+   * Get an entire chapter.
+   *
+   * @param book - Book name
+   * @param chapter - Chapter number
+   * @returns Passage containing all verses in the chapter
+   * @throws InvalidReferenceError if book/chapter is invalid
+   * @throws APIError if API request fails
+   *
+   * @example
+   * ```ts
+   * // Get all of John chapter 3
+   * const passage = await client.getChapter(BookName.JOHN, 3);
+   * ```
+   */
+  async getChapter(book, chapter) {
+    const bookNumber = getBookNumber(book);
+    const bookInfo = BIBLE_STRUCTURE[bookNumber];
+    if (!bookInfo) {
+      throw new APIError(`Invalid book number: ${bookNumber}`);
+    }
+    const maxChapter = bookInfo.chapters;
+    if (chapter < 1 || chapter > maxChapter) {
+      const bookName2 = normalizeBookName(book);
+      throw new APIError(
+        `${bookName2} only has ${maxChapter} chapters, but chapter ${chapter} was requested`
+      );
+    }
+    const bookName = normalizeBookName(book);
+    const query = `${bookName} ${chapter}`;
+    return this.withCache(`chapter:${query}`, this.cacheTtls.chapter, async () => {
+      const response = await this.search(query);
+      if (response.passages.length === 0) {
+        throw new APIError(`No passage found for ${query}`);
+      }
+      const passage = response.passages[0];
+      if (!passage) {
+        throw new APIError(`No passage found for ${query}`);
+      }
+      return passage;
+    });
+  }
+  /**
+   * Clear all cached data.
+   *
+   * This method calls the cache provider's clear method if one is configured.
+   * If the cache provider doesn't implement a clear method, this is a no-op.
+   *
+   * @example
+   * ```ts
+   * const client = new LSBibleClient({
+   *   cache: { provider: new MemoryCacheProvider() }
+   * });
+   *
+   * // Clear all cached data
+   * client.clearCache();
+   * ```
+   */
+  clearCache() {
+    if (this.cacheProvider && "clear" in this.cacheProvider) {
+      this.cacheProvider.clear();
+    }
+  }
+};
+
+// src/mcp/tools.ts
+function registerTools(server, client) {
+  const apiClient = new LSBibleClient({
+    cache: {
+      provider: new MemoryCacheProvider()
+    }
+  });
+  server.registerTool(
+    "get_verse",
+    {
+      title: "Get Bible Verse",
+      description: "Fetch a single Bible verse by book, chapter, and verse",
+      inputSchema: {
+        book: z.nativeEnum(BookName).describe("Book name (e.g., John, Genesis)"),
+        chapter: z.number().int().positive().describe("Chapter number"),
+        verse: z.number().int().positive().describe("Verse number")
+      },
+      outputSchema: {
+        reference: z.object({
+          book: z.string(),
+          chapter: z.number(),
+          verse: z.number()
+        }),
+        text: z.string(),
+        segments: z.array(
+          z.object({
+            text: z.string(),
+            isRedLetter: z.boolean().optional(),
+            isItalic: z.boolean().optional(),
+            isSmallCaps: z.boolean().optional(),
+            isBold: z.boolean().optional()
+          })
+        )
+      }
+    },
+    async ({ book, chapter, verse }) => {
+      try {
+        const passage = await apiClient.getVerse(book, chapter, verse);
+        const verseData = passage.verses[0];
+        if (!verseData) {
+          const output2 = {
+            error: `No verse found for ${book} ${chapter}:${verse}`
+          };
+          return {
+            content: [{ type: "text", text: JSON.stringify(output2) }],
+            isError: true
+          };
+        }
+        const output = {
+          reference: {
+            book: verseData.reference.bookName,
+            chapter: verseData.reference.chapter,
+            verse: verseData.reference.verse
+          },
+          text: verseData.plainText,
+          segments: verseData.segments
+        };
+        return {
+          content: [{ type: "text", text: JSON.stringify(output) }],
+          structuredContent: output
+        };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${errorMessage}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "get_passage",
+    {
+      title: "Get Bible Passage",
+      description: "Fetch a range of verses (single or multi-chapter)",
+      inputSchema: {
+        fromBook: z.nativeEnum(BookName).describe("Starting book"),
+        fromChapter: z.number().int().positive().describe("Starting chapter"),
+        fromVerse: z.number().int().positive().describe("Starting verse"),
+        toBook: z.nativeEnum(BookName).describe("Ending book"),
+        toChapter: z.number().int().positive().describe("Ending chapter"),
+        toVerse: z.number().int().positive().describe("Ending verse")
+      },
+      outputSchema: {
+        reference: z.object({
+          from: z.object({
+            book: z.string(),
+            chapter: z.number(),
+            verse: z.number()
+          }),
+          to: z.object({
+            book: z.string(),
+            chapter: z.number(),
+            verse: z.number()
+          })
+        }),
+        verses: z.array(
+          z.object({
+            reference: z.object({
+              book: z.string(),
+              chapter: z.number(),
+              verse: z.number()
+            }),
+            text: z.string(),
+            segments: z.array(
+              z.object({
+                text: z.string(),
+                isRedLetter: z.boolean().optional(),
+                isItalic: z.boolean().optional(),
+                isSmallCaps: z.boolean().optional(),
+                isBold: z.boolean().optional()
+              })
+            )
+          })
+        )
+      }
+    },
+    async ({ fromBook, fromChapter, fromVerse, toBook, toChapter, toVerse }) => {
+      try {
+        const passage = await apiClient.getPassage(
+          fromBook,
+          fromChapter,
+          fromVerse,
+          toBook,
+          toChapter,
+          toVerse
+        );
+        const output = {
+          reference: {
+            from: {
+              book: passage.fromRef.bookName,
+              chapter: passage.fromRef.chapter,
+              verse: passage.fromRef.verse
+            },
+            to: {
+              book: passage.toRef.bookName,
+              chapter: passage.toRef.chapter,
+              verse: passage.toRef.verse
+            }
+          },
+          verses: passage.verses.map((v) => ({
+            reference: {
+              book: v.reference.bookName,
+              chapter: v.reference.chapter,
+              verse: v.reference.verse
+            },
+            text: v.plainText,
+            segments: v.segments
+          }))
+        };
+        return {
+          content: [{ type: "text", text: JSON.stringify(output) }],
+          structuredContent: output
+        };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${errorMessage}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "get_chapter",
+    {
+      title: "Get Bible Chapter",
+      description: "Fetch an entire chapter",
+      inputSchema: {
+        book: z.nativeEnum(BookName).describe("Book name"),
+        chapter: z.number().int().positive().describe("Chapter number")
+      },
+      outputSchema: {
+        reference: z.object({
+          book: z.string(),
+          chapter: z.number(),
+          verseCount: z.number()
+        }),
+        verses: z.array(
+          z.object({
+            reference: z.object({
+              book: z.string(),
+              chapter: z.number(),
+              verse: z.number()
+            }),
+            text: z.string(),
+            segments: z.array(
+              z.object({
+                text: z.string(),
+                isRedLetter: z.boolean().optional(),
+                isItalic: z.boolean().optional(),
+                isSmallCaps: z.boolean().optional(),
+                isBold: z.boolean().optional()
+              })
+            )
+          })
+        )
+      }
+    },
+    async ({ book, chapter }) => {
+      try {
+        const passage = await apiClient.getChapter(book, chapter);
+        const output = {
+          reference: {
+            book: passage.verses[0]?.reference.bookName ?? book,
+            chapter,
+            verseCount: passage.verses.length
+          },
+          verses: passage.verses.map((v) => ({
+            reference: {
+              book: v.reference.bookName,
+              chapter: v.reference.chapter,
+              verse: v.reference.verse
+            },
+            text: v.plainText,
+            segments: v.segments
+          }))
+        };
+        return {
+          content: [{ type: "text", text: JSON.stringify(output) }],
+          structuredContent: output
+        };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${errorMessage}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "search_bible",
+    {
+      title: "Search Bible",
+      description: "Full-text search across the entire Bible",
+      inputSchema: {
+        query: z.string().describe("Search query text"),
+        includeDistribution: z.boolean().optional().default(false).describe("Include search result distribution by section and book")
+      },
+      outputSchema: {
+        query: z.string(),
+        resultCount: z.number(),
+        results: z.array(
+          z.object({
+            reference: z.object({
+              book: z.string(),
+              chapter: z.number(),
+              verse: z.number()
+            }),
+            text: z.string(),
+            segments: z.array(
+              z.object({
+                text: z.string(),
+                isRedLetter: z.boolean().optional(),
+                isItalic: z.boolean().optional(),
+                isSmallCaps: z.boolean().optional(),
+                isBold: z.boolean().optional()
+              })
+            )
+          })
+        ),
+        distribution: z.object({
+          bySection: z.record(z.string(), z.number()),
+          byBook: z.record(z.string(), z.number())
+        }).optional()
+      }
+    },
+    async ({ query, includeDistribution = false }) => {
+      try {
+        const searchResponse = await apiClient.search(query);
+        const distribution = includeDistribution ? {
+          bySection: searchResponse.countsBySection ?? {},
+          byBook: searchResponse.countsByBook ?? {}
+        } : void 0;
+        const results = searchResponse.passages.flatMap(
+          (passage) => passage.verses.map((v) => ({
+            reference: {
+              book: v.reference.bookName,
+              chapter: v.reference.chapter,
+              verse: v.reference.verse
+            },
+            text: v.plainText,
+            segments: v.segments
+          }))
+        );
+        const output = {
+          query,
+          resultCount: searchResponse.matchCount,
+          results,
+          distribution
+        };
+        return {
+          content: [{ type: "text", text: JSON.stringify(output) }],
+          structuredContent: output
+        };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${errorMessage}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/mcp/server.ts
+function createLSBibleMCPServer() {
+  const server = new McpServer({
+    name: "lsbible",
+    version: "0.1.0"
+  });
+  registerTools(server);
+  registerResources(server);
+  registerPrompts(server);
+  return server;
+}
+
+// src/mcp/stdio.ts
+async function main() {
+  const server = createLSBibleMCPServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("LSBible MCP Server running on stdio");
+  console.error("Ready to accept connections from MCP clients");
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=stdio.js.map
+//# sourceMappingURL=stdio.js.map