astro-lilypond 0.17.0 → 1.0.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import type { AstroIntegration } from "astro";
 import { type AstroComponentFactory } from "astro/runtime/server/index.js";
-import type { AutoInstallOptions } from "./binary/index.js";
+import { type AutoInstallOptions } from "./binary/index.js";
 import { type PluginOptions } from "./plugins/index.js";
 import { type LilypondDefaults } from "./render.js";
 import { type LilypondMetadata } from "./utils/index.js";
@@ -23,10 +23,10 @@ export interface LilypondScore {
     assetTitle: string;
     meta: LilypondMetadata;
 }
-export interface RenderOptions {
+export interface GetScoreOptions {
     /**
      * Output format for `Score`.
-     * @default "svg"
+     * @default the `defaults.format` configured on the integration ("svg" unless overridden)
      */
     format?: "svg" | "png";
     /**
@@ -47,9 +47,9 @@ export interface LilypondImageResult {
 export interface LilypondPdfResult {
     src: string;
 }
-export interface RenderResult {
+export interface GetScoreResult {
     Score: AstroComponentFactory;
-    pageCount: number;
+    pages: LilypondPage[];
     pdf?: LilypondPdfResult;
     meta: LilypondMetadata;
     raw: string;
@@ -64,35 +64,21 @@ interface ScoreImageProps {
  * Renders a `LilypondScore` (from a `.ly`/`.ily`/`.lilypond` import,
  * or a `lilypondLoader()` entry) to a renderable `<Score />` component.
  */
-export declare function render(score: LilypondScore, options?: RenderOptions): Promise<RenderResult>;
-export interface ScoreProps extends ScoreImageProps {
+export declare function getScore(score: LilypondScore, options?: GetScoreOptions): Promise<GetScoreResult>;
+export interface ScoreProps extends ScoreImageProps, Pick<GetScoreOptions, "format" | "crop"> {
     /**
      * A `LilypondScore` from a `.ly`/`.ily`/`.lilypond` import
      * or a `lilypondLoader()` entry.
      */
     content: LilypondScore;
-    /**
-     * @default "svg"
-     */
-    format?: "svg" | "png";
-    /**
-     * @default false
-     */
-    crop?: boolean;
 }
 /**
  * Renders a `LilypondScore` directly, for the common case where none of
- * `render()`'s `pageCount`, `meta`, `raw`, or `pdf` are needed. Use
- * `render()` instead when you need those.
+ * `getScore()`'s `pages`, `meta`, `raw`, or `pdf` are needed. Use
+ * `getScore()` instead when you need those.
  */
 export declare const Score: AstroComponentFactory;
-export declare function renderAll(scores: LilypondScore[], options?: RenderOptions): Promise<RenderResult[]>;
 export interface LilypondOptions extends PluginOptions {
-    /**
-     * Output format used by Markdown fences and `lilypondLoader()` entries.
-     * @default "svg"
-     */
-    format?: "svg" | "png";
     /**
      * Defaults passed to each score; can be overridden at render time.
      */

package/dist/index.js

@@ -1,8 +1,9 @@
 import { createComponent, renderComponent, renderTemplate, unescapeHTML, } from "astro/runtime/server/index.js";
 import emitAssetIntegration from "astro-emit-asset";
+import { resolveAutoInstallOption, resolveLilypondBinary, } from "./binary/index.js";
 import { remarkPlugin, satteriPlugin, } from "./plugins/index.js";
-import { render as renderScore } from "./render.js";
-import { getRenderState, resolveAndSetRenderState } from "./renderState.js";
+import { render } from "./render.js";
+import { getLilypondState, setLilypondState } from "./state.js";
 import { altTextFor, emitLilypondAsset, emitLilypondPdfAsset, includePathsFor, lyTypeDeclarationsFor, parseLyHeaderFields, prependVersion, renderedErrorHtml, renderedHtml, resolveDefaults, sourceNameFor, titleFor, toLilypondMetadata, } from "./utils/index.js";
 export const LY_EXTENSIONS = [".ly", ".lilypond", ".ily"];
 function createScoreComponent(content) {
@@ -17,7 +18,7 @@ function createScoreComponent(content) {
     });
 }
 /**
- * Dev-only fallback for `render()`: renders an inline error block
+ * Dev-only fallback for `getScore()`: renders an inline error block
  * instead of the score.
  */
 function createErrorScoreComponent(error, title) {
@@ -29,13 +30,14 @@ function createErrorScoreComponent(error, title) {
  * Renders a `LilypondScore` (from a `.ly`/`.ily`/`.lilypond` import,
  * or a `lilypondLoader()` entry) to a renderable `<Score />` component.
  */
-export async function render(score, options = {}) {
-    const state = getRenderState();
-    const { resolution, cropScale } = resolveDefaults(state.defaults);
-    const format = options.format ?? "svg";
+export async function getScore(score, options = {}) {
+    const state = getLilypondState();
+    const { logger } = state;
+    const { resolution, cropScale, format: defaultFormat, } = resolveDefaults(state.defaults);
+    const format = options.format ?? defaultFormat;
     const crop = options.crop ?? false;
     try {
-        const [{ Score, pageCount }, pdf] = await Promise.all([
+        const [{ Score, pages }, pdf] = await Promise.all([
             (async () => {
                 const pages = await emitLilypondAsset({
                     title: score.assetTitle,
@@ -45,7 +47,7 @@ export async function render(score, options = {}) {
                     crop,
                     sizeScale: crop ? cropScale : 1,
                     binaryPath: state.binaryPath,
-                    render: () => renderScore(score.source, {
+                    render: () => render(score.source, {
                         format,
                         crop,
                         defaults: state.defaults,
@@ -53,12 +55,12 @@ export async function render(score, options = {}) {
                         binaryPath: state.binaryPath,
                         includePaths: score.includePaths,
                         sourceName: score.sourceName,
-                        logger: state.logger,
+                        logger,
                     }),
                 });
                 return {
                     Score: createScoreComponent({ pages, alt: score.alt }),
-                    pageCount: pages.length,
+                    pages,
                 };
             })(),
             options.pdf
@@ -66,7 +68,7 @@ export async function render(score, options = {}) {
                     title: score.assetTitle,
                     source: score.source,
                     binaryPath: state.binaryPath,
-                    render: () => renderScore(score.source, {
+                    render: () => render(score.source, {
                         format: "pdf",
                         crop: false,
                         defaults: state.defaults,
@@ -74,19 +76,19 @@ export async function render(score, options = {}) {
                         binaryPath: state.binaryPath,
                         includePaths: score.includePaths,
                         sourceName: score.sourceName,
-                        logger: state.logger,
+                        logger,
                     }),
                 })
                 : Promise.resolve(undefined),
         ]);
-        return { Score, pageCount, pdf, meta: score.meta, raw: score.source };
+        return { Score, pages, pdf, meta: score.meta, raw: score.source };
     }
     catch (err) {
         if (!state.isDev)
             throw err;
         return {
             Score: createErrorScoreComponent(err, score.assetTitle),
-            pageCount: 0,
+            pages: [],
             pdf: undefined,
             meta: score.meta,
             raw: score.source,
@@ -95,17 +97,14 @@ export async function render(score, options = {}) {
 }
 /**
  * Renders a `LilypondScore` directly, for the common case where none of
- * `render()`'s `pageCount`, `meta`, `raw`, or `pdf` are needed. Use
- * `render()` instead when you need those.
+ * `getScore()`'s `pages`, `meta`, `raw`, or `pdf` are needed. Use
+ * `getScore()` instead when you need those.
  */
 export const Score = createComponent(async (result, props) => {
     const { content, format, crop, ...imageProps } = props;
-    const { Score: ContentScore } = await render(content, { format, crop });
+    const { Score: ContentScore } = await getScore(content, { format, crop });
     return renderTemplate `${renderComponent(result, "Score", ContentScore, imageProps)}`;
 });
-export async function renderAll(scores, options = {}) {
-    return Promise.all(scores.map((score) => render(score, options)));
-}
 function lyFilePlugin(options) {
     return {
         name: "vite-plugin-astro-lilypond-ly",
@@ -142,8 +141,14 @@ export default function lilypond(options = {}) {
                 const isDev = command === "dev";
                 options.isDev = isDev;
                 options.logger = logger;
-                options.binaryPath = await resolveAndSetRenderState({
-                    autoInstall: options.autoInstall,
+                const binaryPath = await resolveLilypondBinary({
+                    ...resolveAutoInstallOption(options.autoInstall),
+                    log: (message) => logger.info(message),
+                    warn: (message) => logger.warn(message),
+                });
+                options.binaryPath = binaryPath;
+                setLilypondState({
+                    binaryPath,
                     defaults: options.defaults,
                     timeout: options.timeout,
                     isDev,

package/dist/loader.js

@@ -3,7 +3,7 @@ import { join, relative, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { z } from "astro/zod";
 import { LY_EXTENSIONS } from "./index.js";
-import { getRenderState } from "./renderState.js";
+import { getLilypondState } from "./state.js";
 import { altTextFor, includePathsFor, parseLyHeaderFields, prependVersion, resolveDefaults, sourceNameFor, titleFor, toLilypondMetadata, } from "./utils/index.js";
 const DEFAULT_PATTERN = `**/*.{${LY_EXTENSIONS.map((ext) => ext.slice(1)).join(",")}}`;
 // Field names must match `LilypondMetadata` in `utils/lilypondMetadata.ts`.
@@ -62,7 +62,7 @@ export function lilypondLoader({ pattern = DEFAULT_PATTERN, base, generateId = d
         schema: lilypondEntrySchema,
         async load(context) {
             const { config, store, logger, watcher, generateDigest, parseData } = context;
-            const { version } = resolveDefaults(getRenderState().defaults);
+            const { version } = resolveDefaults(getLilypondState().defaults);
             const rootDir = fileURLToPath(config.root);
             const baseUrl = resolveBaseUrl(base, config.root);
             const baseDir = fileURLToPath(baseUrl);

package/dist/plugins/remark.js

@@ -1,11 +1,12 @@
 import { visit } from "unist-util-visit";
-import { defaultOptions, render } from "../render.js";
-import { altTextForBlock, emitLilypondAsset, includePathsFor, isLilypondLang, prependVersion, renderedErrorHtml, renderedHtml, resolveDefaults, sourceNameFor, titleFor, } from "../utils/index.js";
+import { includePathsFor, isLilypondLang, sourceNameFor, titleFor, } from "../utils/index.js";
+import { renderMarkdownBlock } from "./renderMarkdownBlock.js";
 export const remarkPlugin = (options) => {
     const { logger } = options;
     if (!logger) {
         throw new Error("astro-lilypond: please add the `lilypond()` integration to your Astro config.");
     }
+    const renderOptions = { ...options, logger };
     return async (tree, file) => {
         const promises = [];
         const includePaths = includePathsFor(file?.path);
@@ -14,42 +15,16 @@ export const remarkPlugin = (options) => {
         visit(tree, "code", (node, index, parent) => {
             if (!isLilypondLang(node.lang) || index === undefined || !parent)
                 return;
-            const { version, resolution, cropScale } = resolveDefaults(options.defaults);
-            const source = version ? prependVersion(node.value, version) : node.value;
-            const format = options.format ?? defaultOptions.format;
-            const alt = altTextForBlock(node.meta, node.value);
-            const promise = (async () => {
-                let value;
-                try {
-                    const pages = await emitLilypondAsset({
-                        title,
-                        format,
-                        source,
-                        resolution,
-                        crop: true,
-                        sizeScale: cropScale,
-                        binaryPath: options.binaryPath,
-                        render: () => render(source, {
-                            format,
-                            crop: true,
-                            defaults: options.defaults,
-                            timeout: options.timeout,
-                            binaryPath: options.binaryPath,
-                            includePaths,
-                            sourceName,
-                            logger,
-                        }),
-                    });
-                    value = renderedHtml(pages, alt);
-                }
-                catch (err) {
-                    if (!options.isDev)
-                        throw err;
-                    value = renderedErrorHtml(err, title);
-                }
+            const promise = renderMarkdownBlock(renderOptions, {
+                title,
+                value: node.value,
+                meta: node.meta,
+                includePaths,
+                sourceName,
+            }).then((value) => {
                 const htmlNode = { type: "html", value };
                 parent.children[index] = htmlNode;
-            })();
+            });
             promises.push(promise);
         });
         await Promise.all(promises);

package/dist/plugins/renderMarkdownBlock.d.ts

@@ -0,0 +1,17 @@
+import type { PluginOptions } from "./types.js";
+export interface MarkdownBlock {
+    title: string;
+    value: string;
+    meta: string | null | undefined;
+    includePaths: string[];
+    sourceName: string | undefined;
+}
+/**
+ * Renders one fenced ```lilypond block to HTML. Shared by the remark and
+ * satteri plugins. `logger` is required here (unlike `PluginOptions`) since
+ * each plugin's registration-time "add the integration" guard already
+ * narrowed it before calling this.
+ */
+export declare function renderMarkdownBlock(options: Omit<PluginOptions, "logger"> & {
+    logger: NonNullable<PluginOptions["logger"]>;
+}, block: MarkdownBlock): Promise<string>;

package/dist/plugins/renderMarkdownBlock.js

@@ -0,0 +1,42 @@
+import { render } from "../render.js";
+import { altTextForBlock, emitLilypondAsset, prependVersion, renderedErrorHtml, renderedHtml, resolveDefaults, } from "../utils/index.js";
+/**
+ * Renders one fenced ```lilypond block to HTML. Shared by the remark and
+ * satteri plugins. `logger` is required here (unlike `PluginOptions`) since
+ * each plugin's registration-time "add the integration" guard already
+ * narrowed it before calling this.
+ */
+export async function renderMarkdownBlock(options, block) {
+    const { logger } = options;
+    const { title } = block;
+    const { version, format, resolution, cropScale } = resolveDefaults(options.defaults);
+    const source = version ? prependVersion(block.value, version) : block.value;
+    const alt = altTextForBlock(block.meta, block.value);
+    try {
+        const pages = await emitLilypondAsset({
+            title,
+            format,
+            source,
+            resolution,
+            crop: true,
+            sizeScale: cropScale,
+            binaryPath: options.binaryPath,
+            render: () => render(source, {
+                format,
+                crop: true,
+                defaults: options.defaults,
+                timeout: options.timeout,
+                binaryPath: options.binaryPath,
+                includePaths: block.includePaths,
+                sourceName: block.sourceName,
+                logger,
+            }),
+        });
+        return renderedHtml(pages, alt);
+    }
+    catch (err) {
+        if (!options.isDev)
+            throw err;
+        return renderedErrorHtml(err, title);
+    }
+}

package/dist/plugins/satteri.js

@@ -1,49 +1,25 @@
-import { defaultOptions, render } from "../render.js";
-import { altTextForBlock, emitLilypondAsset, includePathsFor, isLilypondLang, prependVersion, renderedErrorHtml, renderedHtml, resolveDefaults, sourceNameFor, titleFor, } from "../utils/index.js";
+import { includePathsFor, isLilypondLang, sourceNameFor, titleFor, } from "../utils/index.js";
+import { renderMarkdownBlock } from "./renderMarkdownBlock.js";
 export function satteriPlugin(options) {
     const { logger } = options;
     if (!logger) {
         throw new Error("astro-lilypond: please add the `lilypond()` integration to your Astro config.");
     }
+    const renderOptions = { ...options, logger };
     return {
         name: "astro-lilypond",
         async code(node, ctx) {
             if (!isLilypondLang(node.lang))
                 return undefined;
-            const { version, resolution, cropScale } = resolveDefaults(options.defaults);
-            const source = version ? prependVersion(node.value, version) : node.value;
-            const format = options.format ?? defaultOptions.format;
-            const includePaths = includePathsFor(ctx.fileURL);
             const sourceName = sourceNameFor(ctx.fileURL);
-            const title = titleFor(sourceName);
-            const alt = altTextForBlock(node.meta, node.value);
-            try {
-                const pages = await emitLilypondAsset({
-                    title,
-                    format,
-                    source,
-                    resolution,
-                    crop: true,
-                    sizeScale: cropScale,
-                    binaryPath: options.binaryPath,
-                    render: () => render(source, {
-                        format,
-                        crop: true,
-                        defaults: options.defaults,
-                        timeout: options.timeout,
-                        binaryPath: options.binaryPath,
-                        includePaths,
-                        sourceName,
-                        logger,
-                    }),
-                });
-                return { rawHtml: renderedHtml(pages, alt) };
-            }
-            catch (err) {
-                if (!options.isDev)
-                    throw err;
-                return { rawHtml: renderedErrorHtml(err, title) };
-            }
+            const rawHtml = await renderMarkdownBlock(renderOptions, {
+                title: titleFor(sourceName),
+                value: node.value,
+                meta: node.meta,
+                includePaths: includePathsFor(ctx.fileURL),
+                sourceName,
+            });
+            return { rawHtml };
         },
     };
 }

package/dist/plugins/types.d.ts

@@ -1,7 +1,6 @@
 import type { AstroIntegrationLogger } from "astro";
 import type { LilypondDefaults } from "../render.js";
 export interface PluginOptions {
-    format?: "svg" | "png";
     defaults?: LilypondDefaults;
     timeout?: number;
     binaryPath?: string;

package/dist/render.d.ts

@@ -12,6 +12,11 @@ export interface LilypondDefaults {
      * @default "2.26.0"
      */
     version?: LilypondVersion;
+    /**
+     * Output format.
+     * @default "svg"
+     */
+    format?: "svg" | "png";
     /**
      * Resolution in DPI (only applies to PNG).
      * @default 144
@@ -29,10 +34,9 @@ export interface LilypondDefaults {
 }
 /**
  * The subset of `LilypondDefaults` that `render()` itself reads. `version`
- * is resolved by the caller before reaching `render()`, by prepending it to
- * source text.
+ * and `format` are resolved by the caller before reaching `render()`.
  */
-export type RenderDefaults = Omit<LilypondDefaults, "version">;
+export type RenderDefaults = Omit<LilypondDefaults, "version" | "format">;
 export interface InternalRenderOptions {
     /**
      * Output format.

package/dist/render.js

@@ -5,16 +5,18 @@ import { execLilyPond } from "./execLilyPond.js";
 import { readOutputFile, safeInputFileName } from "./readOutputFile.js";
 import { resolveDefaults } from "./utils/resolveDefaults.js";
 export const FORMATS = ["png", "svg", "pdf"];
-export const defaultOptions = {
+const defaultLilypondDefaults = {
+    version: "2.26.0",
     format: "svg",
+    resolution: 144,
+    cropScale: 1.5,
+};
+export const defaultOptions = {
+    format: defaultLilypondDefaults.format,
     crop: true,
     binaryPath: "lilypond",
     timeout: 60_000,
-    defaults: {
-        version: "2.26.0",
-        resolution: 144,
-        cropScale: 1.5,
-    },
+    defaults: defaultLilypondDefaults,
 };
 export async function render(source, options) {
     const { format = defaultOptions.format, crop = defaultOptions.crop, binaryPath = defaultOptions.binaryPath, timeout = defaultOptions.timeout, includePaths = [], sourceName, logger, } = options;

package/dist/state.d.ts

@@ -0,0 +1,12 @@
+import type { AstroIntegrationLogger } from "astro";
+import type { LilypondDefaults } from "./render.js";
+export interface LilypondState {
+    binaryPath: string;
+    defaults: LilypondDefaults | undefined;
+    timeout: number | undefined;
+    isDev: boolean;
+    logger: Pick<AstroIntegrationLogger, "warn" | "error">;
+}
+export declare function setLilypondState(state: LilypondState): void;
+export declare function getLilypondState(): LilypondState;
+export declare function resetLilypondStateForTests(): void;

package/dist/state.js

@@ -0,0 +1,15 @@
+const KEY = "astro-lilypond:state";
+const store = globalThis;
+export function setLilypondState(state) {
+    store[KEY] = state;
+}
+export function getLilypondState() {
+    const state = store[KEY];
+    if (!state) {
+        throw new Error("astro-lilypond: please add the `lilypond()` integration to your Astro config.");
+    }
+    return state;
+}
+export function resetLilypondStateForTests() {
+    store[KEY] = undefined;
+}

package/dist/utils/renderedErrorHtml.js

@@ -1,12 +1,18 @@
 import { escapeHtml } from "./escapeHtml.js";
-const ERROR_STYLE = "all: initial; display: block; margin: 1em 0; padding: 1em; " +
-    "color-scheme: light dark; " +
-    "border: 2px solid light-dark(#dc2626, #f87171); border-radius: 6px; " +
-    "background: light-dark(#fef2f2, #450a0a); " +
-    "color: light-dark(#7f1d1d, #fca5a5); " +
-    "font-family: ui-monospace, monospace; " +
-    "font-size: 0.875rem; line-height: 1.5; white-space: pre-wrap; " +
-    "overflow-wrap: break-word; text-align: left;";
+const ERROR_STYLE = `display: block;
+   margin: 1em 0;
+   padding: 1em;
+   color-scheme: light dark;
+   border: 2px solid light-dark(#dc2626, #f87171);
+   border-radius: 6px;
+   background: light-dark(#fef2f2, #450a0a);
+   color: light-dark(#5d1516, #fcd1d2);
+   font-family: ui-monospace, monospace;
+   font-size: 0.875rem;
+   line-height: 1.5;
+   white-space: pre-wrap;
+   overflow-wrap: break-word;
+   text-align: left;`;
 function messageFor(error) {
     return error instanceof Error ? error.message : String(error);
 }

package/dist/utils/resolveDefaults.js

@@ -1,9 +1,10 @@
 import { defaultOptions } from "../render.js";
 /** Fills in any `defaults` fields left unset with `render.ts`'s own defaults. */
 export function resolveDefaults(defaults) {
-    const { version, resolution, cropScale } = defaultOptions.defaults;
+    const { version, format, resolution, cropScale } = defaultOptions.defaults;
     return {
         version: defaults?.version ?? version,
+        format: defaults?.format ?? format,
         resolution: defaults?.resolution ?? resolution,
         cropScale: defaults?.cropScale ?? cropScale,
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro-lilypond",
-  "version": "0.17.0",
+  "version": "1.0.0",
   "description": "An Astro integration for rendering Lilypond markup to music notation.",
   "homepage": "https://lilypond.ky.fyi",
   "author": "Ky Decker",
@@ -67,8 +67,7 @@
   },
   "scripts": {
     "build": "tsc --project tsconfig.build.json",
-    "test": "vitest --project unit",
-    "test:coverage": "vitest run --project unit --coverage",
-    "test:integration": "vitest run --project integration"
+    "test": "vitest",
+    "test:coverage": "vitest run --coverage"
   }
 }

package/dist/renderState.d.ts

@@ -1,30 +0,0 @@
-import type { AstroIntegrationLogger } from "astro";
-import { type AutoInstallOptions } from "./binary/index.js";
-import type { LilypondDefaults } from "./render.js";
-export interface RenderState {
-    binaryPath: string;
-    defaults: LilypondDefaults | undefined;
-    timeout: number | undefined;
-    isDev: boolean;
-    logger: Pick<AstroIntegrationLogger, "warn" | "error">;
-}
-/** Called by the `lilypond()` integration's `astro:config:setup` hook. */
-export declare function setRenderState(next: RenderState): void;
-/** Read by the public `render()`, called from user code rather than the integration's own closures. */
-export declare function getRenderState(): RenderState;
-/** Test-only: resets the shared singleton between test cases. */
-export declare function resetRenderStateForTests(): void;
-export interface ResolveAndSetRenderStateOptions {
-    autoInstall?: boolean | AutoInstallOptions;
-    defaults?: LilypondDefaults;
-    timeout?: number;
-    isDev: boolean;
-    logger: Pick<AstroIntegrationLogger, "info" | "warn" | "error">;
-}
-/**
- * Shared by the `lilypond()` integration's `astro:config:setup` hook and
- * `lilypondLoader()`'s `load()`: resolves the `lilypond` binary and
- * populates the render state from it. Returns the resolved binary path for
- * callers (e.g. Markdown plugins) that also need it directly.
- */
-export declare function resolveAndSetRenderState(options: ResolveAndSetRenderStateOptions): Promise<string>;

package/dist/renderState.js

@@ -1,48 +0,0 @@
-import { resolveAutoInstallOption, resolveLilypondBinary, } from "./binary/index.js";
-/**
- * Keyed on `globalThis` rather than module-scope state — some Astro adapters
- * bundle the render step as a separate chunk with its own copy of this
- * module, so a plain module `let` wouldn't survive from
- * `astro:config:setup` into an actual render.
- */
-const GLOBAL_KEY = "astro-lilypond:renderState";
-function globalStore() {
-    return globalThis;
-}
-/** Called by the `lilypond()` integration's `astro:config:setup` hook. */
-export function setRenderState(next) {
-    globalStore()[GLOBAL_KEY] = next;
-}
-/** Read by the public `render()`, called from user code rather than the integration's own closures. */
-export function getRenderState() {
-    const state = globalStore()[GLOBAL_KEY];
-    if (!state) {
-        throw new Error("astro-lilypond: please add the `lilypond()` integration to your Astro config.");
-    }
-    return state;
-}
-/** Test-only: resets the shared singleton between test cases. */
-export function resetRenderStateForTests() {
-    globalStore()[GLOBAL_KEY] = undefined;
-}
-/**
- * Shared by the `lilypond()` integration's `astro:config:setup` hook and
- * `lilypondLoader()`'s `load()`: resolves the `lilypond` binary and
- * populates the render state from it. Returns the resolved binary path for
- * callers (e.g. Markdown plugins) that also need it directly.
- */
-export async function resolveAndSetRenderState(options) {
-    const binaryPath = await resolveLilypondBinary({
-        ...resolveAutoInstallOption(options.autoInstall),
-        log: (message) => options.logger.info(message),
-        warn: (message) => options.logger.warn(message),
-    });
-    setRenderState({
-        binaryPath,
-        defaults: options.defaults,
-        timeout: options.timeout,
-        isDev: options.isDev,
-        logger: options.logger,
-    });
-    return binaryPath;
-}