@morphemecms/cms 0.1.1-next-20261103223426 → 0.2.0

package/CHANGELOG.md

@@ -1,6 +1,11 @@
 # @morphemecms/cms
 
-## 0.1.1-next-20261103223426
+## 0.2.0
+
+### Minor Changes
+
+- 545e832: Themes and apps are installed from the Morpheme store, through the site's Worker (`/api/store/`); set the secret `MORPHEME_STORE_KEY` to connect a site. `store` in `src/site/config.ts` is gone, and a store theme may import CSS only from `@morphemecms/cms` and its own files.
+- 9dbb555: Builds on Windows: the theme's helpers `ui/dialog.ts`, `ui/bottomSheet.ts` and `ui/sideSheet.ts` are now `ui/dialogControl.ts`, `ui/bottomSheetControl.ts` and `ui/sideSheetControl.ts` (app API 2, theme API 3), the editor's screen data modules are `*Data.ts`, `worker/apps.js` with CRLF line endings passes the content check, and the check stops two files whose names differ only by case.
 
 ### Patch Changes
 

package/bin/morpheme.mjs

@@ -12,7 +12,7 @@ const COMMANDS = {
   'after-build': ['scheduled-list', 'link-counts', 'page-colors'],
   'check:content': ['check-content'],
   'check:editor': ['editor-roundtrip'],
-  'check:worker': ['check-worker', 'check-consent'],
+  'check:worker': ['check-worker', 'check-consent', 'check-store'],
   'check:screens': ['editor-screens'],
   'check:themes': ['check-themes'],
   'check:demo': ['check-demo'],

package/lib/apps.mjs

@@ -61,11 +61,14 @@ export function appWorkersFile(root) {
   ].join('\n');
 }
 
+/** The text with its line endings as \n, as git on Windows may check it out with \r\n. @param {string} text */
+const lf = (text) => text.replace(/\r\n/g, '\n');
+
 /** Writes worker/apps.js when it is not as it must be; true when it wrote it. @param {string} root */
 export function writeAppWorkers(root) {
   const file = join(root, WORKERS);
   const text = appWorkersFile(root);
-  if (existsSync(file) && readFileSync(file, 'utf8') === text) return false;
+  if (existsSync(file) && lf(readFileSync(file, 'utf8')) === text) return false;
   writeFileSync(file, text);
   return true;
 }
@@ -73,7 +76,7 @@ export function writeAppWorkers(root) {
 /** What is wrong with worker/apps.js (npm run check:content), as sentences. @param {string} root */
 export function appWorkersProblems(root) {
   const file = join(root, WORKERS);
-  return existsSync(file) && readFileSync(file, 'utf8') === appWorkersFile(root)
+  return existsSync(file) && lf(readFileSync(file, 'utf8')) === appWorkersFile(root)
     ? []
     : [`${WORKERS} passer ikke til appenes worker.js. Kør npx morpheme app-workers, og commit filen.`];
 }

package/lib/apps.test.d.mts

@@ -0,0 +1 @@
+export {};

package/lib/apps.test.mjs

@@ -0,0 +1,50 @@
+// Tests for worker/apps.js in lib/apps.mjs: appWorkersProblems and writeAppWorkers accept the file with CRLF line
+// endings (git on Windows) and still find and rewrite one that is out of date.
+import { describe, it, after, before } from 'node:test';
+import { strict as assert } from 'node:assert/strict';
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { appWorkersFile, appWorkersProblems, writeAppWorkers } from './apps.mjs';
+
+describe('lib/apps.mjs', () => {
+  let root;
+
+  before(() => {
+    root = mkdtempSync(join(tmpdir(), 'apps-'));
+    mkdirSync(join(root, 'src/apps/booking'), { recursive: true });
+    writeFileSync(join(root, 'src/apps/booking/worker.js'), 'export default {};\n');
+    mkdirSync(join(root, 'worker'), { recursive: true });
+  });
+
+  after(() => {
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  it('appWorkersProblems accepts worker/apps.js with CRLF line endings', () => {
+    const file = join(root, 'worker/apps.js');
+    writeFileSync(file, appWorkersFile(root).replace(/\n/g, '\r\n'));
+    assert.deepEqual(appWorkersProblems(root), []);
+  });
+
+  it('writeAppWorkers leaves worker/apps.js with CRLF line endings as it is', () => {
+    const file = join(root, 'worker/apps.js');
+    const crlfText = appWorkersFile(root).replace(/\n/g, '\r\n');
+    writeFileSync(file, crlfText);
+    assert.equal(writeAppWorkers(root), false);
+    assert.equal(readFileSync(file, 'utf8'), crlfText);
+  });
+
+  it('appWorkersProblems finds worker/apps.js out of date', () => {
+    const file = join(root, 'worker/apps.js');
+    writeFileSync(file, '// old\n');
+    assert.equal(appWorkersProblems(root).length, 1);
+  });
+
+  it('writeAppWorkers rewrites worker/apps.js out of date', () => {
+    const file = join(root, 'worker/apps.js');
+    writeFileSync(file, '// old\r\n');
+    assert.equal(writeAppWorkers(root), true);
+    assert.equal(readFileSync(file, 'utf8'), appWorkersFile(root));
+  });
+});

package/lib/caseCollisions.d.mts

@@ -0,0 +1,4 @@
+/** Groups of paths whose stems differ only by case, each sorted. @param {string[]} paths @returns {string[][]} */
+export function caseCollisions(paths: string[]): string[][];
+/** One Danish sentence per such group among the files under each dir (relative to root). @param {string} root @param {string[]} dirs */
+export function caseCollisionProblems(root: string, dirs: string[]): string[];

package/lib/caseCollisions.mjs

@@ -0,0 +1,62 @@
+// Files whose names differ only by case (Dialog.tsx beside dialog.ts): on a case-insensitive disk (Windows,
+// macOS) an import without its extension finds the wrong one. Exposes caseCollisions (pure) and caseCollisionProblems
+// (npm run check:content). Only node:fs and node:path.
+import { readdirSync, existsSync } from 'node:fs';
+import { join, relative } from 'node:path';
+
+/** A path without its last extension (theme/ui/Dialog.tsx -> theme/ui/Dialog). @param {string} path */
+function stemOf(path) {
+  const lastSlash = path.lastIndexOf('/');
+  const folder = lastSlash === -1 ? '' : path.slice(0, lastSlash + 1);
+  const name = lastSlash === -1 ? path : path.slice(lastSlash + 1);
+  const lastDot = name.lastIndexOf('.');
+  if (lastDot <= 0) return path;
+  return `${folder}${name.slice(0, lastDot)}`;
+}
+
+/** Groups of paths whose stems differ only by case, each sorted. @param {string[]} paths @returns {string[][]} */
+export function caseCollisions(paths) {
+  const groups = new Map();
+  for (const p of paths) {
+    const key = stemOf(p).toLowerCase();
+    if (!groups.has(key)) groups.set(key, new Set());
+    groups.get(key).add(stemOf(p));
+  }
+  const result = [];
+  for (const stems of groups.values()) {
+    if (stems.size >= 2) {
+      const group = paths.filter((p) => stems.has(stemOf(p))).sort();
+      result.push(group);
+    }
+  }
+  return result.sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
+}
+
+/** One Danish sentence per such group among the files under each dir (relative to root). @param {string} root @param {string[]} dirs */
+export function caseCollisionProblems(root, dirs) {
+  const problems = [];
+  for (const dir of dirs) {
+    const absDir = join(root, dir);
+    if (!existsSync(absDir)) continue;
+
+    const files = [];
+    const walk = (current) => {
+      for (const e of readdirSync(current, { withFileTypes: true })) {
+        if (e.isDirectory()) {
+          if (e.name !== 'node_modules' && !e.name.startsWith('.')) walk(join(current, e.name));
+        } else if (e.isFile()) {
+          const rel = relative(root, join(current, e.name)).split('\\').join('/');
+          files.push(rel);
+        }
+      }
+    };
+    walk(absDir);
+
+    for (const group of caseCollisions(files)) {
+      problems.push(
+        `${group.join(', ')}: navnene er ens, når store og små bogstaver ikke tæller, så en import uden filtype finder den forkerte på Windows og macOS. Giv den ene et andet navn.`,
+      );
+    }
+  }
+  return problems;
+}

package/lib/caseCollisions.test.d.mts

@@ -0,0 +1 @@
+export {};

package/lib/caseCollisions.test.mjs

@@ -0,0 +1,74 @@
+// Tests for lib/caseCollisions.mjs: which paths collide by case, and caseCollisionProblems on a folder,
+// skipping node_modules and taking a dir with the system's separators (Windows).
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { caseCollisions, caseCollisionProblems } from './caseCollisions.mjs';
+
+test('caseCollisions detects Dialog collision', () => {
+  const input = ['theme/ui/Dialog.tsx', 'theme/ui/dialog.ts', 'theme/ui/Button.tsx'];
+  const expected = [['theme/ui/Dialog.tsx', 'theme/ui/dialog.ts']];
+  assert.deepEqual(caseCollisions(input), expected);
+});
+
+test('caseCollisions no collision for different stems', () => {
+  const input = ['src/Redirects.tsx', 'src/redirectData.ts'];
+  assert.deepEqual(caseCollisions(input), []);
+});
+
+test('caseCollisions no collision for identical stems', () => {
+  const input = ['a.ts', 'a.tsx'];
+  assert.deepEqual(caseCollisions(input), []);
+});
+
+test('caseCollisions detects mixed collision', () => {
+  const input = ['x/A.ts', 'x/a.tsx', 'x/a.css'];
+  const expected = [['x/A.ts', 'x/a.css', 'x/a.tsx']];
+  assert.deepEqual(caseCollisions(input), expected);
+});
+
+test('caseCollisions no collision for different folders', () => {
+  const input = ['one/A.ts', 'two/a.ts'];
+  assert.deepEqual(caseCollisions(input), []);
+});
+
+test('caseCollisionProblems checks folder and skips node_modules', () => {
+  const root = mkdtempSync(join(tmpdir(), 'case-'));
+  try {
+    const base = join(root, 'pkg');
+    mkdirSync(join(base, 'ui'), { recursive: true });
+    writeFileSync(join(base, 'ui', 'Dialog.tsx'), '');
+    writeFileSync(join(base, 'ui', 'dialog.ts'), '');
+    writeFileSync(join(base, 'ui', 'Button.tsx'), '');
+
+    const nm = join(base, 'node_modules', 'x');
+    mkdirSync(nm, { recursive: true });
+    writeFileSync(join(nm, 'A.js'), '');
+    writeFileSync(join(nm, 'a.ts'), '');
+
+    const problems = caseCollisionProblems(root, ['pkg', 'missing']);
+    assert.equal(problems.length, 1);
+    assert.ok(problems[0].startsWith('pkg/ui/Dialog.tsx, pkg/ui/dialog.ts: '));
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('caseCollisionProblems takes a dir with the system separator', () => {
+  const root = mkdtempSync(join(tmpdir(), 'case-'));
+  try {
+    const base = join(root, 'pkg');
+    mkdirSync(join(base, 'ui'), { recursive: true });
+    writeFileSync(join(base, 'ui', 'Dialog.tsx'), '');
+    writeFileSync(join(base, 'ui', 'dialog.ts'), '');
+    writeFileSync(join(base, 'ui', 'Button.tsx'), '');
+
+    const problems = caseCollisionProblems(root, [join('pkg', 'ui')]);
+    assert.equal(problems.length, 1);
+    assert.ok(problems[0].startsWith('pkg/ui/Dialog.tsx, pkg/ui/dialog.ts: '));
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});

package/lib/contracts.d.mts

@@ -0,0 +1,15 @@
+/**
+ * Store contract versions: the API levels for apps and themes.
+ * Exposes APP_API and THEME_API.
+ */
+/** The version of the contract between the editor and an app (apps.ts: defineApp, its folder, and the theme's parts it
+ * draws with: the standard blocks' and the UI components, @theme/blocks/… and @theme/ui/…, imported from
+ * @morphemecms/cms): an app in the store says which it is written to, and only those the editor can run are
+ * offered. Raised when an app written to the one before no longer works. */
+export const APP_API: 2;
+/** The version of the contract between the editor and a theme (what a theme must and may have, "Hvad et tema må" in
+ * CLAUDE.md, themeProblems in packages/editor/site/theme.mjs, the standard theme's UI parts with Material 3's names and
+ * variants, the motion scheme's --motion-* springs and motionSpring/motionTiming (@morphemecms/cms/lib/motion),
+ * and the classes it styles): only themes written to it are offered. Raised when a theme written to the one before no
+ * longer works. */
+export const THEME_API: 3;

package/lib/contracts.mjs

@@ -0,0 +1,17 @@
+/**
+ * Store contract versions: the API levels for apps and themes.
+ * Exposes APP_API and THEME_API.
+ */
+
+/** The version of the contract between the editor and an app (apps.ts: defineApp, its folder, and the theme's parts it
+ * draws with: the standard blocks' and the UI components, @theme/blocks/… and @theme/ui/…, imported from
+ * @morphemecms/cms): an app in the store says which it is written to, and only those the editor can run are
+ * offered. Raised when an app written to the one before no longer works. */
+export const APP_API = 2;
+
+/** The version of the contract between the editor and a theme (what a theme must and may have, "Hvad et tema må" in
+ * CLAUDE.md, themeProblems in packages/editor/site/theme.mjs, the standard theme's UI parts with Material 3's names and
+ * variants, the motion scheme's --motion-* springs and motionSpring/motionTiming (@morphemecms/cms/lib/motion),
+ * and the classes it styles): only themes written to it are offered. Raised when a theme written to the one before no
+ * longer works. */
+export const THEME_API = 3;

package/lib/licenses.d.mts

@@ -120,7 +120,7 @@ export function licensesIntegration({ root, iconPacks, owners }: {
     iconPacks: () => IconPack[];
     owners: () => Promise<Owner[]>;
 }): import("astro").AstroIntegration;
-/** An app's or a theme's licences as the store's catalog has them (StoreLicenses in src/licenses.ts): its own licence's
+/** An app's or a theme's licences as the store's catalog has them (StoreLicenses in src/licenseData.ts): its own licence's
  * name, and each work's name, version, who made it, its licence's name and kind, without the texts.
  * @param {{ license?: string, thirdParty?: object[] }} manifest @param {{ folder: string, owner: string }} where */
 export function storeLicenses(manifest: {

package/lib/licenses.mjs

@@ -16,7 +16,7 @@
 // License asks to be passed on), else the licence's standard text (license-texts/<SPDX>.txt) with who made it; who made
 // it is its `author`, else its first contributor, the holder its licence's copyright line names, its first maintainer or
 // the owner of its repository.
-// The build writes dist/editor/licenses.json (LicensesFile in src/licenses.ts), which the editor fetches, and stops when
+// The build writes dist/editor/licenses.json (LicensesFile in src/licenseData.ts), which the editor fetches, and stops when
 // something shipped has no licence it can show. npm run check:content checks, before a build: every package the site's
 // and the editor's code imports, and what they depend on (codePackageProblems, more than is shipped, so nothing shipped
 // slips through) and each app's and theme's declaration (declarationProblems); the icon packs' manifests and licences
@@ -674,7 +674,7 @@ export function licensesIntegration({ root, iconPacks, owners }) {
 // ---------------------------------------------------------------------------------------------------
 // The store
 
-/** An app's or a theme's licences as the store's catalog has them (StoreLicenses in src/licenses.ts): its own licence's
+/** An app's or a theme's licences as the store's catalog has them (StoreLicenses in src/licenseData.ts): its own licence's
  * name, and each work's name, version, who made it, its licence's name and kind, without the texts.
  * @param {{ license?: string, thirdParty?: object[] }} manifest @param {{ folder: string, owner: string }} where */
 export function storeLicenses(manifest, where) {

package/lib/storeEntries.d.mts

@@ -0,0 +1,18 @@
+/**
+ * @param {any} x
+ * @param {number} api
+ * @returns {boolean}
+ */
+export function validApp(x: any, api: number): boolean;
+/**
+ * @param {any} x
+ * @param {number} api
+ * @returns {boolean}
+ */
+export function validTheme(x: any, api: number): boolean;
+export function isText(v: unknown): v is string;
+export function isPath(v: unknown): boolean;
+export const ITEM_ID: RegExp;
+export const REFUSED_APPS: string[];
+export const STANDARD: "saturn";
+export const RECORD: "store.json";

package/lib/storeEntries.mjs

@@ -0,0 +1,64 @@
+/**
+ * Pure validation logic for store apps and themes.
+ * Exposes isText, isPath, ITEM_ID, REFUSED_APPS, STANDARD, RECORD, validApp, validTheme.
+ * No external dependencies.
+ */
+
+/**
+ * @param {unknown} v
+ * @returns {v is string}
+ */
+export const isText = (v) => typeof v === 'string' && v.trim() !== '';
+
+/**
+ * @param {unknown} v
+ * @returns {boolean}
+ */
+export const isPath = (v) => isText(v) && v.split('/').every((part) => part !== '' && part !== '.' && part !== '..');
+
+export const ITEM_ID = /^[a-z0-9][a-z0-9-]*$/;
+// The store's address before and a developer's page (STORE_BEFORE and DEVELOPER_ROUTE in src/store.ts)
+export const REFUSED_APPS = ['butik', 'udvikler'];
+// The standard theme, which every site has
+export const STANDARD = 'saturn';
+// The note in an installed folder of where it came from
+export const RECORD = 'store.json';
+
+const isAdd = (v) => isText(v?.label) && isText(v?.icon);
+const isGoodFile = (f) => isText(f?.oid) && isPath(f?.path) && f.path !== RECORD;
+
+/**
+ * @param {any} x
+ * @param {number} api
+ * @returns {boolean}
+ */
+export function validApp(x, api) {
+  return (
+    ITEM_ID.test(x?.id ?? '') &&
+    !REFUSED_APPS.includes(x.id) &&
+    isText(x.version) &&
+    x.api === api &&
+    [x.label, x.publisher, x.icon, x.hint].every(isText) &&
+    Array.isArray(x.files) &&
+    x.files.length > 0 &&
+    x.files.every(isGoodFile) &&
+    ['blocks', 'lists', 'kinds'].every((k) => Array.isArray(x.adds?.[k]) && x.adds[k].every(isAdd))
+  );
+}
+
+/**
+ * @param {any} x
+ * @param {number} api
+ * @returns {boolean}
+ */
+export function validTheme(x, api) {
+  return (
+    ITEM_ID.test(x?.id ?? '') &&
+    x.id !== STANDARD &&
+    x.api === api &&
+    [x.version, x.name, x.author, x.icon].every(isText) &&
+    Array.isArray(x.files) &&
+    x.files.length > 0 &&
+    x.files.every(isGoodFile)
+  );
+}

package/lib/storeEntries.test.d.mts

@@ -0,0 +1 @@
+export {};

package/lib/storeEntries.test.mjs

@@ -0,0 +1,71 @@
+/**
+ * Tests for store entry validation logic (validApp, validTheme, isPath).
+ * Run with `node --test packages/editor/lib/*.test.mjs` (part of npm run check).
+ */
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { validApp, validTheme, isPath } from './storeEntries.mjs';
+
+const theme = () => ({
+  id: 'venus',
+  version: '1.0.0',
+  api: 4,
+  name: 'Venus',
+  author: 'Morpheme',
+  icon: 'palette',
+  files: [{ path: 'theme.json', oid: 'a'.repeat(40) }],
+});
+const app = () => ({
+  id: 'calendly',
+  version: '1.0.0',
+  api: 2,
+  label: 'Calendly',
+  publisher: 'Morpheme',
+  icon: 'event',
+  hint: 'Bookings',
+  files: [{ path: 'index.ts', oid: 'b'.repeat(40) }],
+  adds: { blocks: [{ label: 'Booking', icon: 'event' }], lists: [], kinds: [] },
+});
+
+test('valid theme', () => {
+  assert.equal(validTheme(theme(), 4), true);
+});
+
+test('valid theme wrong api', () => {
+  assert.equal(validTheme({ ...theme(), api: 3 }, 4), false);
+});
+
+test('valid theme standard id', () => {
+  assert.equal(validTheme({ ...theme(), id: 'saturn' }, 4), false);
+});
+
+test('valid theme bad path', () => {
+  assert.equal(validTheme({ ...theme(), files: [{ path: '../x', oid: 'a'.repeat(40) }] }, 4), false);
+});
+
+test('valid theme record path', () => {
+  assert.equal(validTheme({ ...theme(), files: [{ path: 'store.json', oid: 'a'.repeat(40) }] }, 4), false);
+});
+
+test('valid theme empty files', () => {
+  assert.equal(validTheme({ ...theme(), files: [] }, 4), false);
+});
+
+test('valid app', () => {
+  assert.equal(validApp(app(), 2), true);
+});
+
+test('valid app refused id', () => {
+  assert.equal(validApp({ ...app(), id: 'butik' }, 2), false);
+});
+
+test('valid app missing adds kinds', () => {
+  assert.equal(validApp({ ...app(), adds: { blocks: [], lists: [] } }, 2), false);
+});
+
+test('isPath cases', () => {
+  assert.equal(isPath('styles/global.css'), true);
+  assert.equal(isPath('a//b'), false);
+  assert.equal(isPath('./a'), false);
+  assert.equal(isPath(''), false);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morphemecms/cms",
-  "version": "0.1.1-next-20261103223426",
+  "version": "0.2.0",
   "description": "Morpheme CMS: the editor for a site built with Astro, its screens, its blocks and the rules a site gives it. See README.md.",
   "license": "MIT",
   "author": "Lars Adolfsen",

package/pages/editor/sw.js

@@ -1,4 +1,4 @@
-// The editor's service worker, only for its notifications on the phone or computer (packages/editor/src/notifications.ts):
+// The editor's service worker, only for its notifications on the phone or computer (packages/editor/src/notificationData.ts):
 // while the editor is open but not on screen, it shows them (on Android that works only through a service worker), and
 // when the site's Worker sends one (Web Push, packages/editor/worker/push.js: the site is updated after a save, an app's notification),
 // the browser wakes it, also when the editor is closed, and it shows that. It does not cache or touch any request.

package/scripts/built-site.mjs

@@ -1,9 +1,10 @@
 // The built site served on this computer, with what the editor asks of GitHub (through the site's Worker) answered from
-// the files in this repository, for the scripts that open the editor in a browser (editor-screens.mjs,
-// app-screenshots.mjs): no sign-in, and nothing changes.
+// the files in this repository, and the app store from a made-up catalog, for the scripts that open the editor in a
+// browser (editor-screens.mjs, app-screenshots.mjs): no sign-in, and nothing changes.
 import { createServer } from 'node:http';
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { extname, join, posix } from 'node:path';
+import { APP_API, THEME_API } from '../lib/contracts.mjs';
 
 const ROOT = `${process.cwd()}/`;
 
@@ -81,6 +82,35 @@ function workerAnswer(route, body, texts) {
   return null;
 }
 
+// The app store, as the site's Worker passes it on (packages/editor/worker/store.js), made up: one app and one theme in
+// the catalog's shape, and no file by any id.
+const STORE_CATALOG = {
+  apps: [
+    {
+      id: 'sample-app',
+      version: '1.0.0',
+      api: APP_API,
+      label: 'Sample app',
+      publisher: 'Example Studio',
+      icon: 'star',
+      hint: 'A made-up app for the checks.',
+      adds: { blocks: [], lists: [], kinds: [] },
+      files: [{ path: 'index.ts', oid: '0'.repeat(40) }],
+    },
+  ],
+  themes: [
+    {
+      id: 'sample-theme',
+      version: '1.0.0',
+      api: THEME_API,
+      name: 'Sample theme',
+      author: 'Example Studio',
+      icon: 'palette',
+      files: [{ path: 'theme.json', oid: '1'.repeat(40) }],
+    },
+  ],
+};
+
 /** Opens the editor (/editor/) of the site at `site` in `page`, signed in, with GitHub answered from the files on disk
  * (`texts`: some with other texts), and waits until it has loaded the site. */
 export async function openEditor(page, site, texts = {}) {
@@ -88,6 +118,11 @@ export async function openEditor(page, site, texts = {}) {
   await page.route(`${site}/api/r2?**`, (r) =>
     r.fulfill({ contentType: 'application/json', body: JSON.stringify({ bound: false, bucket: 'ready' }) }),
   );
+  await page.route(`${site}/api/store/**`, (r) =>
+    new URL(r.request().url()).pathname === '/api/store/catalog'
+      ? r.fulfill({ contentType: 'application/json', body: JSON.stringify(STORE_CATALOG) })
+      : r.fulfill({ status: 404 }),
+  );
   await page.route(`${site}/api/github/**`, (r) => {
     const route = new URL(r.request().url()).pathname.slice('/api/github/'.length);
     const found = workerAnswer(route, JSON.parse(r.request().postData() || '{}'), texts);

package/scripts/check-content.mjs

@@ -22,6 +22,7 @@ import {
   themeProblems,
 } from '@morphemecms/cms/site/theme.mjs';
 import { appFoldersPlugin, appIds, appWorkersProblems } from '@morphemecms/cms/lib/apps.mjs';
+import { caseCollisionProblems } from '@morphemecms/cms/lib/caseCollisions.mjs';
 import { codePackageProblems, declarationProblems, ownerId } from '@morphemecms/cms/lib/licenses.mjs';
 import { notesOf, releaseProblems } from './releases.mjs';
 
@@ -64,8 +65,7 @@ try {
   const { problemsOf, untranslated } = await server.ssrLoadModule('@morphemecms/cms/src/checkSite.ts');
   result = problemsOf(files);
   missing = untranslated();
-  const { config } = await server.ssrLoadModule('/src/site/config.ts');
-  if (config.store && existsSync(config.store.catalog)) catalog = JSON.parse(readFileSync(config.store.catalog, 'utf8'));
+  if (existsSync('store/catalog.json')) catalog = JSON.parse(readFileSync('store/catalog.json', 'utf8'));
   for (const id of appIds(root)) {
     const app = (await server.ssrLoadModule(`/src/apps/${id}/index.ts`)).default;
     for (const x of app.thirdParty ?? []) if (x?.package) declared.add(x.package);
@@ -116,6 +116,8 @@ result.problems.push(...allowedCspProblems());
 result.problems.push(...appCookieProblems());
 // The Worker has the part of each app that has one (worker/apps.js).
 result.problems.push(...appWorkersProblems(root));
+// No two files of the package or the site differ only by case (an import would find the wrong one on Windows).
+result.problems.push(...caseCollisionProblems(root, [own, 'src']));
 // Every app and theme says what its licence is and what it brings (the icon packs say theirs, themeProblems), and
 // every package the site's and the editor's code imports, and those they depend on, has a licence the editor can show
 // under "Licenser" (more than the build ships, which stops on its own when something it ships has none).