astro-lilypond 0.12.0 → 0.13.0

package/dist/index.d.ts

@@ -14,7 +14,7 @@ export interface LilypondContent {
 }
 export interface LilypondOptions extends PluginOptions {
     /**
-     * Output format to be written to a file under `outputDir`.
+     * Output format.
      * @default "svg"
      */
     format?: "svg" | "png";
@@ -29,15 +29,5 @@ export interface LilypondOptions extends PluginOptions {
      * @default 60000
      */
     timeout?: number;
-    /**
-     * Directory name, relative to Astro's `publicDir`, that rendered assets
-     * are written into by both `astro dev` and `astro build`. Filenames are
-     * content-addressed, so unchanged scores are reused instead of being
-     * re-rendered, and it's safe to commit this directory if you'd like
-     * faster rebuilds.
-     *
-     * @default "_lilypond"
-     */
-    outputDir?: string;
 }
 export default function lilypond(options?: LilypondOptions): AstroIntegration;

package/dist/index.js

@@ -1,12 +1,9 @@
 import { execFile } from "node:child_process";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
-import { pruneOrphanedAssets, pruneStaleAssets } from "./deleteAssets.js";
+import emitAssetIntegration from "astro-emit-asset";
 import { rehypePlugin, remarkPlugin, satteriPlugin, } from "./plugins/index.js";
 import { defaultOptions, render, resolveCrop, } from "./render.js";
-import { altTextFor, assetsUrlBaseFor, contentHashFor, includePathsFor, lyTypeDeclarationsFor, parseLyHeader, parseLyImportQuery, prependVersion, RECOGNIZED_QUERY_PARAMS, resolveDefaults, sourceNameFor, titleFor, } from "./utils/index.js";
-import { writeAssets } from "./writeAsset.js";
+import { altTextFor, emitLilypondAsset, includePathsFor, lyTypeDeclarationsFor, parseLyHeader, parseLyImportQuery, prependVersion, RECOGNIZED_QUERY_PARAMS, resolveDefaults, sourceNameFor, titleFor, } from "./utils/index.js";
 const execFileAsync = promisify(execFile);
 export const LY_EXTENSIONS = [".ly", ".lilypond", ".ily"];
 function lyFilePlugin(options) {
@@ -27,17 +24,15 @@ function lyFilePlugin(options) {
             const includePaths = includePathsFor(pathname);
             const sourceName = sourceNameFor(pathname);
             const title = titleFor(sourceName);
-            const hash = contentHashFor({ source: src, format, resolution, crop });
             const alt = altTextFor(parseLyHeader(source));
-            const assets = await writeAssets({
-                hash,
+            const pages = await emitLilypondAsset({
                 title,
                 format,
-                outputDir: options.assetsDir,
-                urlBase: options.assetsUrlBase,
+                source: src,
+                resolution,
+                crop,
                 sizeScale: crop ? cropScale : 1,
-                trackAsset: options.trackAsset,
-                getBuffers: () => render(src, {
+                render: () => render(src, {
                     format,
                     crop,
                     defaults: options.defaults,
@@ -46,15 +41,8 @@ function lyFilePlugin(options) {
                     sourceName,
                 }),
             });
-            // Keyed by the full id (including query) so `./score.ly` and
-            // `./score.ly?crop` are tracked as independent sources.
-            await options.pruneStaleAssets(id, assets.map((asset) => asset.fileName));
             const content = {
-                pages: assets.map((asset) => ({
-                    src: asset.url,
-                    width: asset.width,
-                    height: asset.height,
-                })),
+                pages,
                 alt,
             };
             return {
@@ -64,9 +52,6 @@ function lyFilePlugin(options) {
     };
 }
 export default function lilypond(options = {}) {
-    const referencedAssets = new Set();
-    const assetsBySource = new Map();
-    let assetsDir;
     return {
         name: "astro-lilypond",
         hooks: {
@@ -76,25 +61,9 @@ export default function lilypond(options = {}) {
                         logger?.warn("astro-lilypond: `lilypond` binary not found — LilyPond blocks will render as errors. Install LilyPond and ensure it is on PATH.");
                     }
                 });
-                const outputDirName = options.outputDir ?? "_lilypond";
-                const assetsUrlBase = assetsUrlBaseFor(config.base, outputDirName);
-                const resolvedAssetsDir = join(fileURLToPath(config.publicDir), outputDirName);
-                assetsDir = resolvedAssetsDir;
-                const resolvedOptions = {
-                    ...options,
-                    assetsDir,
-                    assetsUrlBase,
-                    trackAsset: (fileName) => referencedAssets.add(fileName),
-                    pruneStaleAssets: (sourceKey, fileNames) => pruneStaleAssets({
-                        assetsBySource,
-                        sourceKey,
-                        fileNames,
-                        outputDir: resolvedAssetsDir,
-                        logger,
-                    }),
-                };
                 updateConfig({
-                    vite: { plugins: [lyFilePlugin(resolvedOptions)] },
+                    integrations: [emitAssetIntegration()],
+                    vite: { plugins: [lyFilePlugin(options)] },
                 });
                 const existingProcessor = config.markdown?.processor;
                 if (existingProcessor?.name === "satteri") {
@@ -110,7 +79,7 @@ export default function lilypond(options = {}) {
                                 ...existingOptions,
                                 mdastPlugins: [
                                     ...(existingOptions.mdastPlugins ?? []),
-                                    satteriPlugin(resolvedOptions),
+                                    satteriPlugin(options),
                                 ],
                             }),
                         },
@@ -131,11 +100,11 @@ export default function lilypond(options = {}) {
                                 ...existingOptions,
                                 remarkPlugins: [
                                     ...(existingOptions.remarkPlugins ?? []),
-                                    [remarkPlugin, resolvedOptions],
+                                    [remarkPlugin, options],
                                 ],
                                 rehypePlugins: [
                                     ...(existingOptions.rehypePlugins ?? []),
-                                    [rehypePlugin, resolvedOptions],
+                                    [rehypePlugin, options],
                                 ],
                             }),
                         },
@@ -154,15 +123,6 @@ export default function lilypond(options = {}) {
                     content: lyTypeDeclarationsFor(LY_EXTENSIONS, RECOGNIZED_QUERY_PARAMS),
                 });
             },
-            "astro:build:done": async ({ logger }) => {
-                if (!assetsDir)
-                    return;
-                await pruneOrphanedAssets({
-                    dir: assetsDir,
-                    referenced: referencedAssets,
-                    logger,
-                });
-            },
         },
     };
 }

package/dist/loader.d.ts

@@ -27,15 +27,6 @@ export interface LilypondLoaderOptions extends PluginOptions {
      * @default the file's path relative to `base`, POSIX-separated, with its extension stripped.
      */
     generateId?: (options: GenerateIdOptions) => string;
-    /**
-     * Directory name, relative to Astro's `publicDir`, that rendered assets
-     * are written into. Exclusive to this collection — the loader prunes
-     * anything under it that isn't currently referenced by one of its own
-     * entries, so don't point two different collections (or the `lilypond()`
-     * integration's own `outputDir`) at the same directory.
-     * @default `"_lilypond/<collection name>"`
-     */
-    outputDir?: string;
 }
 export interface LilypondHeaderData extends KnownLyHeaderFields {
     /** Header fields outside LilyPond's standard set (e.g. `mutopiacomposer`). */

package/dist/loader.js

@@ -1,12 +1,10 @@
 import { glob, readFile } from "node:fs/promises";
-import { basename, join, posix, relative, sep } from "node:path";
+import { join, relative, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { z } from "astro/zod";
-import { pruneOrphanedAssets } from "./deleteAssets.js";
 import { LY_EXTENSIONS } from "./index.js";
 import { defaultOptions, render, resolveCrop } from "./render.js";
-import { altTextFor, assetsUrlBaseFor, contentHashFor, includePathsFor, parseLyHeaderFields, prependVersion, resolveDefaults, sourceNameFor, splitHeaderFields, titleFor, } from "./utils/index.js";
-import { writeAssets } from "./writeAsset.js";
+import { altTextFor, emitLilypondAsset, includePathsFor, parseLyHeaderFields, prependVersion, resolveDefaults, sourceNameFor, splitHeaderFields, titleFor, } from "./utils/index.js";
 const DEFAULT_PATTERN = `**/*.{${LY_EXTENSIONS.map((ext) => ext.slice(1)).join(",")}}`;
 export const lilypondEntrySchema = z.object({
     pages: z.array(z.object({
@@ -56,7 +54,7 @@ function posixRelative(from, to) {
  * Content Loader to turn a directory of `.ly` files into a content collection.
  */
 export function lilypondLoader(options) {
-    const { pattern = DEFAULT_PATTERN, base, generateId = defaultGenerateId, format, defaults, timeout, outputDir, } = options;
+    const { pattern = DEFAULT_PATTERN, base, generateId = defaultGenerateId, format, defaults, timeout, } = options;
     const resolved = resolveDefaults(defaults);
     const crop = resolveCrop(resolved.crop, "component");
     const resolvedFormat = format ?? defaultOptions.format;
@@ -64,10 +62,7 @@ export function lilypondLoader(options) {
         name: "astro-lilypond-loader",
         schema: lilypondEntrySchema,
         async load(context) {
-            const { config, collection, store, logger, watcher, generateDigest, parseData, } = context;
-            const outputDirName = outputDir ?? posix.join("_lilypond", collection);
-            const assetsDir = join(fileURLToPath(config.publicDir), outputDirName);
-            const assetsUrlBase = assetsUrlBaseFor(config.base, outputDirName);
+            const { config, store, logger, watcher, generateDigest, parseData } = context;
             const rootDir = fileURLToPath(config.root);
             const baseUrl = resolveBaseUrl(base, config.root);
             const baseDir = fileURLToPath(baseUrl);
@@ -83,28 +78,19 @@ export function lilypondLoader(options) {
                 }
                 const headerFields = parseLyHeaderFields(source);
                 const id = generateId({ entry, base: baseUrl, header: headerFields });
-                // Not short-circuited on a matching digest: that only proves the
-                // source is unchanged, not that the asset file still exists on
-                // disk. `writeAssets()` does the real disk-backed cache check.
                 const digest = generateDigest(source);
                 const src = prependVersion(source, resolved.version);
                 const includePaths = includePathsFor(filePath);
                 const sourceName = sourceNameFor(filePath);
                 const title = titleFor(sourceName);
-                const hash = contentHashFor({
-                    source: src,
+                const pages = await emitLilypondAsset({
+                    title,
                     format: resolvedFormat,
+                    source: src,
                     resolution: resolved.resolution,
                     crop,
-                });
-                const assets = await writeAssets({
-                    hash,
-                    title,
-                    format: resolvedFormat,
-                    outputDir: assetsDir,
-                    urlBase: assetsUrlBase,
                     sizeScale: crop ? resolved.cropScale : 1,
-                    getBuffers: () => render(src, {
+                    render: () => render(src, {
                         format: resolvedFormat,
                         crop,
                         defaults,
@@ -116,11 +102,7 @@ export function lilypondLoader(options) {
                 const data = await parseData({
                     id,
                     data: {
-                        pages: assets.map((asset) => ({
-                            src: asset.url,
-                            width: asset.width,
-                            height: asset.height,
-                        })),
+                        pages,
                         alt: altTextFor({
                             title: headerFields.title,
                             composer: headerFields.composer,
@@ -167,17 +149,6 @@ export function lilypondLoader(options) {
                 }
                 for (const id of untouched)
                     store.delete(id);
-                // Sweep the directory against every currently-stored entry's pages
-                // (not just the ones touched this pass), so a removed/renamed
-                // source's leftover files get cleaned up without needing separate
-                // per-entry bookkeeping.
-                const referenced = new Set();
-                for (const stored of store.values()) {
-                    const pages = stored.data.pages;
-                    for (const page of pages ?? [])
-                        referenced.add(basename(page.src));
-                }
-                await pruneOrphanedAssets({ dir: assetsDir, referenced, logger });
             }
             await runSync();
             if (!watcher)

package/dist/plugins/index.d.ts

@@ -1,4 +1,4 @@
 export { rehypePlugin } from "./rehype.js";
 export { remarkPlugin } from "./remark.js";
 export { satteriPlugin } from "./satteri.js";
-export type { PluginOptions, ResolvedPluginOptions } from "./types.js";
+export type { PluginOptions } from "./types.js";

package/dist/plugins/rehype.d.ts

@@ -1,5 +1,4 @@
-import type { ResolvedPluginOptions } from "./types.js";
-export type RehypePluginOptions = ResolvedPluginOptions;
-export declare function rehypePlugin(options: RehypePluginOptions): (tree: any, file?: {
+import type { PluginOptions } from "./types.js";
+export declare function rehypePlugin(options: PluginOptions): (tree: any, file?: {
     path?: string;
 }) => Promise<void>;

package/dist/plugins/rehype.js

@@ -1,13 +1,11 @@
 import { visit } from "unist-util-visit";
 import { defaultOptions, render, resolveCrop } from "../render.js";
-import { altTextForBlock, contentHashFor, includePathsFor, isLilypondLang, prependVersion, renderedHtml, resolveDefaults, sourceNameFor, titleFor, } from "../utils/index.js";
-import { writeAssets } from "../writeAsset.js";
+import { altTextForBlock, emitLilypondAsset, includePathsFor, isLilypondLang, prependVersion, renderedHtml, resolveDefaults, sourceNameFor, titleFor, } from "../utils/index.js";
 // Typed loosely so it's assignable to both RehypePlugin and the unified
 // Plugin generic regardless of which @types/hast version the host project pins.
 export function rehypePlugin(options) {
     return async (tree, file) => {
         const promises = [];
-        const fileNames = [];
         const includePaths = includePathsFor(file?.path);
         const sourceName = sourceNameFor(file?.path);
         const title = titleFor(sourceName);
@@ -36,17 +34,15 @@ export function rehypePlugin(options) {
             const source = version ? prependVersion(raw, version) : raw;
             const format = options.format ?? defaultOptions.format;
             const crop = resolveCrop(cropSetting, "markdown");
-            const hash = contentHashFor({ source, format, resolution, crop });
             const alt = altTextForBlock(codeNode.data?.meta, raw);
-            const promise = writeAssets({
-                hash,
+            const promise = emitLilypondAsset({
                 title,
                 format,
-                outputDir: options.assetsDir,
-                urlBase: options.assetsUrlBase,
-                trackAsset: options.trackAsset,
+                source,
+                resolution,
+                crop,
                 sizeScale: crop ? cropScale : 1,
-                getBuffers: () => render(source, {
+                render: () => render(source, {
                     format,
                     crop,
                     defaults: options.defaults,
@@ -54,19 +50,15 @@ export function rehypePlugin(options) {
                     includePaths,
                     sourceName,
                 }),
-            }).then((assets) => {
-                fileNames.push(...assets.map((asset) => asset.fileName));
+            }).then((pages) => {
                 const rawNode = {
                     type: "raw",
-                    value: renderedHtml(assets, alt),
+                    value: renderedHtml(pages, alt),
                 };
                 parent.children[index] = rawNode;
             });
             promises.push(promise);
         });
         await Promise.all(promises);
-        if (file?.path) {
-            await options.pruneStaleAssets(file.path, fileNames);
-        }
     };
 }

package/dist/plugins/remark.d.ts

@@ -1,5 +1,4 @@
 import type { Root } from "mdast";
 import type { Plugin } from "unified";
-import type { ResolvedPluginOptions } from "./types.js";
-export type RemarkPluginOptions = ResolvedPluginOptions;
-export declare const remarkPlugin: Plugin<[RemarkPluginOptions], Root>;
+import type { PluginOptions } from "./types.js";
+export declare const remarkPlugin: Plugin<[PluginOptions], Root>;

package/dist/plugins/remark.js

@@ -1,11 +1,9 @@
 import { visit } from "unist-util-visit";
 import { defaultOptions, render, resolveCrop } from "../render.js";
-import { altTextForBlock, contentHashFor, includePathsFor, isLilypondLang, prependVersion, renderedHtml, resolveDefaults, sourceNameFor, titleFor, } from "../utils/index.js";
-import { writeAssets } from "../writeAsset.js";
+import { altTextForBlock, emitLilypondAsset, includePathsFor, isLilypondLang, prependVersion, renderedHtml, resolveDefaults, sourceNameFor, titleFor, } from "../utils/index.js";
 export const remarkPlugin = (options) => {
     return async (tree, file) => {
         const promises = [];
-        const fileNames = [];
         const includePaths = includePathsFor(file?.path);
         const sourceName = sourceNameFor(file?.path);
         const title = titleFor(sourceName);
@@ -16,17 +14,15 @@ export const remarkPlugin = (options) => {
             const source = version ? prependVersion(node.value, version) : node.value;
             const format = options.format ?? defaultOptions.format;
             const crop = resolveCrop(cropSetting, "markdown");
-            const hash = contentHashFor({ source, format, resolution, crop });
             const alt = altTextForBlock(node.meta, node.value);
-            const promise = writeAssets({
-                hash,
+            const promise = emitLilypondAsset({
                 title,
                 format,
-                outputDir: options.assetsDir,
-                urlBase: options.assetsUrlBase,
-                trackAsset: options.trackAsset,
+                source,
+                resolution,
+                crop,
                 sizeScale: crop ? cropScale : 1,
-                getBuffers: () => render(source, {
+                render: () => render(source, {
                     format,
                     crop,
                     defaults: options.defaults,
@@ -34,19 +30,15 @@ export const remarkPlugin = (options) => {
                     includePaths,
                     sourceName,
                 }),
-            }).then((assets) => {
-                fileNames.push(...assets.map((asset) => asset.fileName));
+            }).then((pages) => {
                 const htmlNode = {
                     type: "html",
-                    value: renderedHtml(assets, alt),
+                    value: renderedHtml(pages, alt),
                 };
                 parent.children[index] = htmlNode;
             });
             promises.push(promise);
         });
         await Promise.all(promises);
-        if (file?.path) {
-            await options.pruneStaleAssets(file.path, fileNames);
-        }
     };
 };

package/dist/plugins/satteri.d.ts

@@ -1,4 +1,3 @@
 import type { MdastPluginDefinition } from "satteri";
-import type { ResolvedPluginOptions } from "./types.js";
-export type SatteriPluginOptions = ResolvedPluginOptions;
-export declare function satteriPlugin(options: SatteriPluginOptions): MdastPluginDefinition;
+import type { PluginOptions } from "./types.js";
+export declare function satteriPlugin(options: PluginOptions): MdastPluginDefinition;

package/dist/plugins/satteri.js

@@ -1,6 +1,5 @@
 import { defaultOptions, render, resolveCrop } from "../render.js";
-import { altTextForBlock, contentHashFor, includePathsFor, isLilypondLang, prependVersion, renderedHtml, resolveDefaults, sourceNameFor, titleFor, } from "../utils/index.js";
-import { writeAssets } from "../writeAsset.js";
+import { altTextForBlock, emitLilypondAsset, includePathsFor, isLilypondLang, prependVersion, renderedHtml, resolveDefaults, sourceNameFor, titleFor, } from "../utils/index.js";
 export function satteriPlugin(options) {
     return {
         name: "astro-lilypond",
@@ -17,17 +16,15 @@ export function satteriPlugin(options) {
             const sourceName = sourceNameFor(ctx.fileURL);
             const title = titleFor(sourceName);
             const crop = resolveCrop(cropSetting, "markdown");
-            const hash = contentHashFor({ source, format, resolution, crop });
             const alt = altTextForBlock(node.meta, node.value);
-            const assets = await writeAssets({
-                hash,
+            const pages = await emitLilypondAsset({
                 title,
                 format,
-                outputDir: options.assetsDir,
-                urlBase: options.assetsUrlBase,
-                trackAsset: options.trackAsset,
+                source,
+                resolution,
+                crop,
                 sizeScale: crop ? cropScale : 1,
-                getBuffers: () => render(source, {
+                render: () => render(source, {
                     format,
                     crop,
                     defaults: options.defaults,
@@ -36,14 +33,9 @@ export function satteriPlugin(options) {
                     sourceName,
                 }),
             });
-            // Sätteri has no per-file "done" hook, so prune per block instead.
-            if (ctx.fileURL) {
-                const index = ctx.indexOf(node) ?? "root";
-                await options.pruneStaleAssets(`${ctx.fileURL.href}#${index}`, assets.map((asset) => asset.fileName));
-            }
             return {
                 type: "html",
-                value: renderedHtml(assets, alt),
+                value: renderedHtml(pages, alt),
             };
         },
     };

package/dist/plugins/types.d.ts

@@ -4,17 +4,3 @@ export interface PluginOptions {
     defaults?: LilypondDefaults;
     timeout?: number;
 }
-/**
- * `PluginOptions` plus the filesystem/URL details resolved once from Astro's
- * config in `astro:config:setup`. Internal only.
- */
-export interface ResolvedPluginOptions extends PluginOptions {
-    /** Absolute filesystem path assets are written into. */
-    assetsDir: string;
-    /** URL prefix assets are referenced by, e.g. `"/_lilypond"`. */
-    assetsUrlBase: string;
-    /** Records that a given output filename was referenced during this build. */
-    trackAsset: (fileName: string) => void;
-    /** Deletes files this source previously produced but no longer does. */
-    pruneStaleAssets: (sourceKey: string, fileNames: readonly string[]) => Promise<void>;
-}

package/dist/utils/emitLilypondAsset.d.ts

@@ -0,0 +1,29 @@
+import type { LilypondPage } from "../index.js";
+import type { Format } from "../render.js";
+export interface EmitLilypondAssetOptions {
+    /**
+     * Human-readable title — becomes the emitted file's name, with the hash
+     * `emitAsset()` derives inserted after it (`<title>.<hash>.<format>`).
+     */
+    title: string;
+    /** Output format — also used as the file extension. */
+    format: Format;
+    /** The exact LilyPond source rendered, so a change busts the cache. */
+    source: string;
+    /** Resolution in DPI (PNG only) — a render dependency, so part of the cache key. */
+    resolution: number;
+    /** Whether output is cropped — a render dependency, so part of the cache key. */
+    crop: boolean;
+    /**
+     * Multiplies the `width`/`height` reported on each page. The generated
+     * bytes are never touched — this only affects the dimensions handed back
+     * for sizing the `<img>` tag.
+     */
+    sizeScale: number;
+    /**
+     * Produces the bytes to render, one Buffer per page. Only invoked on a
+     * cache miss.
+     */
+    render: () => Promise<Buffer[]>;
+}
+export declare function emitLilypondAsset(options: EmitLilypondAssetOptions): Promise<LilypondPage[]>;

package/dist/utils/emitLilypondAsset.fake.d.ts

@@ -0,0 +1,10 @@
+import type { vi } from "vitest";
+import type { emitLilypondAsset } from "./emitLilypondAsset.js";
+type EmitLilypondAssetMock = ReturnType<typeof vi.mocked<typeof emitLilypondAsset>>;
+export declare function fakeEmitLilypondAsset(mock: EmitLilypondAssetMock, urlBase?: string): void;
+/**
+ * Fake that just awaits `opts.render()` and discards the result — for tests
+ * asserting that a `render()` rejection propagates out of the caller.
+ */
+export declare function fakeEmitLilypondAssetPropagatingRenderErrors(mock: EmitLilypondAssetMock): void;
+export {};

package/dist/utils/emitLilypondAsset.fake.js

@@ -0,0 +1,18 @@
+export function fakeEmitLilypondAsset(mock, urlBase = "/_astro") {
+    mock.mockImplementation(async (opts) => {
+        const buffers = await opts.render();
+        return buffers.map((_, i) => ({
+            src: `${urlBase}/${opts.title}${i === 0 ? "" : `-p${i + 1}`}.${opts.format}`,
+        }));
+    });
+}
+/**
+ * Fake that just awaits `opts.render()` and discards the result — for tests
+ * asserting that a `render()` rejection propagates out of the caller.
+ */
+export function fakeEmitLilypondAssetPropagatingRenderErrors(mock) {
+    mock.mockImplementation(async (opts) => {
+        await opts.render();
+        return [];
+    });
+}

package/dist/utils/emitLilypondAsset.js

@@ -0,0 +1,37 @@
+import { emitAsset } from "astro-emit-asset/emit";
+import { imageDimensionsFor } from "./imageDimensions.js";
+const EMIT_ASSET_GLOBAL_KEY = "astro-emit-asset";
+function assertEmitAssetRegistered() {
+    if (globalThis[EMIT_ASSET_GLOBAL_KEY])
+        return;
+    throw new Error("astro-lilypond: please add the `lilypond()` integration to your Astro config.");
+}
+export async function emitLilypondAsset(options) {
+    assertEmitAssetRegistered();
+    const { title, format, source, resolution, crop, sizeScale, render } = options;
+    const result = await emitAsset(`${title}.[hash].${format}`, [source, format, resolution, crop, sizeScale], async () => {
+        const buffers = await render();
+        const pages = buffers.map((data) => {
+            const dimensions = imageDimensionsFor(format, data);
+            return {
+                data,
+                meta: {
+                    width: dimensions ? dimensions.width * sizeScale : undefined,
+                    height: dimensions ? dimensions.height * sizeScale : undefined,
+                },
+            };
+        });
+        // Returning a 1-element array (instead of the bare object) makes
+        // astro-emit-asset insert a page index into the filename even for a
+        // single-page score (`title.0.hash.ext`) — return the object
+        // directly for that (overwhelmingly common) case so the file is
+        // named `title.hash.ext` instead.
+        return pages.length === 1 ? pages[0] : pages;
+    });
+    const assets = Array.isArray(result) ? result : [result];
+    return assets.map((asset) => ({
+        src: asset.src,
+        width: asset.meta.width,
+        height: asset.meta.height,
+    }));
+}

package/dist/utils/index.d.ts

@@ -1,7 +1,6 @@
 export { altTextFor } from "./altTextFor.js";
 export { altTextForBlock } from "./altTextForBlock.js";
-export { assetsUrlBaseFor } from "./assetsUrlBaseFor.js";
-export { contentHashFor } from "./contentHashFor.js";
+export { type EmitLilypondAssetOptions, emitLilypondAsset, } from "./emitLilypondAsset.js";
 export { escapeHtmlAttribute } from "./escapeHtmlAttribute.js";
 export type { ImageDimensions } from "./imageDimensions.js";
 export { imageDimensionsFor } from "./imageDimensions.js";
@@ -9,12 +8,10 @@ export { includePathsFor } from "./includePathsFor.js";
 export { isLilypondLang } from "./isLilypondLang.js";
 export { parseLyImportQuery, RECOGNIZED_QUERY_PARAMS, } from "./lyImportQuery.js";
 export { lyTypeDeclarationsFor } from "./lyTypeDeclarationsFor.js";
-export { contentTypeFor, isOwnAssetFileName } from "./ownAssetFileName.js";
 export { parseFenceMeta } from "./parseFenceMeta.js";
 export type { LyHeaderFields } from "./parseLyHeader.js";
 export { extractMarkupText, parseLyHeader, parseLyHeaderFields, } from "./parseLyHeader.js";
 export { prependVersion } from "./prependVersion.js";
-export type { RenderedPage } from "./renderedHtml.js";
 export { renderedHtml } from "./renderedHtml.js";
 export { resolveDefaults } from "./resolveDefaults.js";
 export { sourceNameFor } from "./sourceNameFor.js";

package/dist/utils/index.js

@@ -1,14 +1,12 @@
 export { altTextFor } from "./altTextFor.js";
 export { altTextForBlock } from "./altTextForBlock.js";
-export { assetsUrlBaseFor } from "./assetsUrlBaseFor.js";
-export { contentHashFor } from "./contentHashFor.js";
+export { emitLilypondAsset, } from "./emitLilypondAsset.js";
 export { escapeHtmlAttribute } from "./escapeHtmlAttribute.js";
 export { imageDimensionsFor } from "./imageDimensions.js";
 export { includePathsFor } from "./includePathsFor.js";
 export { isLilypondLang } from "./isLilypondLang.js";
 export { parseLyImportQuery, RECOGNIZED_QUERY_PARAMS, } from "./lyImportQuery.js";
 export { lyTypeDeclarationsFor } from "./lyTypeDeclarationsFor.js";
-export { contentTypeFor, isOwnAssetFileName } from "./ownAssetFileName.js";
 export { parseFenceMeta } from "./parseFenceMeta.js";
 export { extractMarkupText, parseLyHeader, parseLyHeaderFields, } from "./parseLyHeader.js";
 export { prependVersion } from "./prependVersion.js";

package/dist/utils/renderedHtml.d.ts

@@ -1,6 +1,2 @@
-export interface RenderedPage {
-    url: string;
-    width?: number;
-    height?: number;
-}
-export declare function renderedHtml(pages: RenderedPage[], alt: string): string;
+import type { LilypondPage } from "../index.js";
+export declare function renderedHtml(pages: LilypondPage[], alt: string): string;

package/dist/utils/renderedHtml.js

@@ -3,7 +3,7 @@ function imgTag(page, escapedAlt) {
     const size = page.width !== undefined && page.height !== undefined
         ? ` width="${page.width}" height="${page.height}"`
         : "";
-    return `<img data-lilypond-image src="${page.url}"${size} alt="${escapedAlt}">`;
+    return `<img data-lilypond-image src="${page.src}"${size} alt="${escapedAlt}">`;
 }
 export function renderedHtml(pages, alt) {
     const escapedAlt = escapeHtmlAttribute(alt);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro-lilypond",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "An Astro integration for rendering Lilypond markup to music notation.",
   "homepage": "https://lilypond.ky.fyi",
   "author": "Ky Decker",
@@ -48,6 +48,7 @@
     "astro": ">=7.0.0"
   },
   "dependencies": {
+    "astro-emit-asset": "^0.1.0",
     "unist-util-visit": "^5.1.0"
   },
   "devDependencies": {

package/dist/deleteAssets.d.ts

@@ -1,26 +0,0 @@
-export interface PruneOrphanedAssetsOptions {
-    /** Absolute filesystem path to the assets output directory. */
-    dir: string;
-    /** Filenames (e.g. `"ab12…ef.svg"`) referenced during this build. */
-    referenced: ReadonlySet<string>;
-    logger?: {
-        info: (message: string) => void;
-    };
-}
-/** Deletes our content-addressed files under `dir` that weren't referenced this build. */
-export declare function pruneOrphanedAssets(options: PruneOrphanedAssetsOptions): Promise<void>;
-export interface PruneStaleAssetsOptions {
-    /** Per-source history of output filenames, keyed by module id or file path. */
-    assetsBySource: Map<string, Set<string>>;
-    /** Stable identifier for the source these `fileNames` were rendered from. */
-    sourceKey: string;
-    /** Every output filename this source's current transform pass produced. */
-    fileNames: readonly string[];
-    /** Absolute filesystem path the files live in. */
-    outputDir: string;
-    logger?: {
-        info: (message: string) => void;
-    };
-}
-/** Deletes a source's own previously-rendered files that it no longer produces. */
-export declare function pruneStaleAssets(options: PruneStaleAssetsOptions): Promise<void>;

package/dist/deleteAssets.js

@@ -1,51 +0,0 @@
-import { readdir, unlink } from "node:fs/promises";
-import { join, relative } from "node:path";
-import { isOwnAssetFileName } from "./utils/index.js";
-/** Deletes `fileNames` from `dir` and logs a one-line summary. Ignores files that are already gone. */
-async function deleteAssets(options) {
-    const { dir, fileNames, reason, context, logger } = options;
-    if (fileNames.length === 0)
-        return;
-    await Promise.all(fileNames.map((name) => unlink(join(dir, name)).catch(() => { })));
-    logger?.info(`astro-lilypond: pruned ${fileNames.length} ${reason} asset${fileNames.length === 1 ? "" : "s"} from ${context}`);
-}
-/** Relativizes `path` to the current working directory for log messages. */
-function relativeToCwd(path) {
-    return relative(process.cwd(), path) || ".";
-}
-/** Deletes our content-addressed files under `dir` that weren't referenced this build. */
-export async function pruneOrphanedAssets(options) {
-    const { dir, referenced, logger } = options;
-    let entries;
-    try {
-        entries = await readdir(dir);
-    }
-    catch {
-        return;
-    }
-    const orphaned = entries.filter((name) => isOwnAssetFileName(name) && !referenced.has(name));
-    await deleteAssets({
-        dir,
-        fileNames: orphaned,
-        reason: "orphaned",
-        context: relativeToCwd(dir),
-        logger,
-    });
-}
-/** Deletes a source's own previously-rendered files that it no longer produces. */
-export async function pruneStaleAssets(options) {
-    const { assetsBySource, sourceKey, fileNames, outputDir, logger } = options;
-    const next = new Set(fileNames);
-    const previous = assetsBySource.get(sourceKey);
-    assetsBySource.set(sourceKey, next);
-    if (!previous)
-        return;
-    const stale = [...previous].filter((name) => !next.has(name));
-    await deleteAssets({
-        dir: outputDir,
-        fileNames: stale,
-        reason: "stale",
-        context: relativeToCwd(sourceKey),
-        logger,
-    });
-}

package/dist/utils/assetsUrlBaseFor.d.ts

@@ -1,5 +0,0 @@
-/**
- * Joins Astro's `base` config with the configured output directory name
- * into a clean URL prefix.
- */
-export declare function assetsUrlBaseFor(base: string, outputDirName: string): string;

package/dist/utils/assetsUrlBaseFor.js

@@ -1,8 +0,0 @@
-import { posix } from "node:path";
-/**
- * Joins Astro's `base` config with the configured output directory name
- * into a clean URL prefix.
- */
-export function assetsUrlBaseFor(base, outputDirName) {
-    return posix.join(base, outputDirName);
-}

package/dist/utils/contentHashFor.d.ts

@@ -1,19 +0,0 @@
-import type { Format } from "../render.js";
-export interface ContentHashInput {
-    source: string;
-    format: Format;
-    resolution: number;
-    crop: boolean;
-}
-/**
- * Derives a content-addressed hash for a rendered score (the first segment
- * of its `<hash>.<title>.<ext>` filename), so identical source/options reuse
- * the same output file (skipping a redundant `lilypond` invocation) and any
- * change produces a new, cache-safe filename.
- *
- * Deliberately does not cover `\include`d file contents or the `lilypond`
- * binary version — an included file changing, or a LilyPond upgrade,
- * won't bust the cache. Accepted v1 tradeoff; clear the output directory
- * to force a full re-render after either.
- */
-export declare function contentHashFor(input: ContentHashInput): string;

package/dist/utils/contentHashFor.js

@@ -1,20 +0,0 @@
-import { createHash } from "node:crypto";
-const HASH_LENGTH = 6;
-/**
- * Derives a content-addressed hash for a rendered score (the first segment
- * of its `<hash>.<title>.<ext>` filename), so identical source/options reuse
- * the same output file (skipping a redundant `lilypond` invocation) and any
- * change produces a new, cache-safe filename.
- *
- * Deliberately does not cover `\include`d file contents or the `lilypond`
- * binary version — an included file changing, or a LilyPond upgrade,
- * won't bust the cache. Accepted v1 tradeoff; clear the output directory
- * to force a full re-render after either.
- */
-export function contentHashFor(input) {
-    const { source, format, resolution, crop } = input;
-    return createHash("sha256")
-        .update(JSON.stringify([source, format, resolution, crop]))
-        .digest("hex")
-        .slice(0, HASH_LENGTH);
-}

package/dist/utils/ownAssetFileName.d.ts

@@ -1,11 +0,0 @@
-/**
- * True for filenames matching our own `<hash>.<title>.<format>` naming —
- * the single source of truth for what counts as one of our own rendered
- * assets, shared by `pruneOrphanedAssets` and the dev asset endpoint.
- */
-export declare function isOwnAssetFileName(name: string): boolean;
-/**
- * The `Content-Type` for one of our own asset filenames, or `undefined` if
- * `fileName` isn't one (see `isOwnAssetFileName`).
- */
-export declare function contentTypeFor(fileName: string): string | undefined;

package/dist/utils/ownAssetFileName.js

@@ -1,24 +0,0 @@
-import { FORMATS } from "../render.js";
-const CONTENT_TYPES = {
-    svg: "image/svg+xml",
-    png: "image/png",
-};
-const OWN_ASSET_NAME = new RegExp(`^[0-9a-f]+\\.[a-zA-Z0-9_-]+\\.(?:${FORMATS.join("|")})$`);
-/**
- * True for filenames matching our own `<hash>.<title>.<format>` naming —
- * the single source of truth for what counts as one of our own rendered
- * assets, shared by `pruneOrphanedAssets` and the dev asset endpoint.
- */
-export function isOwnAssetFileName(name) {
-    return OWN_ASSET_NAME.test(name);
-}
-/**
- * The `Content-Type` for one of our own asset filenames, or `undefined` if
- * `fileName` isn't one (see `isOwnAssetFileName`).
- */
-export function contentTypeFor(fileName) {
-    if (!isOwnAssetFileName(fileName))
-        return undefined;
-    const format = fileName.slice(fileName.lastIndexOf(".") + 1);
-    return CONTENT_TYPES[format];
-}

package/dist/writeAsset.d.ts

@@ -1,51 +0,0 @@
-import type { Format } from "./render.js";
-export interface WriteAssetOptions {
-    /** Content hash — the first segment of the filename. */
-    hash: string;
-    /**
-     * Human-readable title — the middle segment of the filename, e.g. the
-     * source file's basename. See `titleFor()`.
-     */
-    title: string;
-    /** Output format — also used as the file extension. */
-    format: Format;
-    /** Absolute filesystem path to write the file into. */
-    outputDir: string;
-    /** URL prefix the returned URL is built from, e.g. `"/_lilypond"`. */
-    urlBase: string;
-    /** Called with each written/reused file's name, hit or miss. */
-    trackAsset?: (fileName: string) => void;
-    /**
-     * Produces the bytes to write, one Buffer per page. Only invoked on a
-     * cache miss, so a caller can defer an expensive render behind this and
-     * skip it entirely when the content-addressed file(s) already exist.
-     */
-    getBuffers: () => Promise<Buffer[]>;
-    /**
-     * Multiplies the `width`/`height` reported on each `WrittenAsset`. The
-     * written file's own bytes are never touched — this only affects the
-     * dimensions handed back for sizing the `<img>` tag, so it's cheap to
-     * change and applies even to a cache hit that skips `getBuffers`.
-     * @default 1
-     */
-    sizeScale?: number;
-}
-export interface WrittenAsset {
-    /** Bare filename under `outputDir`. */
-    fileName: string;
-    /** Public URL to reference the file by. */
-    url: string;
-    /**
-     * Dimensions read back from the written file's own bytes, so `<img>`
-     * tags can be sized upfront and avoid layout shift on load. Omitted if
-     * they couldn't be determined (e.g. unrecognized/malformed content).
-     */
-    width?: number;
-    height?: number;
-}
-/**
- * Persists rendered pages to content-addressed files under `outputDir`,
- * skipping the render entirely if page 1 already exists on disk, and returns
- * each page's filename and public URL, in page order.
- */
-export declare function writeAssets(options: WriteAssetOptions): Promise<WrittenAsset[]>;

package/dist/writeAsset.js

@@ -1,80 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { access, mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { imageDimensionsFor } from "./utils/imageDimensions.js";
-/** Page 1 keeps the plain `<hash>.<title>.<format>` name; later pages get `-pN`. */
-function pageFileName(hash, title, format, page) {
-    return page === 1
-        ? `${hash}.${title}.${format}`
-        : `${hash}.${title}-p${page}.${format}`;
-}
-async function exists(path) {
-    return access(path).then(() => true, () => false);
-}
-/**
- * Finds every already-written sibling page after page 1, stopping at the
- * first missing page number — pages are written contiguously, so a gap
- * means the end. Costs one `access()` per actual page (typically 0-2)
- * rather than listing the whole (potentially large, shared) `outputDir`.
- */
-async function existingSiblingPages(outputDir, hash, title, format) {
-    const siblings = [];
-    for (let page = 2;; page++) {
-        const fileName = pageFileName(hash, title, format, page);
-        if (!(await exists(join(outputDir, fileName))))
-            break;
-        siblings.push(fileName);
-    }
-    return siblings;
-}
-/**
- * Persists rendered pages to content-addressed files under `outputDir`,
- * skipping the render entirely if page 1 already exists on disk, and returns
- * each page's filename and public URL, in page order.
- */
-export async function writeAssets(options) {
-    const { hash, title, format, outputDir, urlBase, trackAsset, getBuffers, sizeScale = 1, } = options;
-    const page1Name = pageFileName(hash, title, format, 1);
-    const page1Path = join(outputDir, page1Name);
-    const alreadyWritten = await exists(page1Path);
-    let fileNames;
-    // Populated on a cache miss, so dimensions can be read from the buffers
-    // already in hand instead of reading each file back from disk.
-    let buffersByFileName;
-    if (alreadyWritten) {
-        fileNames = [
-            page1Name,
-            ...(await existingSiblingPages(outputDir, hash, title, format)),
-        ];
-    }
-    else {
-        const buffers = await getBuffers();
-        fileNames = buffers.map((_, i) => pageFileName(hash, title, format, i + 1));
-        buffersByFileName = new Map(fileNames.map((name, i) => [name, buffers[i]]));
-        await mkdir(outputDir, { recursive: true });
-        await Promise.all(buffers.map(async (buf, i) => {
-            const destPath = join(outputDir, fileNames[i]);
-            // Write to a uniquely-suffixed temp file, then atomically rename
-            // onto the final path — safe under concurrent writers racing to
-            // produce the same hash, since identical hashes imply identical
-            // bytes, so whichever rename lands "wins" without ever leaving a
-            // corrupt/partial file.
-            const tmpPath = `${destPath}.${randomUUID()}.tmp`;
-            await writeFile(tmpPath, buf);
-            await rename(tmpPath, destPath);
-        }));
-    }
-    for (const fileName of fileNames)
-        trackAsset?.(fileName);
-    return Promise.all(fileNames.map(async (fileName) => {
-        const buf = buffersByFileName?.get(fileName) ??
-            (await readFile(join(outputDir, fileName)));
-        const dimensions = imageDimensionsFor(format, buf);
-        return {
-            fileName,
-            url: `${urlBase}/${fileName}`,
-            width: dimensions ? dimensions.width * sizeScale : undefined,
-            height: dimensions ? dimensions.height * sizeScale : undefined,
-        };
-    }));
-}