kempo 4.6.2 → 4.7.0

package/server/utils/global-content/deleteGlobalContent.js

@@ -1,24 +1,9 @@
 import { readFile, writeFile } from 'fs/promises';
 import { join } from 'path';
 import { existsSync } from 'fs';
-import { GLOBAL_FILE, parseEntries } from './helpers.js';
+import { GLOBAL_FILE, parseEntries, serializeEntries } from './helpers.js';
 import triggerHook from '../hooks/triggerHook.js';
 
-const serializeEntries = entries => entries.map(e => {
-  const attrs = [
-    `id="${e.id}"`,
-    `name="${e.name}"`,
-    `owner="${e.owner}"`,
-    `author="${e.author}"`,
-    `created="${e.createdAt}"`,
-    `updated="${e.updatedAt}"`,
-    `locked="${e.locked}"`,
-    `location="${e.location}"`,
-    `priority="${e.priority}"`
-  ].join(' ');
-  return `<content ${attrs}>\n${e.markup}\n</content>`;
-}).join('\n');
-
 export default async ({ rootDir, ids }) => {
   if(!rootDir){
     return [{ code: 400, msg: 'Root directory is required' }, null];

package/server/utils/global-content/disableGlobalContent.js

@@ -1,22 +1,7 @@
 import { readFile, writeFile } from 'fs/promises';
 import { join } from 'path';
 import { existsSync } from 'fs';
-import { GLOBAL_FILE, GLOBAL_DISABLED_FILE, parseEntries } from './helpers.js';
-
-const serializeEntries = entries => entries.map(e => {
-  const attrs = [
-    `id="${e.id}"`,
-    `name="${e.name}"`,
-    `owner="${e.owner}"`,
-    `author="${e.author}"`,
-    `created="${e.createdAt}"`,
-    `updated="${e.updatedAt}"`,
-    `locked="${e.locked}"`,
-    `location="${e.location}"`,
-    `priority="${e.priority}"`
-  ].join(' ');
-  return `<content ${attrs}>\n${e.markup}\n</content>`;
-}).join('\n');
+import { GLOBAL_FILE, GLOBAL_DISABLED_FILE, parseEntries, serializeEntries } from './helpers.js';
 
 export default async ({ rootDir, id }) => {
   if(!rootDir){

package/server/utils/global-content/enableGlobalContent.js

@@ -1,22 +1,7 @@
 import { readFile, writeFile } from 'fs/promises';
 import { join } from 'path';
 import { existsSync } from 'fs';
-import { GLOBAL_FILE, GLOBAL_DISABLED_FILE, parseEntries } from './helpers.js';
-
-const serializeEntries = entries => entries.map(e => {
-  const attrs = [
-    `id="${e.id}"`,
-    `name="${e.name}"`,
-    `owner="${e.owner}"`,
-    `author="${e.author}"`,
-    `created="${e.createdAt}"`,
-    `updated="${e.updatedAt}"`,
-    `locked="${e.locked}"`,
-    `location="${e.location}"`,
-    `priority="${e.priority}"`
-  ].join(' ');
-  return `<content ${attrs}>\n${e.markup}\n</content>`;
-}).join('\n');
+import { GLOBAL_FILE, GLOBAL_DISABLED_FILE, parseEntries, serializeEntries } from './helpers.js';
 
 export default async ({ rootDir, id }) => {
   if(!rootDir){

package/server/utils/global-content/helpers.js

@@ -1,10 +1,19 @@
-import { readFile } from 'fs/promises';
-import { join } from 'path';
-import { existsSync } from 'fs';
-
 const GLOBAL_FILE = 'kempo-global.global.html';
 const GLOBAL_DISABLED_FILE = 'kempo-global.global-disabled.html';
 
+/*
+  A quote or angle bracket inside an attribute would end the tag early, so they are written as
+  entities and read back.
+*/
+const escapeAttr = value => String(value ?? '').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+const unescapeAttr = value => value.replace(/&quot;/g, '"').replace(/&lt;/g, '<').replace(/&gt;/g, '>');
+
+const KNOWN_ATTRIBUTES = ['id', 'name', 'owner', 'author', 'locked', 'location', 'priority', 'created', 'updated', 'menu', 'menu-locations', 'menu-copy', 'menu-nav-item'];
+
+/*
+  Attributes this code does not know about are kept in `extra` and written back unchanged, so a
+  marker added by hand or by a newer version survives a save instead of being silently dropped.
+*/
 const parseEntries = raw => {
   const entries = [];
   const regex = /<content\s([^>]*)>([\s\S]*?)<\/content>/g;
@@ -13,21 +22,46 @@ const parseEntries = raw => {
     const attrs = {};
     const attrRegex = /(\w[\w-]*)="([^"]*)"/g;
     let a;
-    while((a = attrRegex.exec(match[1])) !== null) attrs[a[1]] = a[2];
+    while((a = attrRegex.exec(match[1])) !== null) attrs[a[1]] = unescapeAttr(a[2]);
     entries.push({
       id: attrs.id || '',
       name: attrs.name || '',
       owner: attrs.owner || 'custom',
       author: attrs.author || '',
       locked: attrs.locked === 'true',
+      menu: attrs.menu || '',
+      menuLocations: attrs['menu-locations'] === undefined ? null : attrs['menu-locations'].split(',').map(l => l.trim()).filter(Boolean),
+      menuCopyOf: attrs['menu-copy'] || '',
+      navItem: attrs['menu-nav-item'] || '',
       location: attrs.location || 'default',
       priority: parseInt(attrs.priority || '0', 10),
       createdAt: attrs.created || '',
       updatedAt: attrs.updated || '',
+      extra: Object.fromEntries(Object.entries(attrs).filter(([key]) => !KNOWN_ATTRIBUTES.includes(key))),
       markup: match[2].trim()
     });
   }
   return entries;
 };
 
-export { GLOBAL_FILE, GLOBAL_DISABLED_FILE, parseEntries };
+const serializeEntries = entries => entries.map(e => {
+  const attrs = [
+    `id="${e.id}"`,
+    `name="${escapeAttr(e.name)}"`,
+    `owner="${e.owner}"`,
+    `author="${escapeAttr(e.author)}"`,
+    `created="${e.createdAt}"`,
+    `updated="${e.updatedAt}"`,
+    `locked="${e.locked}"`,
+    `location="${e.location}"`,
+    `priority="${e.priority}"`,
+    ...(e.menu ? [`menu="${e.menu}"`] : []),
+    ...(e.menuLocations ? [`menu-locations="${e.menuLocations.join(',')}"`] : []),
+    ...(e.menuCopyOf ? [`menu-copy="${e.menuCopyOf}"`] : []),
+    ...(e.navItem ? [`menu-nav-item="${e.navItem}"`] : []),
+    ...Object.entries(e.extra || {}).map(([key, value]) => `${key}="${escapeAttr(value)}"`)
+  ].join(' ');
+  return `<content ${attrs}>\n${e.markup}\n</content>`;
+}).join('\n');
+
+export { GLOBAL_FILE, GLOBAL_DISABLED_FILE, parseEntries, serializeEntries };

package/server/utils/global-content/listGlobalContent.js

@@ -3,7 +3,7 @@ import { join } from 'path';
 import { existsSync } from 'fs';
 import { GLOBAL_FILE, GLOBAL_DISABLED_FILE, parseEntries } from './helpers.js';
 
-export default async ({ rootDir }) => {
+export default async ({ rootDir, includeMenu = true }) => {
   if(!rootDir){
     return [{ code: 400, msg: 'Root directory is required' }, null];
   }
@@ -19,6 +19,6 @@ export default async ({ rootDir }) => {
     ? parseEntries(await readFile(disabledPath, 'utf-8')).map(e => ({ ...e, disabled: true }))
     : [];
 
-  const entries = [...activeEntries, ...disabledEntries];
+  const entries = [...activeEntries, ...disabledEntries].filter(e => includeMenu || !e.menu);
   return [null, { entries, total: entries.length }];
 };

package/server/utils/global-content/setGlobalContentLocked.js

@@ -1,22 +1,7 @@
 import { readFile, writeFile } from 'fs/promises';
 import { join } from 'path';
 import { existsSync } from 'fs';
-import { GLOBAL_FILE, parseEntries } from './helpers.js';
-
-const serializeEntries = entries => entries.map(e => {
-  const attrs = [
-    `id="${e.id}"`,
-    `name="${e.name}"`,
-    `owner="${e.owner}"`,
-    `author="${e.author}"`,
-    `created="${e.createdAt}"`,
-    `updated="${e.updatedAt}"`,
-    `locked="${e.locked}"`,
-    `location="${e.location}"`,
-    `priority="${e.priority}"`
-  ].join(' ');
-  return `<content ${attrs}>\n${e.markup}\n</content>`;
-}).join('\n');
+import { GLOBAL_FILE, parseEntries, serializeEntries } from './helpers.js';
 
 export default async ({ rootDir, id, locked }) => {
   if(!rootDir) return [{ code: 400, msg: 'Root directory is required' }, null];

package/server/utils/global-content/updateGlobalContent.js

@@ -1,24 +1,9 @@
 import { readFile, writeFile } from 'fs/promises';
 import { join } from 'path';
 import { existsSync } from 'fs';
-import { GLOBAL_FILE, parseEntries } from './helpers.js';
+import { GLOBAL_FILE, parseEntries, serializeEntries } from './helpers.js';
 import triggerHook from '../hooks/triggerHook.js';
 
-const serializeEntries = entries => entries.map(e => {
-  const attrs = [
-    `id="${e.id}"`,
-    `name="${e.name}"`,
-    `owner="${e.owner}"`,
-    `author="${e.author}"`,
-    `created="${e.createdAt}"`,
-    `updated="${e.updatedAt}"`,
-    `locked="${e.locked}"`,
-    `location="${e.location}"`,
-    `priority="${e.priority}"`
-  ].join(' ');
-  return `<content ${attrs}>\n${e.markup}\n</content>`;
-}).join('\n');
-
 export default async ({ rootDir, id, name, location, priority, markup }) => {
   if(!rootDir){
     return [{ code: 400, msg: 'Root directory is required' }, null];

package/server/utils/menus/adoptMenuItem.js

@@ -0,0 +1,58 @@
+import { readStores, writeStores, menuHome, isMenuDefinition } from './store.js';
+import { parseLink } from './markup.js';
+import saveMenu from './saveMenu.js';
+import triggerHook from '../hooks/triggerHook.js';
+
+/*
+  Moves an existing single link into a menu so it is managed on the Menus page. Only a single link
+  qualifies: anything else would lose what it is made of when the page rewrites it.
+
+  Without a `menuId` it goes into the menu already shown in the link's location; if there is none, a
+  menu named `menuName` is made and shown there, so the link stays exactly where it was on the site.
+*/
+export default async ({ rootDir, id, menuId, menuName, extensionDirs }) => {
+  if(!rootDir){
+    return [{ code: 400, msg: 'Root directory is required' }, null];
+  }
+  if(!id){
+    return [{ code: 400, msg: 'Global content ID is required' }, null];
+  }
+
+  let stores = await readStores(rootDir);
+  const entry = stores.active.find(e => e.id === id && !e.menu);
+  if(!entry){
+    return [{ code: 404, msg: 'Global content not found' }, null];
+  }
+  if(entry.owner !== 'custom'){
+    return [{ code: 403, msg: 'This belongs to an extension' }, null];
+  }
+  if(!parseLink(entry.markup)){
+    return [{ code: 400, msg: 'Only a single link can be managed as a menu item' }, null];
+  }
+
+  let target = menuId
+    ? stores.active.find(e => e.id === menuId && isMenuDefinition(e))
+    : stores.active.find(e => isMenuDefinition(e) && e.menuLocations.includes(entry.location));
+  if(menuId && !target){
+    return [{ code: 404, msg: 'Menu not found' }, null];
+  }
+
+  if(!target){
+    const [error, created] = await saveMenu({ rootDir, name: menuName || entry.location, extensionDirs });
+    if(error){
+      return [error, null];
+    }
+    stores = await readStores(rootDir);
+    target = stores.active.find(e => e.id === created.id);
+    target.menuLocations = [entry.location];
+  }
+
+  const live = stores.active.find(e => e.id === id);
+  live.menu = target.id;
+  live.location = menuHome(target.id);
+  live.updatedAt = new Date().toISOString();
+  await writeStores(rootDir, stores, extensionDirs);
+  await triggerHook('globalContent:updated', { id, updatedAt: live.updatedAt });
+
+  return [null, { id, menuId: target.id }];
+};

package/server/utils/menus/assignMenuLocation.js

@@ -0,0 +1,47 @@
+import { readStores, writeStores, isMenuDefinition } from './store.js';
+import findMenuLocations from './findMenuLocations.js';
+import triggerHook from '../hooks/triggerHook.js';
+
+/*
+  Chooses the menu shown in a location, or none when `menuId` is empty. A location shows one menu, so
+  choosing one takes the location from whichever menu had it; a menu can be chosen for several.
+  Only a place the theme marks as a menu can be newly assigned, so a typo cannot silently show nothing.
+*/
+export default async ({ rootDir, location, menuId, extensionDirs }) => {
+  if(!rootDir){
+    return [{ code: 400, msg: 'Root directory is required' }, null];
+  }
+  if(!location){
+    return [{ code: 400, msg: 'Location is required' }, null];
+  }
+
+  const stores = await readStores(rootDir);
+  const definitions = stores.active.filter(isMenuDefinition);
+  const target = menuId ? definitions.find(d => d.id === menuId) : null;
+  if(menuId && !target){
+    return [{ code: 404, msg: 'Menu not found' }, null];
+  }
+
+  if(target){
+    const [, declared] = await findMenuLocations({ rootDir });
+    if(!target.menuLocations.includes(location) && !declared.some(l => l.location === location)){
+      return [{ code: 400, msg: 'That place is not a menu in the theme' }, null];
+    }
+  }
+
+  const now = new Date().toISOString();
+  for(const definition of definitions){
+    if(!definition.menuLocations.includes(location)) continue;
+    definition.menuLocations = definition.menuLocations.filter(l => l !== location);
+    definition.updatedAt = now;
+  }
+  if(target){
+    target.menuLocations = [...target.menuLocations, location];
+    target.updatedAt = now;
+  }
+
+  await writeStores(rootDir, stores, extensionDirs);
+  await triggerHook('globalContent:updated', { id: target?.id ?? '', updatedAt: now });
+
+  return [null, { location, menuId: target?.id ?? null }];
+};

package/server/utils/menus/deleteMenu.js

@@ -0,0 +1,27 @@
+import { readStores, writeStores } from './store.js';
+import triggerHook from '../hooks/triggerHook.js';
+
+/*
+  Deletes a menu and all of its items. Where it was shown is left without a menu.
+*/
+export default async ({ rootDir, id, extensionDirs }) => {
+  if(!rootDir){
+    return [{ code: 400, msg: 'Root directory is required' }, null];
+  }
+  if(!id){
+    return [{ code: 400, msg: 'Menu ID is required' }, null];
+  }
+
+  const stores = await readStores(rootDir);
+  if(!stores.active.some(e => e.id === id && e.menuLocations !== null)){
+    return [{ code: 404, msg: 'Menu not found' }, null];
+  }
+
+  const removed = [...stores.active, ...stores.disabled].filter(e => e.menu === id).map(e => e.id);
+  stores.active = stores.active.filter(e => e.menu !== id);
+  stores.disabled = stores.disabled.filter(e => e.menu !== id);
+  await writeStores(rootDir, stores, extensionDirs);
+  for(const removedId of removed) await triggerHook('globalContent:deleted', { id: removedId });
+
+  return [null, { deleted: removed.length - 1 }];
+};

package/server/utils/menus/deleteMenuItems.js

@@ -0,0 +1,27 @@
+import { readStores, writeStores, isMenuItem } from './store.js';
+import triggerHook from '../hooks/triggerHook.js';
+
+export default async ({ rootDir, ids, extensionDirs }) => {
+  if(!rootDir){
+    return [{ code: 400, msg: 'Root directory is required' }, null];
+  }
+  if(!Array.isArray(ids) || !ids.length){
+    return [{ code: 400, msg: 'No IDs specified' }, null];
+  }
+
+  const stores = await readStores(rootDir);
+  const found = [...stores.active, ...stores.disabled].filter(e => ids.includes(e.id) && isMenuItem(e));
+  if(found.length !== new Set(ids).size){
+    return [{ code: 404, msg: 'Menu item not found' }, null];
+  }
+  if(found.some(e => e.locked)){
+    return [{ code: 403, msg: 'A locked item cannot be deleted' }, null];
+  }
+
+  stores.active = stores.active.filter(e => !ids.includes(e.id));
+  stores.disabled = stores.disabled.filter(e => !ids.includes(e.id));
+  await writeStores(rootDir, stores, extensionDirs);
+  for(const id of ids) await triggerHook('globalContent:deleted', { id });
+
+  return [null, { deleted: ids.length }];
+};

package/server/utils/menus/findMenuLocations.js

@@ -0,0 +1,41 @@
+import { readFile } from 'fs/promises';
+import scanDir from '../fs/scanDir.js';
+
+const LOCATION_TAG = /<location((?:[^>"']|"[^"]*"|'[^']*')*?)(?:\s*\/>|>[\s\S]*?<\/location>)/g;
+const SOURCE_FILE = /\.(template|fragment|page)\.html$/;
+
+/*
+  A location is a menu when the template, fragment or page that holds it says so:
+  `<location name="main-nav-links" label="Main menu" menu="true" />`. Looking in the site's own files
+  means the Menus page lists exactly the slots this site's theme has, and a theme with no menu slot
+  simply has no menus.
+*/
+export default async ({ rootDir }) => {
+  if(!rootDir){
+    return [{ code: 400, msg: 'Root directory is required' }, null];
+  }
+
+  const found = await scanDir(rootDir, rootDir, async (fullPath, entry) => {
+    if(entry.isDirectory() || !SOURCE_FILE.test(entry.name)) return null;
+    const content = await readFile(fullPath, 'utf-8');
+    const locations = [];
+    let match;
+    LOCATION_TAG.lastIndex = 0;
+    while((match = LOCATION_TAG.exec(content)) !== null){
+      const attr = name => {
+        const value = new RegExp(`(?:^|\\s)${name}=(?:"([^"]*)"|'([^']*)')`).exec(match[1]);
+        return value ? (value[1] ?? value[2]) : undefined;
+      };
+      if(attr('menu') !== 'true') continue;
+      locations.push({ location: attr('name') ?? 'default', label: attr('label') ?? '' });
+    }
+    return locations;
+  });
+
+  const byName = new Map();
+  for(const { location, label } of found){
+    if(!byName.has(location) || (!byName.get(location).label && label)) byName.set(location, { location, label: label || location });
+  }
+
+  return [null, [...byName.values()]];
+};

package/server/utils/menus/findNavItems.js

@@ -0,0 +1,74 @@
+import { readFile } from 'fs/promises';
+import { basename, dirname } from 'path';
+import scanDir from '../fs/scanDir.js';
+
+const WRAPPER = /^\s*(?:<!--[\s\S]*?-->\s*)*<menu-item((?:[^>"']|"[^"]*"|'[^']*')*)>([\s\S]*)<\/menu-item>\s*$/;
+const ATTRIBUTE = /(\w[\w-]*)=(?:"([^"]*)"|'([^']*)')/g;
+const ID = /^[\w-]+$/;
+
+/*
+  What kempo itself offers, so it is there on every site and needs no extension. The spacer takes up
+  the space left in a menu that is laid out in a row, which pushes the items after it to the far side.
+*/
+const BUILT_IN = [{
+  key: 'kempo:spacer',
+  extension: 'kempo',
+  id: 'spacer',
+  label: 'Spacer',
+  description: 'A flexible gap that pushes the items after it to the far side of the menu, such as the account link to the right. For a menu laid out in a row.',
+  icon: '',
+  markup: '<div class="flex"></div>'
+}];
+
+/*
+  The items enabled extensions offer for a site's menus. An extension ships a `*.menu-item.html` file
+  anywhere in its `public/` folder:
+
+    <menu-item id="cart" label="Cart" description="The shopping cart." icon-src="/commerce/icons/shopping_cart.svg">
+      <k-commerce-cart-button></k-commerce-cart-button>
+    </menu-item>
+
+  `icon` is the name of an icon in the shared sets; `icon-src` is the path to an icon file the extension ships
+  (`/commerce/icons/shopping_cart.svg`), and wins when both are given.
+
+  Kempo's own items (a spacer) come first, always.
+
+  Its content is what is rendered where an admin puts the item. It may include a <script> for the
+  element it uses. An item is named `<extension>:<id>`, which is what a menu stores. A file with no
+  <menu-item> wrapper, or without an id and a label, is skipped rather than breaking the others.
+
+  `extensionDirs` overrides where extensions are read from, as for the other menu functions; each is
+  an extension's public folder, so its package name is the folder above it.
+*/
+export default async ({ extensionDirs } = {}) => {
+  const dirs = extensionDirs ?? await (await import('../extensions/contentDirs.js')).extensionPublicDirs();
+  const items = BUILT_IN.map(item => ({ ...item }));
+
+  for(const dir of dirs){
+    const extension = basename(dirname(dir));
+    const files = await scanDir(dir, dir, async (fullPath, entry) =>
+      !entry.isDirectory() && entry.name.endsWith('.menu-item.html') ? fullPath : null);
+
+    for(const file of files.sort()){
+      const match = WRAPPER.exec(await readFile(file, 'utf-8'));
+      if(!match) continue;
+      const attrs = {};
+      let a;
+      ATTRIBUTE.lastIndex = 0;
+      while((a = ATTRIBUTE.exec(match[1])) !== null) attrs[a[1]] = a[2] ?? a[3];
+      if(!ID.test(attrs.id || '') || !String(attrs.label || '').trim()) continue;
+      items.push({
+        key: `${extension}:${attrs.id}`,
+        extension,
+        id: attrs.id,
+        label: attrs.label.trim(),
+        description: attrs.description || '',
+        icon: attrs.icon || '',
+        iconSrc: attrs['icon-src'] || '',
+        markup: match[2].trim()
+      });
+    }
+  }
+
+  return [null, items];
+};

package/server/utils/menus/findPages.js

@@ -0,0 +1,73 @@
+import { readFile } from 'fs/promises';
+import { join, relative } from 'path';
+import scanDir from '../fs/scanDir.js';
+import parseFrontmatter from '../fs/parseFrontmatter.js';
+import listPages from '../pages/listPages.js';
+import { normalizeScopes } from '../extensions/scopes.js';
+
+/*
+  The enabled extensions that serve pages, as [{ name, root, kempo }]. Read from disk each time, as the
+  router does, so what is listed is what is answering.
+*/
+const enabledExtensions = async () => {
+  const [{ getEnabledExtensions }, { default: readKempoConfig }] = await Promise.all([
+    import('../extensions/scopeCache.js'),
+    import('../extensions/readKempoConfig.js'),
+  ]);
+  const found = [];
+  for(const { name } of await getEnabledExtensions()){
+    const root = join(process.cwd(), 'node_modules', name);
+    try {
+      found.push({ name, root, kempo: (await readKempoConfig(root)).kempo });
+    } catch { /* not readable: nothing is served from it */ }
+  }
+  return found;
+};
+
+/* The pages an extension serves under one of its scopes, as /scope/path/. */
+const pagesOfScope = async (root, { scope, dir }) => {
+  const base = join(root, dir);
+  return scanDir(base, base, async (fullPath, entry) => {
+    if(entry.isDirectory() || !entry.name.endsWith('.page.html')) return null;
+    const path = relative(base, fullPath).replace(/\\/g, '/').replace(/\.page\.html$/, '').replace(/(^|\/)index$/, '$1');
+    if(path.includes('[')) return null;
+    const content = await readFile(fullPath, 'utf-8');
+    const meta = parseFrontmatter(content);
+    if(meta.hidden === 'true') return null;
+    return {
+      url: `/${scope}/${path}`.replace(/\/\/+/g, '/'),
+      title: meta.title || content.match(/<page\s[^>]*title="([^"]*)"/)?.[1] || '',
+    };
+  });
+};
+
+/*
+  Every page a link can go to: the site's own, then those its extensions serve under their scopes
+  (/products/, /categories/, /commerce/cart/). A page with a [param] in its address has no one address and
+  is left out, and so are hidden and disabled pages. The site wins when both have an address.
+
+  `extensions` replaces what is read from disk, as [{ name, root, kempo }], for tests.
+*/
+export default async ({ rootDir, extensions }) => {
+  if(!rootDir){
+    return [{ code: 400, msg: 'Root directory is required' }, null];
+  }
+
+  const [, site] = await listPages({ rootDir, showHidden: false });
+  const pages = (site?.pages ?? [])
+    .filter(page => !page.disabled && !page.url.includes('['))
+    .map(page => ({ url: page.url, title: page.title || page.name || page.url, owner: page.owner }));
+
+  const seen = new Set(pages.map(page => page.url));
+  for(const { name, root, kempo } of extensions ?? await enabledExtensions()){
+    for(const scope of normalizeScopes(kempo)[1]){
+      for(const page of (await pagesOfScope(root, scope)).sort((a, b) => a.url.localeCompare(b.url))){
+        if(seen.has(page.url)) continue;
+        seen.add(page.url);
+        pages.push({ url: page.url, title: page.title || page.url, owner: name });
+      }
+    }
+  }
+
+  return [null, pages];
+};