@refrakt-md/runes 0.14.4 → 0.16.0

package/dist/config.js

@@ -6,6 +6,13 @@ import { BREADCRUMB_AUTO_SENTINEL } from './tags/breadcrumb.js';
 import { NAV_AUTO_SENTINEL, NAV_COLLAPSED_AUTO } from './tags/nav.js';
 import { PAGINATION_AUTO_SENTINEL } from './tags/pagination.js';
 import { resolveXrefs } from './xref-resolve.js';
+import { preprocessSnippets, wrapStandaloneSnippets } from './snippet-pipeline.js';
+import { registerDrawers, resolveAutoDrawerTitleLevels } from './drawer-pipeline.js';
+import { applyOutlineScopeWalkers, harvestHeadingsFromRenderable } from './outline-scope.js';
+import { resolveExpands } from './expand-pipeline.js';
+import { resolveCollections } from './collection-resolve.js';
+import { resolveRelationships } from './relationships-resolve.js';
+import { resolveAggregates } from './aggregate-resolve.js';
 // ─── Budget postTransform helpers ───
 const BUDGET_CURRENCY_SYMBOLS = {
     USD: '$', EUR: '€', GBP: '£', JPY: '¥', CNY: '¥',
@@ -134,6 +141,48 @@ export const coreConfig = {
         },
         PageSection: { block: 'page-section' },
         TableOfContents: { block: 'toc' },
+        /* Snippet doesn't have a normal schema transform — its preprocess
+         * hook replaces the tag with a `fence` node, and the standalone
+         * wrap step adds `<figure class="rf-snippet">` post-transform.
+         * The engine never sees a `Snippet` tag, but we still need an
+         * entry in the theme config so `computeUsedCssBlocks` includes
+         * `snippet.css` in CSS tree-shaking when the figure is rendered. */
+        Snippet: { block: 'snippet' },
+        /* Expand emits a placeholder during transform; the postProcess hook
+         * substitutes the entity content wrapped in `<section
+         * class="rf-expand" data-rune="expand">`. Engine config provides the
+         * block name for CSS tree-shaking. */
+        Expand: { block: 'expand' },
+        /* Badge emits a complete `<span class="rf-badge" data-rune="badge">`
+         * directly from its schema and needs no engine post-processing, but
+         * still needs an entry in the theme config so `computeUsedCssBlocks`
+         * includes `badge.css` in CSS tree-shaking when a badge is rendered. */
+        Badge: { block: 'badge' },
+        /* Collection emits a sentinel during transform; the postProcess hook
+         * (`resolveCollections`) fills it with queried entities. Engine config
+         * provides the block name for CSS tree-shaking. */
+        Collection: { block: 'collection' },
+        Relationships: { block: 'relationships' },
+        /* Aggregate emits a sentinel during transform; the postProcess hook
+         * (`resolveAggregates`) fills it with either a single integer (no-body
+         * form) or a body-zoned breakdown. Engine config provides the block
+         * name for CSS tree-shaking. */
+        Aggregate: { block: 'aggregate' },
+        Progress: {
+            block: 'progress',
+            modifiers: { sentiment: { source: 'meta' } },
+        },
+        /* card — generic content card. The `layout` meta drives the shared
+         * split layout (split.css, data-attribute-keyed); data-media-position
+         * hoists the media to a full-bleed header on mobile. Named parts
+         * (media/content/body/footer/link) get rf-card__* from data-name. */
+        Card: {
+            block: 'card',
+            rootAttributes: { 'data-media-position': 'top' },
+            modifiers: {
+                layout: { source: 'meta', default: 'stacked' },
+            },
+        },
         Embed: {
             block: 'embed',
             defaultDensity: 'compact',
@@ -307,6 +356,17 @@ export const coreConfig = {
                 },
             },
         },
+        Drawer: {
+            block: 'drawer',
+            defaultDensity: 'compact',
+            modifiers: {
+                side: { source: 'meta', default: 'right' },
+                size: { source: 'meta', default: 'md' },
+                shortcut: { source: 'meta', noBemClass: true },
+            },
+            sections: { header: 'header', body: 'body' },
+            editHints: { title: 'inline', body: 'none', close: 'none' },
+        },
         Figure: {
             block: 'figure',
             defaultDensity: 'compact',
@@ -2006,101 +2066,161 @@ navSearchScope) {
     // item href set is final.
     result = applyNavActiveState(result, pageUrl);
     result = resolveBlogPosts(result, coreData.allPosts, ctx, pageUrl);
-    result = resolveXrefs(result, pageUrl, coreData.registry, ctx);
+    result = resolveXrefs(result, pageUrl, coreData.registry, coreData.xrefPatterns ?? [], ctx);
     return result;
 }
 /**
- * Core cross-page pipeline hooks.
- * Run for every site, before any plugin hooks.
- * Registers page and heading entities, aggregates the page tree and breadcrumb paths,
- * and resolves blog post listings.
+ * Build core cross-page pipeline hooks parameterized by build-time options.
+ *
+ * Most callers (existing adapters, tests) use the {@link corePipelineHooks}
+ * default below — equivalent to `createCorePipelineHooks()` with no patterns
+ * configured. The content-loader bootstrap passes compiled
+ * {@link CompiledXrefPattern}s when `refrakt.config.json#/xrefs` is set.
  */
-export const corePipelineHooks = {
-    register(pages, registry, ctx) {
-        for (const page of pages) {
-            const parentUrl = deriveParentUrl(page.url);
-            const existingPage = registry.getById('page', page.url);
-            if (existingPage && existingPage.sourceUrl !== page.url) {
-                ctx.warn(`Page '${page.url}' already registered from '${existingPage.sourceUrl}'`, page.url);
-            }
-            registry.register({
-                type: 'page',
-                id: page.url,
-                sourceUrl: page.url,
-                data: {
-                    title: page.title,
-                    url: page.url,
-                    parentUrl,
-                    draft: page.frontmatter.draft ?? false,
-                    description: page.frontmatter.description,
-                    date: page.frontmatter.date,
-                    order: page.frontmatter.order,
-                    icon: page.frontmatter.icon,
-                },
-            });
-            for (const h of page.headings) {
-                const headingId = `${page.url}#${h.id}`;
-                const existingHeading = registry.getById('heading', headingId);
-                if (existingHeading && existingHeading.sourceUrl !== page.url) {
-                    ctx.warn(`Heading '${headingId}' already registered from '${existingHeading.sourceUrl}'`, page.url);
+export function createCorePipelineHooks(opts = {}) {
+    const xrefPatterns = opts.xrefPatterns ?? [];
+    const embedConfig = opts.embedConfig;
+    return {
+        preprocess: preprocessSnippets,
+        register(pages, registry, ctx) {
+            for (const page of pages) {
+                const parentUrl = deriveParentUrl(page.url);
+                const existingPage = registry.getById('page', page.url);
+                if (existingPage && existingPage.sourceUrl !== page.url) {
+                    ctx.warn(`Page '${page.url}' already registered from '${existingPage.sourceUrl}'`, page.url);
                 }
                 registry.register({
-                    type: 'heading',
-                    id: headingId,
+                    type: 'page',
+                    id: page.url,
                     sourceUrl: page.url,
-                    data: { level: h.level, text: h.text, headingId: h.id, url: page.url },
+                    data: {
+                        title: page.title,
+                        url: page.url,
+                        parentUrl,
+                        draft: page.frontmatter.draft ?? false,
+                        description: page.frontmatter.description,
+                        date: page.frontmatter.date,
+                        order: page.frontmatter.order,
+                        icon: page.frontmatter.icon,
+                    },
                 });
+                for (const h of page.headings) {
+                    const headingId = `${page.url}#${h.id}`;
+                    const existingHeading = registry.getById('heading', headingId);
+                    if (existingHeading && existingHeading.sourceUrl !== page.url) {
+                        ctx.warn(`Heading '${headingId}' already registered from '${existingHeading.sourceUrl}'`, page.url);
+                    }
+                    registry.register({
+                        type: 'heading',
+                        id: headingId,
+                        sourceUrl: page.url,
+                        data: { level: h.level, text: h.text, headingId: h.id, url: page.url },
+                    });
+                }
             }
-        }
-    },
-    aggregate(registry, ctx) {
-        const pageEntities = registry.getAll('page');
-        const pages = pageEntities.map(e => ({
-            url: e.data.url,
-            title: e.data.title,
-            parentUrl: e.data.parentUrl,
-            description: e.data.description,
-            icon: e.data.icon,
-            order: e.data.order,
-        }));
-        const pageTree = buildPageTree(pages);
-        const breadcrumbPaths = buildBreadcrumbPaths(pages);
-        // Quick lookup: url → { url, title } for postProcess use
-        const pagesByUrl = new Map(pages.map(p => [p.url, p]));
-        // Build heading index: "url#id" → heading data
-        const headingIndex = new Map();
-        for (const h of registry.getAll('heading')) {
-            headingIndex.set(h.id, h.data);
-        }
-        // Blog: collect all pages as potential blog posts
-        const allPosts = pageEntities.map(e => ({
-            title: e.data.title || '',
-            url: e.data.url || e.id,
-            date: e.data.date || '',
-            description: e.data.description || '',
-            draft: e.data.draft || false,
-            frontmatter: e.data,
-        }));
-        return { pageTree, breadcrumbPaths, pagesByUrl, headingIndex, allPosts, registry };
-    },
-    postProcess(page, aggregated, ctx) {
-        const coreData = aggregated['__core__'];
-        if (!coreData)
-            return page;
-        let renderable = resolveAutoBreadcrumbs(page.renderable, page.url, coreData.breadcrumbPaths, coreData.pagesByUrl, ctx);
-        renderable = resolveAutoNavs(renderable, page.url, coreData.pagesByUrl, ctx);
-        // SPEC-055 build-time slug resolution (see note in resolveCoreSentinels).
-        renderable = resolveNavSlugs(renderable, coreData.pagesByUrl, ctx, page.url);
-        renderable = resolveCollapsibleNavs(renderable, page.url, coreData.pagesByUrl);
-        renderable = resolveCardsNavs(renderable, page.url, coreData.pagesByUrl);
-        renderable = resolveAutoPagination(renderable, page.url, coreData.pagesByUrl, renderable);
-        // SPEC-055 build-time active state.
-        renderable = applyNavActiveState(renderable, page.url);
-        renderable = resolveBlogPosts(renderable, coreData.allPosts, ctx, page.url);
-        renderable = resolveXrefs(renderable, page.url, coreData.registry, ctx);
-        if (renderable === page.renderable)
-            return page;
-        return { ...page, renderable };
-    },
-};
+            // SPEC-060 — register every drawer rune as a page-scoped entity so
+            // `{% ref "drawer-id" /%}` resolves to the drawer's address.
+            registerDrawers(pages, registry, ctx);
+        },
+        aggregate(registry, ctx) {
+            const pageEntities = registry.getAll('page');
+            const pages = pageEntities.map(e => ({
+                url: e.data.url,
+                title: e.data.title,
+                parentUrl: e.data.parentUrl,
+                description: e.data.description,
+                icon: e.data.icon,
+                order: e.data.order,
+            }));
+            const pageTree = buildPageTree(pages);
+            const breadcrumbPaths = buildBreadcrumbPaths(pages);
+            // Quick lookup: url → { url, title } for postProcess use
+            const pagesByUrl = new Map(pages.map(p => [p.url, p]));
+            // Build heading index: "url#id" → heading data
+            const headingIndex = new Map();
+            for (const h of registry.getAll('heading')) {
+                headingIndex.set(h.id, h.data);
+            }
+            // Blog: collect all pages as potential blog posts
+            const allPosts = pageEntities.map(e => ({
+                title: e.data.title || '',
+                url: e.data.url || e.id,
+                date: e.data.date || '',
+                description: e.data.description || '',
+                draft: e.data.draft || false,
+                frontmatter: e.data,
+            }));
+            return { pageTree, breadcrumbPaths, pagesByUrl, headingIndex, allPosts, registry, xrefPatterns, embedConfig };
+        },
+        postProcess(page, aggregated, ctx) {
+            const coreData = aggregated['__core__'];
+            if (!coreData)
+                return page;
+            let renderable = resolveAutoBreadcrumbs(page.renderable, page.url, coreData.breadcrumbPaths, coreData.pagesByUrl, ctx);
+            renderable = resolveAutoNavs(renderable, page.url, coreData.pagesByUrl, ctx);
+            // SPEC-055 build-time slug resolution (see note in resolveCoreSentinels).
+            renderable = resolveNavSlugs(renderable, coreData.pagesByUrl, ctx, page.url);
+            renderable = resolveCollapsibleNavs(renderable, page.url, coreData.pagesByUrl);
+            renderable = resolveCardsNavs(renderable, page.url, coreData.pagesByUrl);
+            renderable = resolveAutoPagination(renderable, page.url, coreData.pagesByUrl, renderable);
+            // SPEC-055 build-time active state.
+            renderable = applyNavActiveState(renderable, page.url);
+            renderable = resolveBlogPosts(renderable, coreData.allPosts, ctx, page.url);
+            // SPEC-060 — rewrite `data-drawer-title-auto` placeholders to the
+            // appropriate `h{n}` based on outline depth. Runs before xref
+            // resolution so the rewritten title doesn't carry the sentinel
+            // attribute into the rendered HTML.
+            renderable = resolveAutoDrawerTitleLevels(renderable);
+            // SPEC-066 expand resolution — substitutes embedded entity content
+            // before xref runs so refs inside substituted content are resolved
+            // by the same pass as host-page refs.
+            renderable = resolveExpands(renderable, page.url, coreData.registry, coreData.xrefPatterns ?? [], coreData.embedConfig, ctx);
+            // SPEC-070 collection resolution — runs after expand and before xref so
+            // item-template `{% ref %}`s are resolved by the same xref pass.
+            renderable = resolveCollections(renderable, page.url, coreData.registry, coreData.embedConfig, ctx);
+            // SPEC-072 relationships resolution — same placement rationale as
+            // collection: after expand, before xref (so item-template `{% ref %}`s
+            // resolve in the same xref pass).
+            renderable = resolveRelationships(renderable, page.url, coreData.registry, coreData.embedConfig, ctx);
+            // SPEC-076 aggregate resolution — same placement as collection /
+            // relationships: after expand, before xref (so any `{% ref %}` inside
+            // the body template resolves in the same xref pass).
+            renderable = resolveAggregates(renderable, page.url, coreData.registry, coreData.embedConfig, ctx);
+            renderable = resolveXrefs(renderable, page.url, coreData.registry, coreData.xrefPatterns ?? [], ctx);
+            // SPEC-062 standalone snippet wrap: turn `<pre data-snippet-source>`
+            // into `<figure class="rf-snippet">` when not inside a fence-consuming
+            // container (codegroup, diff). The wrap is a no-op when the page
+            // has no snippet-derived fences.
+            const wrappedPage = wrapStandaloneSnippets(renderable === page.renderable ? page : { ...page, renderable }, aggregated, ctx);
+            // SPEC-066 outline-scope walkers: prefix heading IDs and drop TOC
+            // items inside any `data-outline-scope` subtree. Generic — any rune
+            // can set the attribute and get the behaviour. Runs last so it can
+            // see the final tree (including expand-substituted content once
+            // that lands in v0.15.0).
+            applyOutlineScopeWalkers(wrappedPage.renderable);
+            // Refresh `page.headings` from the final renderable. Parse-time
+            // `extractHeadings` only saw the raw AST — anything inlined by
+            // postProcess (expand `level=N`, collection bodies) wouldn't make
+            // it into the parse-time list, leaving the page TOC blind to those
+            // headings. Skips `data-outline-scope` subtrees so peer-document
+            // embeds stay isolated, matching the TOC walker.
+            const harvested = harvestHeadingsFromRenderable(wrappedPage.renderable);
+            if (harvested.length > 0 || wrappedPage.headings.length > 0) {
+                return { ...wrappedPage, headings: harvested };
+            }
+            return wrappedPage;
+        },
+    };
+}
+/**
+ * Core cross-page pipeline hooks (no xref patterns configured).
+ *
+ * Equivalent to `createCorePipelineHooks()`. The content loader bootstrap
+ * uses {@link createCorePipelineHooks} directly when
+ * `refrakt.config.json#/xrefs` is configured so the resolver can use the
+ * compiled patterns as a URL-resolution fallback. Run for every site,
+ * before any plugin hooks. Registers page and heading entities, aggregates
+ * the page tree and breadcrumb paths, and resolves blog post listings.
+ */
+export const corePipelineHooks = createCorePipelineHooks();
 //# sourceMappingURL=config.js.map