@writedocs/generator 0.4.7 → 0.4.9

package/src/components/Update.astro

@@ -0,0 +1,171 @@
+---
+// Mintlify's <Update> - one changelog entry: `label` (usually a date or
+// version) in a left column that sticks while its content scrolls, with
+// `description` and `tags` under it. The label is a linkable anchor, deduped
+// against every other anchor on the page by remarkTitleAnchorIds, same as a
+// Callout/Accordion title. Stacks into one column on narrow screens.
+//
+// When any Update on the page has `tags`, a row of tag filters appears
+// above the first one (the script below) - Mintlify shows the same filters
+// in its right-hand panel. `rss` is accepted but unused: writedocs doesn't
+// generate an RSS feed from updates.
+interface Props {
+  label: string;
+  description?: string;
+  tags?: string[];
+  rss?: { title?: string; description?: string };
+  _titleId?: string;
+}
+const { label, description, tags = [], _titleId } = Astro.props as Props;
+function slugify(value: string): string {
+  return value
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+const id = _titleId ?? slugify(label);
+---
+<section class="wd-update" data-update-tags={JSON.stringify(tags)}>
+  <div class="wd-update-meta">
+    <div class="wd-update-label" id={id}>
+      <a href={`#${id}`}>{label}</a>
+    </div>
+    {description && <div class="wd-update-description">{description}</div>}
+    {tags.length > 0 && (
+      <div class="wd-update-tags">
+        {tags.map((tag) => <span class="wd-update-tag">{tag}</span>)}
+      </div>
+    )}
+  </div>
+  <div class="wd-update-body"><slot /></div>
+</section>
+<script>
+  // Builds one tag-filter bar per page, before the first Update, from every
+  // Update's tags. Clicking a tag shows only the updates that have it;
+  // clicking it again (or "All") shows everything.
+  function initUpdateFilters(root: ParentNode) {
+    const updates = Array.from(root.querySelectorAll<HTMLElement>('.wd-update'));
+    if (updates.length === 0 || updates[0].dataset.wdInit) return;
+    updates.forEach((u) => (u.dataset.wdInit = 'true'));
+    const tagsOf = (u: HTMLElement): string[] => {
+      try {
+        return JSON.parse(u.dataset.updateTags ?? '[]');
+      } catch {
+        return [];
+      }
+    };
+    const allTags = [...new Set(updates.flatMap(tagsOf))];
+    if (allTags.length === 0) return;
+
+    const bar = document.createElement('div');
+    bar.className = 'wd-update-filters';
+    bar.setAttribute('role', 'toolbar');
+    bar.setAttribute('aria-label', 'Filter updates by tag');
+    let active: string | null = null;
+    const buttons: HTMLButtonElement[] = [];
+    const apply = () => {
+      updates.forEach((u) => (u.hidden = active !== null && !tagsOf(u).includes(active)));
+      buttons.forEach((b) => b.setAttribute('aria-pressed', String((b.dataset.tag ?? null) === active)));
+    };
+    for (const tag of [null, ...allTags]) {
+      const b = document.createElement('button');
+      b.type = 'button';
+      b.className = 'wd-update-filter';
+      b.textContent = tag ?? 'All';
+      if (tag !== null) b.dataset.tag = tag;
+      b.addEventListener('click', () => {
+        active = tag === null || active === tag ? null : tag;
+        apply();
+      });
+      buttons.push(b);
+      bar.appendChild(b);
+    }
+    updates[0].before(bar);
+    apply();
+  }
+  initUpdateFilters(document);
+  document.addEventListener('astro:page-load', () => initUpdateFilters(document));
+</script>
+<style>
+  .wd-update {
+    display: grid;
+    grid-template-columns: 11rem minmax(0, 1fr);
+    gap: 2rem;
+    padding: 2rem 0;
+    border-top: 1px solid var(--wd-border);
+  }
+  .wd-update:first-of-type {
+    border-top: 0;
+  }
+  .wd-update[hidden] {
+    display: none;
+  }
+  .wd-update-meta {
+    position: sticky;
+    top: calc(var(--wd-topbar-offset, 5rem) + 1rem);
+    align-self: start;
+  }
+  .wd-update-label {
+    scroll-margin-top: calc(var(--wd-topbar-offset, 5rem) + 1rem);
+  }
+  .wd-update-label a {
+    display: inline-block;
+    padding: 0.2rem 0.6rem;
+    border-radius: 999px;
+    font-size: 0.85rem;
+    font-weight: 600;
+    text-decoration: none;
+    color: var(--wd-primary);
+    background: color-mix(in srgb, var(--wd-primary) 12%, transparent);
+  }
+  .wd-update-description {
+    margin-top: 0.5rem;
+    font-size: 0.85rem;
+    color: var(--wd-text-muted);
+  }
+  .wd-update-tags {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.3rem;
+    margin-top: 0.5rem;
+  }
+  .wd-update-tag {
+    padding: 0.05rem 0.45rem;
+    border: 1px solid var(--wd-border);
+    border-radius: 999px;
+    font-size: 0.72rem;
+    color: var(--wd-text-muted);
+  }
+  .wd-update-body > :global(:first-child) {
+    margin-top: 0;
+  }
+  @media (max-width: 720px) {
+    .wd-update {
+      grid-template-columns: minmax(0, 1fr);
+      gap: 0.75rem;
+    }
+    .wd-update-meta {
+      position: static;
+    }
+  }
+  :global(.wd-update-filters) {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.4rem;
+    margin: 1rem 0 0.5rem;
+  }
+  :global(.wd-update-filter) {
+    padding: 0.2rem 0.7rem;
+    border: 1px solid var(--wd-border);
+    border-radius: 999px;
+    background: none;
+    color: var(--wd-text-muted);
+    font-size: 0.8rem;
+    cursor: pointer;
+  }
+  :global(.wd-update-filter[aria-pressed='true']) {
+    border-color: var(--wd-primary);
+    color: var(--wd-primary);
+    background: color-mix(in srgb, var(--wd-primary) 10%, transparent);
+  }
+</style>

package/src/components/View.astro

@@ -0,0 +1,214 @@
+---
+// Mintlify's <View title="..." icon="..."> - content for one of several
+// alternatives (a language, a framework) on the same page. Every distinct
+// `title` on the page becomes an option in one switcher, placed under the
+// page title (or before the first View on a page without one); only the
+// selected title's Views show. As on Mintlify, the table of contents only
+// lists the headings in the visible Views.
+//
+// The choice is remembered (localStorage) across pages, so a reader who
+// picks "Python" keeps seeing Python wherever the same title exists. A
+// link to an anchor inside a hidden View switches to that View first.
+import AppIcon from './AppIcon.astro';
+interface Props {
+  title: string;
+  icon?: string;
+}
+const { title, icon } = Astro.props as Props;
+---
+<div class="wd-view" data-view-title={title}>
+  {icon && <span class="wd-view-icon-src" hidden><AppIcon icon={icon} class="wd-view-icon" /></span>}
+  <slot />
+</div>
+<script>
+  const STORAGE_KEY = 'wd-view';
+
+  function initViews(root: Document) {
+    const views = Array.from(root.querySelectorAll<HTMLElement>('.wd-view[data-view-title]'));
+    if (views.length === 0 || root.querySelector('.wd-view-switcher')) return;
+
+    const titles = [...new Set(views.map((v) => v.dataset.viewTitle!))];
+    const iconFor = (title: string) =>
+      views.find((v) => v.dataset.viewTitle === title)?.querySelector<HTMLElement>('.wd-view-icon-src > *') ?? null;
+
+    let stored: string | null = null;
+    try {
+      stored = localStorage.getItem(STORAGE_KEY);
+    } catch {}
+    const hashTarget = location.hash ? document.getElementById(decodeURIComponent(location.hash.slice(1))) : null;
+    const hashView = hashTarget?.closest<HTMLElement>('.wd-view')?.dataset.viewTitle;
+    let current = hashView ?? (stored && titles.includes(stored) ? stored : titles[0]);
+
+    // The switcher: a button showing the current option, and a menu of all.
+    const switcher = document.createElement('div');
+    switcher.className = 'wd-view-switcher';
+    const button = document.createElement('button');
+    button.type = 'button';
+    button.className = 'wd-view-button';
+    button.setAttribute('aria-haspopup', 'listbox');
+    button.setAttribute('aria-expanded', 'false');
+    const menu = document.createElement('ul');
+    menu.className = 'wd-view-menu';
+    menu.setAttribute('role', 'listbox');
+    menu.hidden = true;
+
+    const label = (title: string) => {
+      const frag = document.createDocumentFragment();
+      const icon = iconFor(title);
+      if (icon) frag.appendChild(icon.cloneNode(true));
+      frag.appendChild(document.createTextNode(title));
+      return frag;
+    };
+    const options = titles.map((title) => {
+      const li = document.createElement('li');
+      li.setAttribute('role', 'option');
+      li.tabIndex = -1;
+      li.dataset.viewTitle = title;
+      li.appendChild(label(title));
+      li.addEventListener('click', () => {
+        select(title, true);
+        close();
+        button.focus();
+      });
+      li.addEventListener('keydown', (e) => {
+        const i = options.indexOf(li);
+        if (e.key === 'ArrowDown') options[Math.min(i + 1, options.length - 1)].focus();
+        else if (e.key === 'ArrowUp') options[Math.max(i - 1, 0)].focus();
+        else if (e.key === 'Enter' || e.key === ' ') li.click();
+        else if (e.key === 'Escape') {
+          close();
+          button.focus();
+        } else return;
+        e.preventDefault();
+      });
+      menu.appendChild(li);
+      return li;
+    });
+
+    const open = () => {
+      menu.hidden = false;
+      button.setAttribute('aria-expanded', 'true');
+      (options.find((o) => o.dataset.viewTitle === current) ?? options[0]).focus();
+    };
+    const close = () => {
+      menu.hidden = true;
+      button.setAttribute('aria-expanded', 'false');
+    };
+    button.addEventListener('click', () => (menu.hidden ? open() : close()));
+    document.addEventListener('click', (e) => {
+      if (!switcher.contains(e.target as Node)) close();
+    });
+
+    function select(title: string, remember: boolean) {
+      current = title;
+      views.forEach((v) => (v.hidden = v.dataset.viewTitle !== title));
+      button.replaceChildren(label(title));
+      const chevron = document.createElement('span');
+      chevron.className = 'wd-view-chevron';
+      chevron.setAttribute('aria-hidden', 'true');
+      button.appendChild(chevron);
+      options.forEach((o) => o.setAttribute('aria-selected', String(o.dataset.viewTitle === title)));
+      // Table of contents: only headings the reader can currently see.
+      document.querySelectorAll<HTMLAnchorElement>('.wd-toc a[data-toc-slug]').forEach((a) => {
+        const heading = document.getElementById(a.dataset.tocSlug ?? '');
+        const li = a.closest('li');
+        if (li) li.hidden = Boolean(heading?.closest('.wd-view[hidden]'));
+      });
+      if (remember) {
+        try {
+          localStorage.setItem(STORAGE_KEY, title);
+        } catch {}
+      }
+    }
+
+    switcher.append(button, menu);
+    const header = document.querySelector('.wd-article-header');
+    if (header) header.after(switcher);
+    else views[0].before(switcher);
+    select(current, false);
+    if (hashTarget && hashView) hashTarget.scrollIntoView();
+
+    // Same for an in-page link to an anchor inside a hidden View.
+    window.addEventListener('hashchange', () => {
+      if (!switcher.isConnected) return;
+      const el = location.hash ? document.getElementById(decodeURIComponent(location.hash.slice(1))) : null;
+      const title = el?.closest<HTMLElement>('.wd-view[hidden]')?.dataset.viewTitle;
+      if (!title) return;
+      select(title, false);
+      el!.scrollIntoView();
+    });
+  }
+  initViews(document);
+  document.addEventListener('astro:page-load', () => initViews(document));
+</script>
+<style>
+  .wd-view[hidden] {
+    display: none;
+  }
+  :global(.wd-view-switcher) {
+    position: relative;
+    display: inline-block;
+    margin: 0 0 1rem;
+  }
+  :global(.wd-view-button) {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.45rem;
+    padding: 0.35rem 0.75rem;
+    border: 1px solid var(--wd-border);
+    border-radius: 0.5rem;
+    background: var(--wd-background);
+    color: var(--wd-text);
+    font-size: 0.875rem;
+    cursor: pointer;
+  }
+  :global(.wd-view-button:hover) {
+    border-color: var(--wd-primary);
+  }
+  :global(.wd-view-chevron) {
+    width: 0.4rem;
+    height: 0.4rem;
+    margin-left: 0.2rem;
+    border-right: 1.5px solid currentColor;
+    border-bottom: 1.5px solid currentColor;
+    transform: translateY(-2px) rotate(45deg);
+  }
+  :global(.wd-view-menu) {
+    position: absolute;
+    top: calc(100% + 0.3rem);
+    left: 0;
+    z-index: 20;
+    min-width: 100%;
+    margin: 0;
+    padding: 0.3rem;
+    list-style: none;
+    border: 1px solid var(--wd-border);
+    border-radius: 0.5rem;
+    background: var(--wd-background);
+    box-shadow: 0 6px 20px rgba(0, 0, 0, 0.12);
+  }
+  :global(.wd-view-menu li) {
+    display: flex;
+    align-items: center;
+    gap: 0.45rem;
+    margin: 0;
+    padding: 0.35rem 0.6rem;
+    border-radius: 0.35rem;
+    font-size: 0.875rem;
+    white-space: nowrap;
+    cursor: pointer;
+  }
+  :global(.wd-view-menu li:hover),
+  :global(.wd-view-menu li:focus),
+  :global(.wd-view-menu li[aria-selected='true']) {
+    outline: none;
+    background: color-mix(in srgb, var(--wd-primary) 10%, transparent);
+    color: var(--wd-primary);
+  }
+  :global(svg.wd-view-icon),
+  :global(span.wd-view-icon) {
+    width: 1em;
+    height: 1em;
+    flex-shrink: 0;
+  }
+</style>

package/src/components/Visibility.astro

@@ -0,0 +1,11 @@
+---
+// Mintlify's <Visibility for="humans|agents">. On the rendered site,
+// `humans` content shows and `agents` content doesn't; the per-page `.md`
+// route and llms-full.txt do the opposite (see lib/visibility.js). A
+// <Visibility> with no `for` counts as `humans`.
+interface Props {
+  for?: 'humans' | 'agents';
+}
+const { for: audience = 'humans' } = Astro.props as Props;
+---
+{audience !== 'agents' && <slot />}

package/src/components/compound.ts

@@ -0,0 +1,21 @@
+// Mintlify's dotted component names - <Tree.Folder>, <Color.Item>,
+// <GitHub.Repo>, ... MDX compiles <Tree.Folder> to a property lookup on
+// whatever `Tree` resolves to, so the parts are attached as properties of
+// their parent here, once, and everything that hands components to MDX (the
+// src/components/index.ts barrel and [...slug].astro's `components` map)
+// takes these three from this module rather than importing the .astro files
+// directly. `FileTree` is Mintlify's other name for `Tree`.
+import TreeRoot from './Tree.astro';
+import TreeFolder from './TreeFolder.astro';
+import TreeFile from './TreeFile.astro';
+import ColorRoot from './Color.astro';
+import ColorRow from './ColorRow.astro';
+import ColorItem from './ColorItem.astro';
+import GitHubRepo from './GitHubRepo.astro';
+
+export const Tree = Object.assign(TreeRoot, { Folder: TreeFolder, File: TreeFile });
+export const FileTree = Tree;
+export const Color = Object.assign(ColorRoot, { Row: ColorRow, Item: ColorItem });
+// Mintlify has no bare <GitHub> - only <GitHub.Repo> - so this is just a
+// namespace object, not a component.
+export const GitHub = { Repo: GitHubRepo };

package/src/components/index.ts

@@ -51,3 +51,10 @@ export { default as ParamField } from './ParamField.astro';
 export { default as ResponseField } from './ResponseField.astro';
 export { default as Columns } from './Columns.astro';
 export { default as Tooltip } from './Tooltip.astro';
+export { default as Update } from './Update.astro';
+export { default as Tile } from './Tile.astro';
+export { default as Panel } from './Panel.astro';
+export { default as Prompt } from './Prompt.astro';
+export { default as View } from './View.astro';
+export { default as Visibility } from './Visibility.astro';
+export { Tree, FileTree, Color, GitHub } from './compound';

package/src/content.config.ts

@@ -1,11 +1,10 @@
 import { defineCollection } from 'astro:content';
 import { glob } from 'astro/loaders';
 import type { Loader } from 'astro/loaders';
-import { z } from 'astro/zod';
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { seoFieldsSchema, findAllPages } from './lib/config';
+import { pageFrontmatterSchema, findAllPages } from './lib/config';
 import { writedocsTempDir } from './lib/writedocs-temp-dir.js';
 
 const contentDir = process.env.WRITEDOCS_CONTENT_DIR || process.cwd();
@@ -32,131 +31,11 @@ const contentDir = process.env.WRITEDOCS_CONTENT_DIR || process.cwd();
 const generatedDocsDir = path.join(writedocsTempDir(contentDir), 'generated-docs');
 const generatedDocsBase = pathToFileURL(generatedDocsDir + path.sep);
 
-const MINTLIFY_MODE_ALIASES: Record<string, string> = { center: 'frame', assistant: 'default' };
-
-const docsSchema = z.object({
-  title: z.string(),
-  description: z.string().optional(),
-  // Overrides the URL this page is served at, independent of where the
-  // file actually lives - writedocs.json's `pages` arrays always keep
-  // referencing the file's own path regardless. This is Astro's own
-  // glob()-loader convention (a `slug` frontmatter field becomes
-  // `entry.id` verbatim - see generateIdDefault in
-  // astro/dist/content/loaders/glob.js), not writedocs-specific
-  // behavior; declaring it here just brings it into the schema (and
-  // its docs) rather than leaving it an undocumented Astro feature.
-  // See fileIdForEntry() in lib/config.ts for how routes/links still
-  // resolve a page by its file id once this diverges from `entry.id`.
-  // Leading/trailing slashes are fine either way ("/", "/guides/x",
-  // "guides/x" and "guides/x/" all mean the same thing) - see
-  // normalizeEntryId() in lib/config.ts, which is what actually
-  // strips them before this value is ever used as a route or href.
-  slug: z.string().optional(),
-  // Marks this page as an OpenAPI operation reference: "METHOD /path"
-  // matching an operation in the owning group's OpenAPI spec, e.g.
-  // "GET /pets/{petId}" - [...slug].astro renders <ApiPlayground /> for
-  // any page with this field set, below the page's own MDX body (if
-  // any). Sites don't write this by hand for most pages; it's either
-  // set on a generated stub in the `generatedDocs` collection below (see
-  // generate-api-pages.js) or hand-authored to "eject" one specific
-  // operation into a real file (in `docs`) with custom prose - either
-  // way, the value is always exactly the same "METHOD /path" key
-  // generate-api-pages.js uses to look up the operation's full resolved
-  // schema/examples at render time.
-  openapi: z.string().optional(),
-  // Controls how much of the site's own chrome (topbar, sidebar, table of
-  // contents) wraps this page - see BaseLayout.astro/[...slug].astro for
-  // what each value actually removes:
-  //   default - the normal three-column reading layout (all chrome).
-  //   wide    - drops the table of contents; the article itself also
-  //             renders wider, for content that wants the extra room
-  //             (wide tables, side-by-side images).
-  //   frame   - drops the sidebar and table of contents, but keeps the
-  //             topbar and the article's own normal presentation
-  //             ("frame" as in: still inside the site's outer frame).
-  //   custom  - drops the sidebar and table of contents, the
-  //             auto-rendered <h1>, and prev/next nav, and skips the
-  //             article's own prose width/padding too - a blank canvas
-  //             for a hand-built landing/home page made entirely of
-  //             components - but keeps the topbar, so the page still
-  //             has site branding/nav/search/theme-toggle available.
-  //   blank   - everything 'custom' drops, plus the topbar too: no site
-  //             chrome at all, just <slot />. For a page that wants to
-  //             look nothing like the rest of the site (an auth screen,
-  //             a print-style page).
-  //
-  // Two Mintlify values are accepted so a migrated page doesn't fail the
-  // build (see MINTLIFY_MODE_ALIASES below): `center` is the same layout
-  // as our `frame`, and `assistant` (a full-page Mintlify AI chat, which
-  // writedocs doesn't have) falls back to `default`. Mintlify's own
-  // `frame` means something else (a canvas that keeps the sidebar) - it's
-  // left as our `frame`; see docs/dev/docs/mintlify-compat.mdx.
-  mode: z
-    .preprocess(
-      (value) => (typeof value === 'string' && value in MINTLIFY_MODE_ALIASES ? MINTLIFY_MODE_ALIASES[value] : value),
-      z.enum(['default', 'wide', 'frame', 'custom', 'blank']),
-    )
-    .default('default'),
-  // Per-page meta tag overrides - same shape as writedocs.json's top-level
-  // `seo` (see seoFieldsSchema in lib/config.ts, the single source of
-  // truth for this shape). A page only needs to set the specific fields
-  // it wants to override; mergeSeo() falls back to the site-wide default
-  // for anything left unset. See BaseLayout.astro for where this and the
-  // site-wide seo actually get merged and rendered.
-  seo: seoFieldsSchema.optional(),
-  // Mintlify's spelling of `seo.noindex` - a top-level `noindex: true`.
-  // Folded into `seo` by the transform below, so everything downstream
-  // (the robots meta tag, sitemap.xml, llms.txt) keeps reading
-  // `seo.noindex` only.
-  noindex: z.boolean().optional(),
-  // Mintlify's short navigation label - used for the sidebar and the
-  // topbar dropdown menus in place of `title` ([...slug].astro's
-  // navTitleForSlug). The page's own <h1> and prev/next links keep `title`.
-  sidebarTitle: z.string().optional(),
-  // Mintlify's spellings of `seo.keywords`, `seo.ogImage`, `seo.ogType`
-  // and `seo.twitterCard`, folded into `seo` below like `noindex`.
-  keywords: z.array(z.string()).optional(),
-  'og:image': z.string().optional(),
-  'og:type': z.string().optional(),
-  'twitter:card': z.enum(['summary', 'summary_large_image']).optional(),
-  // Mintlify's sidebar/page-chrome fields - see NavTree.astro and
-  // [...slug].astro for where each is used:
-  //   icon                 - shown before the page's label in the sidebar.
-  //   tag                  - a short label after it (e.g. "NEW").
-  //   deprecated           - a "Deprecated" label in the sidebar and next
-  //                          to the page's <h1>.
-  //   hidden               - left out of the sidebar, dropdowns and
-  //                          prev/next, but still built and reachable by
-  //                          URL. Also noindexed, as on Mintlify.
-  //   url                  - an external link: the page's sidebar entry
-  //                          links straight to it, and the page's own URL
-  //                          redirects there.
-  //   hideFooterPagination - no prev/next links on this page.
-  //   hideApiMarker        - no HTTP method badge on this page's sidebar
-  //                          entry.
-  icon: z.string().optional(),
-  tag: z.string().optional(),
-  deprecated: z.boolean().optional(),
-  hidden: z.boolean().optional(),
-  url: z.string().optional(),
-  hideFooterPagination: z.boolean().optional(),
-  hideApiMarker: z.boolean().optional(),
-}).transform(
-  ({ noindex, keywords, 'og:image': ogImage, 'og:type': ogType, 'twitter:card': twitterCard, ...data }) => {
-    // Top-level Mintlify keys fill in `seo` only where the page's own `seo`
-    // doesn't already set that field - an explicit `seo` value always wins.
-    // A `hidden` page is noindexed unless it says otherwise.
-    const fromMintlify = { noindex: noindex ?? (data.hidden ? true : undefined), keywords, ogImage, ogType, twitterCard };
-    const seo = { ...data.seo };
-    let changed = false;
-    for (const [key, value] of Object.entries(fromMintlify)) {
-      if (value === undefined || seo[key as keyof typeof seo] !== undefined) continue;
-      (seo as Record<string, unknown>)[key] = value;
-      changed = true;
-    }
-    return changed ? { ...data, seo } : data;
-  },
-);
+// Page frontmatter - defined in lib/config-schema.ts as
+// pageFrontmatterSchema, next to writedocs.json's own schema, so
+// `writedocs validate` checks every page against exactly the schema the
+// build uses (that file compiles to the plain JS validate loads).
+const docsSchema = pageFrontmatterSchema;
 
 /** Wraps another loader so it's skipped entirely - no filesystem scan, no
  *  "directory doesn't exist"/"no files found" warning - when its own base