astro-lilypond 0.16.2 → 0.17.1

package/dist/binary/downloadLilypond.js

@@ -60,7 +60,7 @@ export async function downloadLilypond({ version, cacheDir = lilypondCacheDir(),
     if (await pathExists(markerPath))
         return binaryPath;
     const url = downloadUrlFor(version, platform, arch, archiveExt);
-    log(`astro-lilypond: downloading LilyPond ${version} (${platform}-${arch})…`);
+    log(`Downloading LilyPond ${version} (${platform}-${arch})…`);
     const response = await fetchImpl(url);
     if (!response.ok || !response.body) {
         throw new Error(`failed to download LilyPond ${version} from ${url} (HTTP ${response.status})`);
@@ -86,7 +86,7 @@ export async function downloadLilypond({ version, cacheDir = lilypondCacheDir(),
             }
         }
         else {
-            log("astro-lilypond: download response had no checksum header — skipping integrity verification");
+            log("Download response had no checksum header — skipping integrity verification");
         }
         await writeFile(archivePath, data);
         const extractDir = join(workDir, "extract");
@@ -106,7 +106,7 @@ export async function downloadLilypond({ version, cacheDir = lilypondCacheDir(),
         const reuseConcurrentInstall = async () => {
             if (!(await pathExists(markerPath)))
                 return false;
-            log(`astro-lilypond: LilyPond ${version} was installed concurrently by another process; reusing it`);
+            log(`LilyPond ${version} was installed concurrently by another process; reusing it`);
             return true;
         };
         if (await reuseConcurrentInstall())
@@ -120,7 +120,7 @@ export async function downloadLilypond({ version, cacheDir = lilypondCacheDir(),
                 return binaryPath;
             throw err;
         }
-        log(`astro-lilypond: installed LilyPond ${version} to ${installDir}`);
+        log(`Installed LilyPond ${version} to ${installDir}`);
         return binaryPath;
     }
     finally {

package/dist/binary/resolveLilypondBinary.js

@@ -21,12 +21,12 @@ export async function resolveLilypondBinary({ version = DEFAULT_LILYPOND_VERSION
     if (await isOnPath())
         return "lilypond";
     if (!autoInstall) {
-        warn("astro-lilypond: `lilypond` binary not found on PATH — LilyPond blocks will render as errors. " +
+        warn("No `lilypond` binary found on PATH — LilyPond blocks will render as errors. " +
             "Install LilyPond and ensure it is on PATH, or enable the `autoInstall` option (on by default).");
         return "lilypond";
     }
     if (!resolvePlatformTarget()) {
-        warn(`astro-lilypond: \`lilypond\` binary not found on PATH, and no prebuilt LilyPond ${version} ` +
+        warn(`No \`lilypond\` binary found on PATH, and no prebuilt LilyPond ${version} ` +
             `is available for ${process.platform}/${process.arch}. Install LilyPond manually and ensure it is on PATH.`);
         return "lilypond";
     }

package/dist/execLilyPond.d.ts

@@ -1,3 +1,4 @@
+import type { AstroIntegrationLogger } from "astro";
 import type { Format } from "./render.js";
 export interface ExecLilypondOptions {
     binaryPath: string;
@@ -8,6 +9,7 @@ export interface ExecLilypondOptions {
     timeout: number;
     inputPath: string;
     outputBase: string;
+    logger: Pick<AstroIntegrationLogger, "warn" | "error">;
 }
 /**
  * Invokes the `lilypond` binary against an already-written input file.

package/dist/execLilyPond.js

@@ -8,10 +8,14 @@ const MAX_BUFFER = 16 * 1024 * 1024; // 16 MiB
  * build output); throws a normalized Error on a non-zero exit or timeout.
  */
 export async function execLilyPond(options) {
-    const { binaryPath, format, crop, resolution, includePaths, timeout, inputPath, outputBase, } = options;
+    const { binaryPath, format, crop, resolution, includePaths, timeout, inputPath, outputBase, logger, } = options;
     const args = [
         // Render the correct format
         `--format=${format}`,
+        // Suppress LilyPond's own progress trace (Processing/Parsing/Interpreting
+        // music/.../Success), which is noise once Astro is reporting the build
+        // itself. Warnings and errors still print at this level.
+        "--loglevel=WARN",
         // Define defaults — these can be overridden with the appropriate flags
         // inside of individual .ly files
         // Disable point-and-click behavior on SVGs when clicking noteheads
@@ -29,9 +33,10 @@ export async function execLilyPond(options) {
         outputBase,
         inputPath,
     ];
-    // LilyPond writes its progress log, (and any warnings/errors) to stderr,
-    // even on success. surface it in the build output so it's visible,
-    // but let the exit code (not stderr content) decide pass/fail.
+    // LilyPond writes any warnings to stderr even on success (errors on
+    // failure). Surface it through Astro's logger so it's visible and styled
+    // consistently with the rest of the build output, but let the exit code
+    // (not stderr content) decide pass/fail.
     let stderr;
     try {
         ({ stderr } = await execFileAsync(binaryPath, args, {
@@ -49,9 +54,9 @@ export async function execLilyPond(options) {
             ? String(err.stderr)
             : undefined;
         if (errStderr)
-            process.stderr.write(errStderr);
+            logger.error(errStderr);
         throw new Error(errStderr || (err instanceof Error ? err.message : String(err)));
     }
     if (stderr)
-        process.stderr.write(stderr);
+        logger.warn(stderr);
 }

package/dist/index.js

@@ -3,7 +3,7 @@ import emitAssetIntegration from "astro-emit-asset";
 import { remarkPlugin, satteriPlugin, } from "./plugins/index.js";
 import { render as renderScore } from "./render.js";
 import { getRenderState, resolveAndSetRenderState } from "./renderState.js";
-import { altTextFor, emitLilypondAsset, emitLilypondPdfAsset, includePathsFor, lyTypeDeclarationsFor, parseLyHeaderFields, prependVersion, renderedHtml, resolveDefaults, sourceNameFor, titleFor, toLilypondMetadata, } from "./utils/index.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) {
     return createComponent((_result, props) => {
@@ -16,6 +16,15 @@ function createScoreComponent(content) {
         return renderTemplate `${unescapeHTML(html)}`;
     });
 }
+/**
+ * Dev-only fallback for `render()`: renders an inline error block
+ * instead of the score.
+ */
+function createErrorScoreComponent(error, title) {
+    return createComponent(() => {
+        return renderTemplate `${unescapeHTML(renderedErrorHtml(error, title))}`;
+    });
+}
 /**
  * Renders a `LilypondScore` (from a `.ly`/`.ily`/`.lilypond` import,
  * or a `lilypondLoader()` entry) to a renderable `<Score />` component.
@@ -25,49 +34,64 @@ export async function render(score, options = {}) {
     const { resolution, cropScale } = resolveDefaults(state.defaults);
     const format = options.format ?? "svg";
     const crop = options.crop ?? false;
-    const [{ Score, pageCount }, pdf] = await Promise.all([
-        (async () => {
-            const pages = await emitLilypondAsset({
-                title: score.assetTitle,
-                format,
-                source: score.source,
-                resolution,
-                crop,
-                sizeScale: crop ? cropScale : 1,
-                binaryPath: state.binaryPath,
-                render: () => renderScore(score.source, {
+    try {
+        const [{ Score, pageCount }, pdf] = await Promise.all([
+            (async () => {
+                const pages = await emitLilypondAsset({
+                    title: score.assetTitle,
                     format,
+                    source: score.source,
+                    resolution,
                     crop,
-                    defaults: state.defaults,
-                    timeout: state.timeout,
+                    sizeScale: crop ? cropScale : 1,
                     binaryPath: state.binaryPath,
-                    includePaths: score.includePaths,
-                    sourceName: score.sourceName,
-                }),
-            });
-            return {
-                Score: createScoreComponent({ pages, alt: score.alt }),
-                pageCount: pages.length,
-            };
-        })(),
-        options.pdf
-            ? emitLilypondPdfAsset({
-                title: score.assetTitle,
-                source: score.source,
-                binaryPath: state.binaryPath,
-                render: () => renderScore(score.source, {
-                    format: "pdf",
-                    crop: false,
-                    defaults: state.defaults,
-                    timeout: state.timeout,
+                    render: () => renderScore(score.source, {
+                        format,
+                        crop,
+                        defaults: state.defaults,
+                        timeout: state.timeout,
+                        binaryPath: state.binaryPath,
+                        includePaths: score.includePaths,
+                        sourceName: score.sourceName,
+                        logger: state.logger,
+                    }),
+                });
+                return {
+                    Score: createScoreComponent({ pages, alt: score.alt }),
+                    pageCount: pages.length,
+                };
+            })(),
+            options.pdf
+                ? emitLilypondPdfAsset({
+                    title: score.assetTitle,
+                    source: score.source,
                     binaryPath: state.binaryPath,
-                    includePaths: score.includePaths,
-                    sourceName: score.sourceName,
-                }),
-            })
-            : Promise.resolve(undefined),
-    ]);
-    return { Score, pageCount, pdf, meta: score.meta, raw: score.source };
+                    render: () => renderScore(score.source, {
+                        format: "pdf",
+                        crop: false,
+                        defaults: state.defaults,
+                        timeout: state.timeout,
+                        binaryPath: state.binaryPath,
+                        includePaths: score.includePaths,
+                        sourceName: score.sourceName,
+                        logger: state.logger,
+                    }),
+                })
+                : Promise.resolve(undefined),
+        ]);
+        return { Score, pageCount, pdf, meta: score.meta, raw: score.source };
+    }
+    catch (err) {
+        if (!state.isDev)
+            throw err;
+        return {
+            Score: createErrorScoreComponent(err, score.assetTitle),
+            pageCount: 0,
+            pdf: undefined,
+            meta: score.meta,
+            raw: score.source,
+        };
+    }
 }
 /**
  * Renders a `LilypondScore` directly, for the common case where none of
@@ -114,11 +138,15 @@ export default function lilypond(options = {}) {
     return {
         name: "astro-lilypond",
         hooks: {
-            "astro:config:setup": async ({ config, updateConfig, logger }) => {
+            "astro:config:setup": async ({ command, config, updateConfig, logger, }) => {
+                const isDev = command === "dev";
+                options.isDev = isDev;
+                options.logger = logger;
                 options.binaryPath = await resolveAndSetRenderState({
                     autoInstall: options.autoInstall,
                     defaults: options.defaults,
                     timeout: options.timeout,
+                    isDev,
                     logger,
                 });
                 updateConfig({
@@ -144,7 +172,7 @@ export default function lilypond(options = {}) {
                             }),
                         },
                     });
-                    logger?.info("astro-lilypond: registered Sätteri mdast plugin");
+                    logger?.info("Registered Sätteri mdast plugin");
                     return;
                 }
                 if (existingProcessor?.name === "unified") {
@@ -165,7 +193,7 @@ export default function lilypond(options = {}) {
                             }),
                         },
                     });
-                    logger?.info("astro-lilypond: registered unified remark plugin");
+                    logger?.info("Registered unified remark plugin");
                     return;
                 }
                 throw new Error("astro-lilypond requires a processor-based Astro markdown config. " +

package/dist/loader.d.ts

@@ -1,7 +1,6 @@
 import type { LoaderContext } from "astro/loaders";
 import { z } from "astro/zod";
 import { type LilypondScore } from "./index.js";
-import type { LilypondDefaults } from "./render.js";
 export interface GenerateIdOptions {
     /** The path to the entry file, relative to `base`. */
     entry: string;
@@ -26,11 +25,6 @@ export interface LilypondLoaderOptions {
      * @default the file's path relative to `base`, POSIX-separated, with its extension stripped.
      */
     generateId?: (options: GenerateIdOptions) => string;
-    /**
-     * Defaults used when `render()` is later called on one of this
-     * collection's entries.
-     */
-    defaults?: LilypondDefaults;
 }
 export type LilypondCollectionEntry = LilypondScore;
 export declare const lilypondEntrySchema: z.ZodObject<{
@@ -58,7 +52,7 @@ export declare const lilypondEntrySchema: z.ZodObject<{
 /**
  * Content Loader to turn a directory of `.ly` files into a content collection.
  */
-export declare function lilypondLoader({ pattern, base, generateId, defaults, }: LilypondLoaderOptions): {
+export declare function lilypondLoader({ pattern, base, generateId, }: LilypondLoaderOptions): {
     name: string;
     schema: z.ZodObject<{
         source: z.ZodString;

package/dist/loader.js

@@ -3,6 +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 { 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`.
@@ -55,13 +56,13 @@ function posixRelative(from, to) {
 /**
  * Content Loader to turn a directory of `.ly` files into a content collection.
  */
-export function lilypondLoader({ pattern = DEFAULT_PATTERN, base, generateId = defaultGenerateId, defaults, }) {
-    const resolved = resolveDefaults(defaults);
+export function lilypondLoader({ pattern = DEFAULT_PATTERN, base, generateId = defaultGenerateId, }) {
     return {
         name: "astro-lilypond-loader",
         schema: lilypondEntrySchema,
         async load(context) {
             const { config, store, logger, watcher, generateDigest, parseData } = context;
+            const { version } = resolveDefaults(getRenderState().defaults);
             const rootDir = fileURLToPath(config.root);
             const baseUrl = resolveBaseUrl(base, config.root);
             const baseDir = fileURLToPath(baseUrl);
@@ -72,13 +73,13 @@ export function lilypondLoader({ pattern = DEFAULT_PATTERN, base, generateId = d
                     source = await readFile(filePath, "utf8");
                 }
                 catch (err) {
-                    logger.error(`astro-lilypond: error reading ${entry}: ${err.message}`);
+                    logger.error(`Error reading ${entry}: ${err.message}`);
                     return undefined;
                 }
                 const headerFields = parseLyHeaderFields(source);
                 const id = generateId({ entry, base: baseUrl, header: headerFields });
                 const digest = generateDigest(source);
-                const src = prependVersion(source, resolved.version);
+                const src = prependVersion(source, version);
                 const includePaths = includePathsFor(filePath);
                 const sourceName = sourceNameFor(filePath);
                 const assetTitle = titleFor(sourceName);
@@ -116,7 +117,7 @@ export function lilypondLoader({ pattern = DEFAULT_PATTERN, base, generateId = d
                     entries.push(entry);
                 }
                 if (entries.length === 0) {
-                    logger.warn(`astro-lilypond: no files matched "${pattern}" in "${baseDir}"`);
+                    logger.warn(`No files matched "${pattern}" in "${baseDir}"`);
                 }
                 const results = await Promise.all(entries.map(async (entry) => ({ entry, id: await syncEntry(entry) })));
                 for (const { entry, id } of results) {
@@ -146,7 +147,7 @@ export function lilypondLoader({ pattern = DEFAULT_PATTERN, base, generateId = d
                 if (!changedPath.startsWith(baseDir))
                     return;
                 queue = queue.then(() => runSync().catch((err) => {
-                    logger.error(`astro-lilypond: reload failed: ${err.message}`);
+                    logger.error(`Reload failed: ${err.message}`);
                 }));
             };
             watcher.on("add", onFsEvent);

package/dist/plugins/remark.js

@@ -1,7 +1,11 @@
 import { visit } from "unist-util-visit";
 import { defaultOptions, render } from "../render.js";
-import { altTextForBlock, emitLilypondAsset, includePathsFor, isLilypondLang, prependVersion, renderedHtml, resolveDefaults, sourceNameFor, titleFor, } from "../utils/index.js";
+import { altTextForBlock, emitLilypondAsset, includePathsFor, isLilypondLang, prependVersion, renderedErrorHtml, renderedHtml, resolveDefaults, sourceNameFor, titleFor, } from "../utils/index.js";
 export const remarkPlugin = (options) => {
+    const { logger } = options;
+    if (!logger) {
+        throw new Error("astro-lilypond: please add the `lilypond()` integration to your Astro config.");
+    }
     return async (tree, file) => {
         const promises = [];
         const includePaths = includePathsFor(file?.path);
@@ -14,30 +18,38 @@ export const remarkPlugin = (options) => {
             const source = version ? prependVersion(node.value, version) : node.value;
             const format = options.format ?? defaultOptions.format;
             const alt = altTextForBlock(node.meta, node.value);
-            const promise = 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,
-                }),
-            }).then((pages) => {
-                const htmlNode = {
-                    type: "html",
-                    value: renderedHtml(pages, alt),
-                };
+            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 htmlNode = { type: "html", value };
                 parent.children[index] = htmlNode;
-            });
+            })();
             promises.push(promise);
         });
         await Promise.all(promises);

package/dist/plugins/satteri.js

@@ -1,6 +1,10 @@
 import { defaultOptions, render } from "../render.js";
-import { altTextForBlock, emitLilypondAsset, includePathsFor, isLilypondLang, prependVersion, renderedHtml, resolveDefaults, sourceNameFor, titleFor, } from "../utils/index.js";
+import { altTextForBlock, emitLilypondAsset, includePathsFor, isLilypondLang, prependVersion, renderedErrorHtml, renderedHtml, resolveDefaults, sourceNameFor, titleFor, } from "../utils/index.js";
 export function satteriPlugin(options) {
+    const { logger } = options;
+    if (!logger) {
+        throw new Error("astro-lilypond: please add the `lilypond()` integration to your Astro config.");
+    }
     return {
         name: "astro-lilypond",
         async code(node, ctx) {
@@ -13,25 +17,33 @@ export function satteriPlugin(options) {
             const sourceName = sourceNameFor(ctx.fileURL);
             const title = titleFor(sourceName);
             const alt = altTextForBlock(node.meta, node.value);
-            const pages = await emitLilypondAsset({
-                title,
-                format,
-                source,
-                resolution,
-                crop: true,
-                sizeScale: cropScale,
-                binaryPath: options.binaryPath,
-                render: () => render(source, {
+            try {
+                const pages = await emitLilypondAsset({
+                    title,
                     format,
+                    source,
+                    resolution,
                     crop: true,
-                    defaults: options.defaults,
-                    timeout: options.timeout,
+                    sizeScale: cropScale,
                     binaryPath: options.binaryPath,
-                    includePaths,
-                    sourceName,
-                }),
-            });
-            return { rawHtml: renderedHtml(pages, alt) };
+                    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) };
+            }
         },
     };
 }

package/dist/plugins/types.d.ts

@@ -1,7 +1,10 @@
+import type { AstroIntegrationLogger } from "astro";
 import type { LilypondDefaults } from "../render.js";
 export interface PluginOptions {
     format?: "svg" | "png";
     defaults?: LilypondDefaults;
     timeout?: number;
     binaryPath?: string;
+    isDev?: boolean;
+    logger?: Pick<AstroIntegrationLogger, "warn" | "error">;
 }

package/dist/render.d.ts

@@ -1,3 +1,4 @@
+import type { AstroIntegrationLogger } from "astro";
 import type { LilypondVersion } from "./types/lilypondVersion.js";
 export declare const FORMATS: readonly ["png", "svg", "pdf"];
 export type Format = (typeof FORMATS)[number];
@@ -32,7 +33,7 @@ export interface LilypondDefaults {
  * source text.
  */
 export type RenderDefaults = Omit<LilypondDefaults, "version">;
-export interface RenderOptions {
+export interface InternalRenderOptions {
     /**
      * Output format.
      * @default "svg"
@@ -72,8 +73,12 @@ export interface RenderOptions {
      * @default 60000
      */
     timeout?: number;
+    /**
+     * Warning and failure logging from LilyPond.
+     */
+    logger: Pick<AstroIntegrationLogger, "warn" | "error">;
 }
-export declare const defaultOptions: Required<Omit<RenderOptions, "includePaths" | "sourceName" | "defaults">> & {
+export declare const defaultOptions: Required<Omit<InternalRenderOptions, "includePaths" | "sourceName" | "defaults" | "logger">> & {
     defaults: Required<LilypondDefaults>;
 };
-export declare function render(source: string, options?: RenderOptions): Promise<Buffer[]>;
+export declare function render(source: string, options: InternalRenderOptions): Promise<Buffer[]>;

package/dist/render.js

@@ -16,8 +16,8 @@ export const defaultOptions = {
         cropScale: 1.5,
     },
 };
-export async function render(source, options = {}) {
-    const { format = defaultOptions.format, crop = defaultOptions.crop, binaryPath = defaultOptions.binaryPath, timeout = defaultOptions.timeout, includePaths = [], sourceName, } = options;
+export async function render(source, options) {
+    const { format = defaultOptions.format, crop = defaultOptions.crop, binaryPath = defaultOptions.binaryPath, timeout = defaultOptions.timeout, includePaths = [], sourceName, logger, } = options;
     const { resolution } = resolveDefaults(options.defaults);
     if (!FORMATS.includes(format)) {
         throw new Error(`${format} is not a supported format`);
@@ -36,6 +36,7 @@ export async function render(source, options = {}) {
             timeout,
             inputPath,
             outputBase,
+            logger,
         });
         return await readOutputFile(outputBase, format, crop);
     }

package/dist/renderState.d.ts

@@ -1,9 +1,12 @@
+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;
@@ -15,10 +18,8 @@ export interface ResolveAndSetRenderStateOptions {
     autoInstall?: boolean | AutoInstallOptions;
     defaults?: LilypondDefaults;
     timeout?: number;
-    logger: {
-        info: (message: string) => void;
-        warn: (message: string) => void;
-    };
+    isDev: boolean;
+    logger: Pick<AstroIntegrationLogger, "info" | "warn" | "error">;
 }
 /**
  * Shared by the `lilypond()` integration's `astro:config:setup` hook and

package/dist/renderState.js

@@ -41,6 +41,8 @@ export async function resolveAndSetRenderState(options) {
         binaryPath,
         defaults: options.defaults,
         timeout: options.timeout,
+        isDev: options.isDev,
+        logger: options.logger,
     });
     return binaryPath;
 }

package/dist/utils/escapeHtml.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Escape a string for safe interpolation as HTML text-node content.
+ */
+export declare function escapeHtml(value: string): string;

package/dist/utils/escapeHtml.js

@@ -0,0 +1,9 @@
+/**
+ * Escape a string for safe interpolation as HTML text-node content.
+ */
+export function escapeHtml(value) {
+    return value
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}

package/dist/utils/escapeHtmlAttribute.d.ts

@@ -1,7 +1,5 @@
 /**
- * Escapes a string for safe interpolation inside a double-quoted HTML
- * attribute value. Used for alt text, which — unlike the srcs this
- * integration already emits — is arbitrary user/header-derived content that
- * can contain `"`, `&`, `<`.
+ * Escape a string for safe interpolation inside a double-quoted
+ * HTML attribute value.
  */
 export declare function escapeHtmlAttribute(value: string): string;

package/dist/utils/escapeHtmlAttribute.js

@@ -1,8 +1,6 @@
 /**
- * Escapes a string for safe interpolation inside a double-quoted HTML
- * attribute value. Used for alt text, which — unlike the srcs this
- * integration already emits — is arbitrary user/header-derived content that
- * can contain `"`, `&`, `<`.
+ * Escape a string for safe interpolation inside a double-quoted
+ * HTML attribute value.
  */
 export function escapeHtmlAttribute(value) {
     return value

package/dist/utils/index.d.ts

@@ -2,6 +2,7 @@ export { altTextFor } from "./altTextFor.js";
 export { altTextForBlock } from "./altTextForBlock.js";
 export { type EmitLilypondAssetOptions, emitLilypondAsset, } from "./emitLilypondAsset.js";
 export { type EmitLilypondPdfAssetOptions, emitLilypondPdfAsset, } from "./emitLilypondPdfAsset.js";
+export { escapeHtml } from "./escapeHtml.js";
 export { escapeHtmlAttribute } from "./escapeHtmlAttribute.js";
 export type { ImageDimensions } from "./imageDimensions.js";
 export { imageDimensionsFor } from "./imageDimensions.js";
@@ -14,6 +15,7 @@ export { parseFenceMeta } from "./parseFenceMeta.js";
 export type { LyHeaderFields } from "./parseLyHeader.js";
 export { extractMarkupText, parseLyHeader, parseLyHeaderFields, } from "./parseLyHeader.js";
 export { prependVersion } from "./prependVersion.js";
+export { renderedErrorHtml } from "./renderedErrorHtml.js";
 export { renderedHtml } from "./renderedHtml.js";
 export { resolveDefaults } from "./resolveDefaults.js";
 export { sourceNameFor } from "./sourceNameFor.js";

package/dist/utils/index.js

@@ -2,6 +2,7 @@ export { altTextFor } from "./altTextFor.js";
 export { altTextForBlock } from "./altTextForBlock.js";
 export { emitLilypondAsset, } from "./emitLilypondAsset.js";
 export { emitLilypondPdfAsset, } from "./emitLilypondPdfAsset.js";
+export { escapeHtml } from "./escapeHtml.js";
 export { escapeHtmlAttribute } from "./escapeHtmlAttribute.js";
 export { imageDimensionsFor } from "./imageDimensions.js";
 export { includePathsFor } from "./includePathsFor.js";
@@ -11,6 +12,7 @@ export { lyTypeDeclarationsFor } from "./lyTypeDeclarationsFor.js";
 export { parseFenceMeta } from "./parseFenceMeta.js";
 export { extractMarkupText, parseLyHeader, parseLyHeaderFields, } from "./parseLyHeader.js";
 export { prependVersion } from "./prependVersion.js";
+export { renderedErrorHtml } from "./renderedErrorHtml.js";
 export { renderedHtml } from "./renderedHtml.js";
 export { resolveDefaults } from "./resolveDefaults.js";
 export { sourceNameFor } from "./sourceNameFor.js";

package/dist/utils/renderedErrorHtml.d.ts

@@ -0,0 +1 @@
+export declare function renderedErrorHtml(error: unknown, title: string): string;

package/dist/utils/renderedErrorHtml.js

@@ -0,0 +1,22 @@
+import { escapeHtml } from "./escapeHtml.js";
+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);
+}
+export function renderedErrorHtml(error, title) {
+    const heading = `LilyPond failed to render "${escapeHtml(title)}"`;
+    return `<pre style="${ERROR_STYLE}">${heading}\n\n${escapeHtml(messageFor(error))}</pre>`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro-lilypond",
-  "version": "0.16.2",
+  "version": "0.17.1",
   "description": "An Astro integration for rendering Lilypond markup to music notation.",
   "homepage": "https://lilypond.ky.fyi",
   "author": "Ky Decker",
@@ -25,6 +25,9 @@
   "files": [
     "dist"
   ],
+  "engines": {
+    "node": ">=22.12.0"
+  },
   "keywords": [
     "astro",
     "astro-integration",