@faith-tools/bible-sdk 0.0.0-stage → 0.7.0

package/dist/types/card.d.ts

@@ -0,0 +1,20 @@
+import { type ReferenceLayout } from "./scripture-passage";
+import { type ProviderOptions } from "./providers";
+export type CardOptions = ProviderOptions & {
+    /** How the card's passage shows its reference, as on <si-passage>. */
+    reference: ReferenceLayout;
+};
+/**
+ * One Scripture card per page, rendered in a Shadow DOM so the host page's
+ * CSS cannot reach it. `toggle(anchor)` opens it above the anchor.
+ */
+export declare function createScriptureCard({ reference, ...options }: CardOptions): {
+    toggle(target: HTMLElement): void;
+    hover: (target: HTMLElement) => void;
+    unhover: (event?: PointerEvent) => void;
+    close: (immediate?: boolean) => void;
+    /** Closes the card at once if its link left the page, as when a router swaps the body. */
+    closeIfDetached(): void;
+    /** Closes the card at once and removes its host from the page. */
+    destroy(): void;
+};

package/dist/types/data-effect.d.ts

@@ -0,0 +1,206 @@
+import { Effect, Layer } from "effect";
+import { type BibleProvider } from "./providers.js";
+import { BibleSource, ScriptureError, type BibleDataProvider } from "./data-types.js";
+export { BibleBook, BibleChapter, BibleSource, BibleVersion, DisplayInstruction, ScriptureError, ScriptureErrorCode, ScripturePassage } from "./data-types.js";
+export type { BibleDataProvider, BibleDisplayProvider } from "./data-types.js";
+export { RequestPolicy } from "./runtime.js";
+/** Service-based programs can use a test or application Layer without constructing a client. */
+export declare const scripture: {
+    listVersions: () => Effect.Effect<readonly {
+        readonly id: string;
+        readonly abbreviation: string;
+        readonly title: string;
+        readonly language?: string | undefined;
+        readonly languageName?: string | undefined;
+    }[], ScriptureError, BibleSource>;
+    listBooks: (args_0?: {
+        versionId?: string;
+    } | undefined) => Effect.Effect<readonly {
+        readonly id: string;
+        readonly title: string;
+    }[], ScriptureError, BibleSource>;
+    listChapters: (args_0: {
+        versionId?: string;
+        bookId: string;
+    }) => Effect.Effect<readonly {
+        readonly passageId: string;
+        readonly number: number;
+    }[], ScriptureError, BibleSource>;
+    getPassage: (args_0: {
+        versionId?: string;
+        passageId: string;
+    }) => Effect.Effect<{
+        readonly provider: string;
+        readonly source: {
+            readonly url: string;
+            readonly versionId: string;
+        };
+        readonly requestedPassageId: string;
+        readonly passageId: string;
+        readonly reference: string;
+        readonly text: string;
+        readonly version: {
+            readonly id: string;
+            readonly abbreviation: string;
+            readonly title: string;
+            readonly language?: string | undefined;
+            readonly languageName?: string | undefined;
+            readonly sourceLanguage?: string | undefined;
+        };
+        readonly attribution: {
+            readonly text: string;
+            readonly urls: readonly string[];
+        };
+        readonly publisher?: {
+            readonly copyrightHtml: string;
+            readonly infoHtml: string;
+        } | undefined;
+        readonly reporting?: {
+            readonly kind: "api-bible-fums";
+            readonly token: string;
+        } | undefined;
+        readonly cache?: {
+            readonly expiresAt: number;
+        } | undefined;
+        readonly licenses: readonly {
+            readonly name?: string | undefined;
+            readonly url: string;
+            readonly restrictions?: {
+                readonly [x: string]: string | boolean;
+            } | undefined;
+        }[];
+        readonly numbering: "kjv" | "unknown";
+        readonly sourceLimitations?: readonly {
+            readonly kind: "source-trimming";
+            readonly startPassageId: string;
+            readonly endPassageId: string;
+            readonly appliesToRequest: boolean;
+        }[] | undefined;
+        readonly display: {
+            readonly format: "text";
+            readonly whitespace: "pre-wrap";
+            readonly attributionPlacement: "after-passage";
+            readonly direction?: "ltr" | "rtl" | undefined;
+            readonly language?: string | undefined;
+            readonly nativeHtml?: {
+                readonly containerAttributes: {
+                    readonly [x: string]: string;
+                };
+                readonly stylesheets: readonly {
+                    readonly kind: "bible" | "font";
+                    readonly href: string;
+                }[];
+            } | undefined;
+        };
+        readonly instructions: readonly {
+            readonly code: string;
+            readonly level: "notice" | "recommended" | "required";
+            readonly appliesTo: "all" | "html" | "text";
+            readonly text: string;
+            readonly urls?: readonly string[] | undefined;
+        }[];
+    }, ScriptureError, BibleSource>;
+    clearCache: Effect.Effect<void, never, BibleSource>;
+};
+/** One source per client. Effects are lazy; run them at the application boundary. */
+export declare function createScriptureClient({ provider }?: {
+    provider?: BibleProvider | BibleDataProvider;
+}): {
+    provider: string;
+    layer: Layer.Layer<BibleSource, never, never>;
+    listVersions: () => Effect.Effect<readonly {
+        readonly id: string;
+        readonly abbreviation: string;
+        readonly title: string;
+        readonly language?: string | undefined;
+        readonly languageName?: string | undefined;
+    }[], ScriptureError, never>;
+    listBooks: (options?: {
+        versionId?: string;
+    }) => Effect.Effect<readonly {
+        readonly id: string;
+        readonly title: string;
+    }[], ScriptureError, never>;
+    listChapters: (options: {
+        versionId?: string;
+        bookId: string;
+    }) => Effect.Effect<readonly {
+        readonly passageId: string;
+        readonly number: number;
+    }[], ScriptureError, never>;
+    getPassage: (options: {
+        versionId?: string;
+        passageId: string;
+    }) => Effect.Effect<{
+        readonly provider: string;
+        readonly source: {
+            readonly url: string;
+            readonly versionId: string;
+        };
+        readonly requestedPassageId: string;
+        readonly passageId: string;
+        readonly reference: string;
+        readonly text: string;
+        readonly version: {
+            readonly id: string;
+            readonly abbreviation: string;
+            readonly title: string;
+            readonly language?: string | undefined;
+            readonly languageName?: string | undefined;
+            readonly sourceLanguage?: string | undefined;
+        };
+        readonly attribution: {
+            readonly text: string;
+            readonly urls: readonly string[];
+        };
+        readonly publisher?: {
+            readonly copyrightHtml: string;
+            readonly infoHtml: string;
+        } | undefined;
+        readonly reporting?: {
+            readonly kind: "api-bible-fums";
+            readonly token: string;
+        } | undefined;
+        readonly cache?: {
+            readonly expiresAt: number;
+        } | undefined;
+        readonly licenses: readonly {
+            readonly name?: string | undefined;
+            readonly url: string;
+            readonly restrictions?: {
+                readonly [x: string]: string | boolean;
+            } | undefined;
+        }[];
+        readonly numbering: "kjv" | "unknown";
+        readonly sourceLimitations?: readonly {
+            readonly kind: "source-trimming";
+            readonly startPassageId: string;
+            readonly endPassageId: string;
+            readonly appliesToRequest: boolean;
+        }[] | undefined;
+        readonly display: {
+            readonly format: "text";
+            readonly whitespace: "pre-wrap";
+            readonly attributionPlacement: "after-passage";
+            readonly direction?: "ltr" | "rtl" | undefined;
+            readonly language?: string | undefined;
+            readonly nativeHtml?: {
+                readonly containerAttributes: {
+                    readonly [x: string]: string;
+                };
+                readonly stylesheets: readonly {
+                    readonly kind: "bible" | "font";
+                    readonly href: string;
+                }[];
+            } | undefined;
+        };
+        readonly instructions: readonly {
+            readonly code: string;
+            readonly level: "notice" | "recommended" | "required";
+            readonly appliesTo: "all" | "html" | "text";
+            readonly text: string;
+            readonly urls?: readonly string[] | undefined;
+        }[];
+    }, ScriptureError, never>;
+    clearCache: () => Effect.Effect<void, never, never>;
+};

package/dist/types/data-helpers.d.ts

@@ -0,0 +1,21 @@
+import { Duration, Effect, Schema } from "effect";
+import { ScriptureError, type DisplayInstruction } from "./data-types.js";
+/** Validate before passing source metadata to Intl constructors. */
+export declare const SourceLanguage: Schema.String;
+export declare const escapeHtml: (text: string) => string;
+export declare function attributionLink(text: string, url: string): string;
+/** Structural validation only. Availability always comes from the selected source. */
+export declare const passageRange: (passageId: string) => Effect.Effect<{
+    readonly book: string;
+    readonly chapter: number;
+    readonly first?: number | undefined;
+    readonly last?: number | undefined;
+}, ScriptureError, never>;
+export declare const bookId: (value: string) => Effect.Effect<string, ScriptureError, never>;
+export declare function validateVerses(numbers: readonly number[], first?: number, last?: number): Effect.Effect<void, ScriptureError>;
+export declare function textInstructions(): DisplayInstruction[];
+/** Bounded Effect cache. Failed exits expire immediately and lookups inherit caller services. */
+export declare function requestCache(timeToLive?: Duration.Input): {
+    get<T>(key: string, load: () => Effect.Effect<T, ScriptureError>): Effect.Effect<T, ScriptureError>;
+    clear: Effect.Effect<void, never, never>;
+};

package/dist/types/data-types.d.ts

@@ -0,0 +1,125 @@
+import { Context, Duration, Effect, Schema } from "effect";
+import type { PassageDisplay } from "./providers.js";
+export declare const BibleVersion: Schema.Struct<{
+    readonly id: Schema.NonEmptyString;
+    readonly abbreviation: Schema.String;
+    readonly title: Schema.String;
+    readonly language: Schema.optional<Schema.String>;
+    readonly languageName: Schema.optional<Schema.String>;
+}>;
+export type BibleVersion = typeof BibleVersion.Type;
+export declare const DisplayInstruction: Schema.Struct<{
+    readonly code: Schema.NonEmptyString;
+    readonly level: Schema.Literals<readonly ["required", "recommended", "notice"]>;
+    readonly appliesTo: Schema.Literals<readonly ["all", "text", "html"]>;
+    readonly text: Schema.NonEmptyString;
+    readonly urls: Schema.optional<Schema.$Array<Schema.String>>;
+}>;
+export type DisplayInstruction = typeof DisplayInstruction.Type;
+export declare const BibleBook: Schema.Struct<{
+    readonly id: Schema.NonEmptyString;
+    readonly title: Schema.String;
+}>;
+export type BibleBook = typeof BibleBook.Type;
+export declare const BibleChapter: Schema.Struct<{
+    readonly passageId: Schema.NonEmptyString;
+    readonly number: Schema.Int;
+}>;
+export type BibleChapter = typeof BibleChapter.Type;
+export declare const ScripturePassage: Schema.Struct<{
+    readonly provider: Schema.NonEmptyString;
+    readonly source: Schema.Struct<{
+        readonly url: Schema.String;
+        readonly versionId: Schema.NonEmptyString;
+    }>;
+    readonly requestedPassageId: Schema.NonEmptyString;
+    readonly passageId: Schema.NonEmptyString;
+    readonly reference: Schema.String;
+    readonly text: Schema.String;
+    readonly version: Schema.Struct<{
+        readonly id: Schema.NonEmptyString;
+        readonly abbreviation: Schema.String;
+        readonly title: Schema.String;
+        readonly language: Schema.optional<Schema.String>;
+        readonly languageName: Schema.optional<Schema.String>;
+        readonly sourceLanguage: Schema.optional<Schema.String>;
+    }>;
+    readonly attribution: Schema.Struct<{
+        readonly text: Schema.NonEmptyString;
+        readonly urls: Schema.$Array<Schema.String>;
+    }>;
+    readonly publisher: Schema.optional<Schema.Struct<{
+        readonly copyrightHtml: Schema.String;
+        readonly infoHtml: Schema.String;
+    }>>;
+    readonly reporting: Schema.optional<Schema.Struct<{
+        readonly kind: Schema.Literal<"api-bible-fums">;
+        readonly token: Schema.NonEmptyString;
+    }>>;
+    readonly cache: Schema.optional<Schema.Struct<{
+        readonly expiresAt: Schema.Number;
+    }>>;
+    readonly licenses: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.optional<Schema.String>;
+        readonly url: Schema.String;
+        readonly restrictions: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Boolean, Schema.String]>>>;
+    }>>;
+    readonly numbering: Schema.Literals<readonly ["kjv", "unknown"]>;
+    readonly sourceLimitations: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.Literal<"source-trimming">;
+        readonly startPassageId: Schema.NonEmptyString;
+        readonly endPassageId: Schema.NonEmptyString;
+        readonly appliesToRequest: Schema.Boolean;
+    }>>>;
+    readonly display: Schema.Struct<{
+        readonly format: Schema.Literal<"text">;
+        readonly whitespace: Schema.Literal<"pre-wrap">;
+        readonly attributionPlacement: Schema.Literal<"after-passage">;
+        readonly direction: Schema.optional<Schema.Literals<readonly ["ltr", "rtl"]>>;
+        readonly language: Schema.optional<Schema.String>;
+        readonly nativeHtml: Schema.optional<Schema.Struct<{
+            readonly containerAttributes: Schema.$Record<Schema.String, Schema.String>;
+            readonly stylesheets: Schema.$Array<Schema.Struct<{
+                readonly kind: Schema.Literals<readonly ["bible", "font"]>;
+                readonly href: Schema.String;
+            }>>;
+        }>>;
+    }>;
+    readonly instructions: Schema.$Array<Schema.Struct<{
+        readonly code: Schema.NonEmptyString;
+        readonly level: Schema.Literals<readonly ["required", "recommended", "notice"]>;
+        readonly appliesTo: Schema.Literals<readonly ["all", "text", "html"]>;
+        readonly text: Schema.NonEmptyString;
+        readonly urls: Schema.optional<Schema.$Array<Schema.String>>;
+    }>>;
+}>;
+export type ScripturePassage = typeof ScripturePassage.Type;
+/** Data capabilities are separate from the existing custom display-provider contract. */
+export interface BibleDataProvider {
+    readonly id: string;
+    readonly defaultVersionId: string;
+    /** Discovery cache lifetime. Omitted preserves the existing unbounded lifetime. */
+    readonly cacheTimeToLive?: Duration.Input;
+    listVersions(): Effect.Effect<BibleVersion[], ScriptureError>;
+    listBooks(versionId: string): Effect.Effect<BibleBook[], ScriptureError>;
+    listChapters(versionId: string, bookId: string): Effect.Effect<BibleChapter[], ScriptureError>;
+    getPassageData(versionId: string, passageId: string): Effect.Effect<ScripturePassage, ScriptureError>;
+    readonly clearCache: Effect.Effect<void>;
+}
+export interface BibleDisplayProvider extends BibleDataProvider {
+    getPassageDisplay(versionId: string, passageId: string): Effect.Effect<PassageDisplay, ScriptureError>;
+}
+declare const BibleSource_base: Context.ServiceClass<BibleSource, "@faith-tools/scripture-inline/data/BibleSource", BibleDataProvider>;
+export declare class BibleSource extends BibleSource_base {
+}
+export declare const ScriptureErrorCode: Schema.Literals<readonly ["invalid_reference", "unavailable", "unsupported", "authentication", "rate_limit", "network", "timeout", "invalid_response"]>;
+export type ScriptureErrorCode = typeof ScriptureErrorCode.Type;
+declare const ScriptureError_base: Schema.Class<ScriptureError, Schema.TaggedStruct<"ScriptureError", {
+    readonly code: Schema.Literals<readonly ["invalid_reference", "unavailable", "unsupported", "authentication", "rate_limit", "network", "timeout", "invalid_response"]>;
+    readonly message: Schema.String;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class ScriptureError extends ScriptureError_base {
+    get retryable(): boolean;
+}
+export {};

package/dist/types/data.d.ts

@@ -0,0 +1,102 @@
+import { createScriptureClient as createEffectClient } from "./data-effect.js";
+export { ScriptureError } from "./data-types.js";
+export type { BibleBook, BibleChapter, BibleVersion, DisplayInstruction, ScriptureErrorCode, ScripturePassage } from "./data-types.js";
+/** Async/await boundary over the same validated Effect operations and caches. */
+export declare function createScriptureClient(options?: Parameters<typeof createEffectClient>[0]): {
+    provider: string;
+    listVersions: () => Promise<readonly {
+        readonly id: string;
+        readonly abbreviation: string;
+        readonly title: string;
+        readonly language?: string | undefined;
+        readonly languageName?: string | undefined;
+    }[]>;
+    listBooks: (options?: {
+        versionId?: string;
+    }) => Promise<readonly {
+        readonly id: string;
+        readonly title: string;
+    }[]>;
+    listChapters: (options: {
+        versionId?: string;
+        bookId: string;
+    }) => Promise<readonly {
+        readonly passageId: string;
+        readonly number: number;
+    }[]>;
+    getPassage: (options: {
+        versionId?: string;
+        passageId: string;
+    }) => Promise<{
+        readonly provider: string;
+        readonly source: {
+            readonly url: string;
+            readonly versionId: string;
+        };
+        readonly requestedPassageId: string;
+        readonly passageId: string;
+        readonly reference: string;
+        readonly text: string;
+        readonly version: {
+            readonly id: string;
+            readonly abbreviation: string;
+            readonly title: string;
+            readonly language?: string | undefined;
+            readonly languageName?: string | undefined;
+            readonly sourceLanguage?: string | undefined;
+        };
+        readonly attribution: {
+            readonly text: string;
+            readonly urls: readonly string[];
+        };
+        readonly publisher?: {
+            readonly copyrightHtml: string;
+            readonly infoHtml: string;
+        } | undefined;
+        readonly reporting?: {
+            readonly kind: "api-bible-fums";
+            readonly token: string;
+        } | undefined;
+        readonly cache?: {
+            readonly expiresAt: number;
+        } | undefined;
+        readonly licenses: readonly {
+            readonly name?: string | undefined;
+            readonly url: string;
+            readonly restrictions?: {
+                readonly [x: string]: string | boolean;
+            } | undefined;
+        }[];
+        readonly numbering: "kjv" | "unknown";
+        readonly sourceLimitations?: readonly {
+            readonly kind: "source-trimming";
+            readonly startPassageId: string;
+            readonly endPassageId: string;
+            readonly appliesToRequest: boolean;
+        }[] | undefined;
+        readonly display: {
+            readonly format: "text";
+            readonly whitespace: "pre-wrap";
+            readonly attributionPlacement: "after-passage";
+            readonly direction?: "ltr" | "rtl" | undefined;
+            readonly language?: string | undefined;
+            readonly nativeHtml?: {
+                readonly containerAttributes: {
+                    readonly [x: string]: string;
+                };
+                readonly stylesheets: readonly {
+                    readonly kind: "bible" | "font";
+                    readonly href: string;
+                }[];
+            } | undefined;
+        };
+        readonly instructions: readonly {
+            readonly code: string;
+            readonly level: "notice" | "recommended" | "required";
+            readonly appliesTo: "all" | "html" | "text";
+            readonly text: string;
+            readonly urls?: readonly string[] | undefined;
+        }[];
+    }>;
+    clearCache: () => Promise<void>;
+};

package/dist/types/dom-runtime.d.ts

@@ -0,0 +1,5 @@
+import { Effect } from "effect";
+/** DOM resources live in the caller's Scope, not in detached event callbacks. */
+export declare const listen: (target: EventTarget, type: string, listener: EventListener, options?: AddEventListenerOptions | boolean) => Effect.Effect<void, never, import("effect/Scope").Scope>;
+export declare const nextFrame: Effect.Effect<void, never, never>;
+export declare const waitForEvent: (target: EventTarget, types: readonly string[]) => Effect.Effect<void, never, never>;

package/dist/types/find.d.ts

@@ -0,0 +1,12 @@
+import { type ParsedPassage } from "grab-bcv";
+export type FoundReference = {
+    /** Offset of the first character of the reference in the scanned text. */
+    start: number;
+    /** Offset just past the last character of the reference. */
+    end: number;
+    /** The reference exactly as written, such as "1 Cor. 13:4-7". */
+    text: string;
+    passage: ParsedPassage;
+};
+/** Finds every Bible reference in `text`, in order, with its exact position. */
+export declare function findReferences(text: string): FoundReference[];

package/dist/types/index.d.ts

@@ -0,0 +1,31 @@
+import type { ReferenceLayout } from "./scripture-passage";
+import type { ProviderOptions } from "./providers";
+export { findReferences, type FoundReference } from "./find";
+export { unwrapReferences, wrapReferences } from "./scan";
+export { createScriptureCard } from "./card";
+export { BIBLE_PASSAGE_INPUT_TAG, PASSAGE_INPUT_TAG, ScripturePassageInput, definePassageInput, type PassageInputDetail } from "./passage-input";
+export { BIBLE_VERSION_INPUT_TAG, VERSION_INPUT_TAG, ScriptureVersionInput, defineVersionInput, type VersionInputDetail } from "./version-input";
+export { BIBLE_PASSAGE_TAG, SCRIPTURE_PASSAGE_TAG, ScripturePassage, defineScripturePassage, type ReferenceLayout } from "./scripture-passage";
+export { helloaoProvider, createYouVersionProvider, listBibleVersions, type BibleProvider, type BibleVersion, type PassageDisplay, type ProviderOptions } from "./providers";
+export type Mode = "link" | "card";
+export type Trigger = "click" | "hover";
+export type ScriptureInlineOptions = ProviderOptions & {
+    /** "link" opens route.bible. "card" shows the passage in a card. Default: "card". */
+    mode?: Mode;
+    /** What opens a card: "click", or "hover" with a mouse (taps and clicks still work). Default: "click". */
+    trigger?: Trigger;
+    /** Where a card shows the reference: "heading", "citation", "quote", or "none". Default: "heading". */
+    reference?: ReferenceLayout;
+    /** Where to look for references. Default: the whole page, including a body that replaces it. */
+    root?: Node;
+    /** Keep linking references in content added later, such as pages swapped in by Turbo or a router. Default: true. */
+    watch?: boolean;
+};
+export type ScriptureInline = {
+    /** The links that replaced each reference. */
+    links: HTMLAnchorElement[];
+    /** Closes any card, removes the listeners, and turns the links back into plain text. */
+    stop(): void;
+};
+/** Finds Bible references on the page and makes them interactive. */
+export declare function scriptureInline({ mode, trigger, reference, root, watch, ...providerOptions }?: ScriptureInlineOptions): ScriptureInline;

package/dist/types/passage-input.d.ts

@@ -0,0 +1,57 @@
+export declare const PASSAGE_INPUT_TAG = "si-passage-input";
+export declare const BIBLE_PASSAGE_INPUT_TAG = "bible-sk-passage-input";
+export type BookOrder = "canonical" | "alphabetical";
+export type PassageInputDetail = {
+    passageId: string;
+    label: string;
+};
+/**
+ * A text input for a Bible passage. Typing "Roman 8" suggests Romans 8, and the element's
+ * `value` is the passage ID, such as "ROM.8" or "ROM.8.28-30". It submits with a form under
+ * `name`, and fires `change` with `detail: { passageId, label }` when the passage changes.
+ * Parts: `input`, `listbox`, `option`, `count`.
+ */
+export declare class ScripturePassageInput extends HTMLElement {
+    static formAssociated: boolean;
+    static observedAttributes: string[];
+    private readonly internals;
+    private readonly input;
+    private readonly list;
+    private suggestions;
+    private active;
+    private committed;
+    constructor();
+    connectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    /** The passage ID, such as "ROM.8.28-30", or "" when the field is empty or not a passage. */
+    get value(): string;
+    set value(value: string);
+    get form(): HTMLFormElement | null;
+    get validity(): ValidityState;
+    get validationMessage(): string;
+    checkValidity(): boolean;
+    reportValidity(): boolean;
+    focus(options?: FocusOptions): void;
+    formResetCallback(): void;
+    formDisabledCallback(disabled: boolean): void;
+    /** Parses `text`. A passage replaces the text with its display form, such as "Romans 8". */
+    private commit;
+    /** "canonical" (default) lists books Genesis to Revelation; "alphabetical" lists them A to Z. */
+    get bookOrder(): BookOrder;
+    /** The options for the text typed so far, from the broadest choice to the narrowest. */
+    private options;
+    private suggest;
+    private highlight;
+    private close;
+    /** A book fills in its name and keeps typing going; a chapter or verse is a full passage. */
+    private accept;
+    private onKeydown;
+}
+/** Register once in a browser entry point. Importing this module does not register it. */
+export declare function definePassageInput(): void;
+declare global {
+    interface HTMLElementTagNameMap {
+        "si-passage-input": ScripturePassageInput;
+        "bible-sk-passage-input": ScripturePassageInput;
+    }
+}

package/dist/types/providers/api-bible.d.ts

@@ -0,0 +1,37 @@
+import { type BibleDataProvider } from "../data-types.js";
+declare const rendering: {
+    readonly contentType: "json";
+    readonly includeTitles: true;
+    readonly includeNotes: false;
+    readonly includeChapterNumbers: false;
+    readonly includeVerseNumbers: false;
+};
+/** The official createBibleClient result satisfies this structural contract. */
+export interface ApiBibleClient {
+    bibles: {
+        list(params: {
+            includeFullDetails: boolean;
+        }, signal?: AbortSignal): Promise<unknown>;
+        get(id: string, signal?: AbortSignal): Promise<unknown>;
+    };
+    books: {
+        list(id: string, params: undefined, signal?: AbortSignal): Promise<unknown>;
+    };
+    chapters: {
+        list(id: string, book: string, signal?: AbortSignal): Promise<unknown>;
+        get(id: string, chapter: string, params: typeof rendering, signal?: AbortSignal): Promise<unknown>;
+    };
+    passages: {
+        get(id: string, passage: string, params: typeof rendering, signal?: AbortSignal): Promise<unknown>;
+    };
+}
+/**
+ * Server-only, data-only adapter. Each application supplies its own official SDK
+ * client, configured with its private key and retry: { maxAttempts: 1 }.
+ * Fetching does not report a display. The host must report every actual web view.
+ */
+export declare function createApiBibleProvider({ client, defaultVersionId }: {
+    client: ApiBibleClient;
+    defaultVersionId: string;
+}): BibleDataProvider;
+export {};

package/dist/types/providers/fetch-bible.d.ts

@@ -0,0 +1,14 @@
+import { type BibleDisplayProvider } from "../data-types.js";
+import type { BibleProvider } from "../providers.js";
+export type FetchBibleOptions = {
+    /** Explicitly declare commercial use; the upstream default is noncommercial. */
+    usage: {
+        commercial: boolean;
+        attributionless?: boolean;
+        limitless?: boolean;
+        derivatives?: boolean | "same-license";
+    };
+};
+export declare function createFetchBibleProvider(options: FetchBibleOptions): BibleProvider & {
+    readonly effects: BibleDisplayProvider;
+};

package/dist/types/providers/helloao.d.ts

@@ -0,0 +1 @@
+export { createHelloAOProvider, helloaoProvider } from "../providers.js";

package/dist/types/providers/youversion.d.ts

@@ -0,0 +1 @@
+export { createYouVersionProvider } from "../providers.js";