@antelopejs/dms-frontend 0.3.1 → 0.3.3

package/README.md

@@ -29,7 +29,8 @@ loader's contract with a renderer has three parts:
   `templates/<renderer>/` — `templates/vue/` today. `TEMPLATE_FILES` in
   `src/config.ts` lists what is copied verbatim, and `src/materialize.ts`
   resolves the template root, copies it, materializes the frontend modules
-  under `frontend-modules/`, and writes `generated-frontend-modules.json` in
+  under `frontend-modules/`, and writes the files derived from them
+  (`src/derived-outputs.ts`), `generated-frontend-modules.json` first, in
   manifest-priority order.
 - **Generated server.** `templates/vue/server.mjs` and `templates/vue/server/`
   become the Node server that `ajs dms start` runs from the built workspace:
@@ -135,6 +136,27 @@ export default frontendModule;
 
 The SDK also exposes `use` for Vue plugins. Entries execute by descending manifest priority, then stable module id. Modules without `dms.frontend.ts` are skipped by the generated loader. Registered page keys match a route's `fullSlug`, request path, or `default`; unregistered pages and components use the generic card renderer.
 
+Within one setup, the first module to register a name keeps it. `ajs-dms dev` sets every module up again each time a change to a layer reaches the server renderer, into empty registries, so the next server render uses the edited component without a restart. A `setup` may therefore run more than once in a process: it should only register, and keep no state of its own between runs.
+
+### Declaring the loader releases a module supports
+
+A frontend module names the `@antelopejs/dms-frontend` releases it runs on in its own `package.json`, the way a package names the Node.js versions it supports:
+
+```json
+{
+  "name": "@acme/dms-billing-frontend-vue",
+  "engines": {
+    "@antelopejs/dms-frontend": ">=0.3.2 <0.4.0"
+  }
+}
+```
+
+`prepare`, `dev`, `build` and `verify-source` read it before they generate anything, whether the manifest was just fetched or replayed from the cache, and stop when this release falls outside a module's range: `dev`, `build` and `verify-source` exit 1, and `prepare` warns and exits 0, as it does for any setup it cannot complete. The message names each such module, its range and this release, rather than letting the build, the type-check or a render fail later on an API the release no longer has, or does not have yet. A prerelease is checked as the release it leads to: `0.4.0-next.1` is outside `<0.4.0`. A module that declares no range still loads, and a warning names it once. `start` checks nothing: it runs what `build` produced.
+
+Cap the range below the next breaking release, which is the next minor release while this package is 0.x, and widen it once the module has been checked against that release. A range left open to `<1.0.0` admits the very release that removes something the module calls.
+
+The range is an engine rather than a peer dependency: the generated workspace installs every module as a workspace package, and pnpm installs a workspace package's peer dependencies, optional ones included, so a peer on the loader would pull a copy of it into every workspace. Package managers ignore an engine they do not know, and so does a loader released before this check.
+
 ### Redirecting typed access refusals
 
 A backend can refuse a whole surface with a typed 403 whose body is a machine-readable code, such as a tenant access gate blocking a suspended workspace. A module that owns such a code registers where a refused page visit goes instead of the error page:
@@ -324,6 +346,15 @@ merged catalogs the application imports: the next server render uses them, and
 the open page applies them in place, without a reload. Adding or removing a
 locale reloads the page instead.
 
+The other files the workspace derives from every module follow their sources
+the same way. A file added to, changed in or removed from a module's `public/`
+is served, or no longer served, at once. Adding or removing an
+`app/config/shortcuts-registry.ts` or a `dms.frontend.ts` regenerates the
+aggregated shortcuts or the module loader, and the page reloads. A layer
+directory added to or removed from `layers/` is the exception: Vite reads the
+`#<layer>` aliases and the auto-imported directories at startup only, so the
+dev server says it needs a restart.
+
 ## Options
 
 | Option | Environment | Purpose |
@@ -358,6 +389,6 @@ ajs dms verify-source \
   --local-package @antelopejs/dms=/path/to/dms
 ```
 
-The verifier prints its generated workspace path, builds client, SSR, and email bundles, runs `vue-tsc`, renders eight DMS email templates, and checks that the email bundle excludes browser-only modules. It leaves the generated workspace in the temporary directory for inspection. It does not start a backend or publish packages. Repository development can invoke the same runner with `DMS_LAYER_SOURCE` through `pnpm test:real-source`.
+A supplied package whose declared range excludes this adapter version is refused before anything is installed (see [Declaring the loader releases a module supports](#declaring-the-loader-releases-a-module-supports)). The verifier prints its generated workspace path, builds client, SSR, and email bundles, runs `vue-tsc`, renders eight DMS email templates, and checks that the email bundle excludes browser-only modules. It leaves the generated workspace in the temporary directory for inspection. It does not start a backend or publish packages. Repository development can invoke the same runner with `DMS_LAYER_SOURCE` through `pnpm test:real-source`.
 
 Refresh rotation is single-flight within one frontend process. Horizontally scaled deployments must use sticky routing so a browser reaches the same process, or replace this process-local behavior with an external session adapter. It does not provide a distributed rotation guarantee.

package/dist/common.d.ts

@@ -6,5 +6,7 @@ export * from "./fs-sync";
 export * from "./manifest-secrets";
 export * from "./layer-watch";
 export * from "./materialize";
+export * from "./derived-outputs";
+export * from "./renderer-range";
 export * from "./workspace";
 export * from "./workspace-setup";

package/dist/common.js

@@ -22,5 +22,7 @@ __exportStar(require("./fs-sync"), exports);
 __exportStar(require("./manifest-secrets"), exports);
 __exportStar(require("./layer-watch"), exports);
 __exportStar(require("./materialize"), exports);
+__exportStar(require("./derived-outputs"), exports);
+__exportStar(require("./renderer-range"), exports);
 __exportStar(require("./workspace"), exports);
 __exportStar(require("./workspace-setup"), exports);

package/dist/derived-outputs.d.ts

@@ -0,0 +1,22 @@
+import { FrontendModuleOptions, ResolvedLayer } from "./workspace";
+export interface FrontendModuleRegistryEntry {
+    id: string;
+    packageName?: string;
+    root: string;
+    priority: number;
+    entry?: string;
+    options: FrontendModuleOptions;
+}
+export interface FrontendModuleRegistry {
+    modules: FrontendModuleRegistryEntry[];
+}
+export declare function createFrontendModuleRegistry(workspaceDir: string, layers: ResolvedLayer[]): FrontendModuleRegistry;
+export declare function affectsLocaleMessages(relativePath: string): boolean;
+export declare function writeLocaleMessages(workspaceDir: string, registry: FrontendModuleRegistry): boolean;
+export interface DerivedOutput {
+    name: string;
+    affects(relativePath: string): boolean;
+    write(workspaceDir: string, registry: FrontendModuleRegistry): boolean;
+    restartNotice?: string;
+}
+export declare const DERIVED_OUTPUTS: readonly DerivedOutput[];

package/dist/derived-outputs.js

@@ -0,0 +1,296 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DERIVED_OUTPUTS = void 0;
+exports.createFrontendModuleRegistry = createFrontendModuleRegistry;
+exports.affectsLocaleMessages = affectsLocaleMessages;
+exports.writeLocaleMessages = writeLocaleMessages;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const config_1 = require("./config");
+const layer_aliases_1 = require("./layer-aliases");
+const layers_1 = require("./layers");
+const fs_sync_1 = require("./fs-sync");
+const GENERATED_MODULE_ID = /^[A-Za-z0-9_-]+$/;
+function validateFrontendModuleRegistry(registry, workspaceDir) {
+    const ids = new Set();
+    const moduleRoot = `${(0, node_path_1.resolve)(workspaceDir, config_1.LAYERS_SUBDIR)}${node_path_1.sep}`;
+    for (const module of registry.modules) {
+        if (!GENERATED_MODULE_ID.test(module.id) || ids.has(module.id))
+            throw new Error(`Invalid or duplicate frontend module id: ${module.id}`);
+        if (!Number.isFinite(module.priority))
+            throw new Error(`Invalid frontend module priority: ${module.id}`);
+        if (module.entry !== undefined && module.entry !== config_1.FRONTEND_MODULE_ENTRY)
+            throw new Error(`Invalid frontend module entry: ${module.id}`);
+        if (!(0, node_path_1.resolve)(module.root).startsWith(moduleRoot))
+            throw new Error(`Frontend module root escapes the workspace: ${module.id}`);
+        ids.add(module.id);
+    }
+}
+function createFrontendModuleRegistry(workspaceDir, layers) {
+    const modules = layers.map((layer) => {
+        const sourceEntry = (0, node_path_1.join)(layer.path, config_1.FRONTEND_MODULE_ENTRY);
+        const options = layer.options ?? {};
+        return {
+            id: (0, layers_1.getLayerSafeName)(layer),
+            packageName: layer.packageName,
+            root: (0, layers_1.getLayerWorkspacePath)(workspaceDir, layer),
+            priority: layer.priority ?? 0,
+            entry: (0, node_fs_1.existsSync)(sourceEntry) ? config_1.FRONTEND_MODULE_ENTRY : undefined,
+            options: layer.configKey ? { [layer.configKey]: options } : options,
+        };
+    });
+    modules.sort((left, right) => right.priority - left.priority || left.id.localeCompare(right.id));
+    const registry = { modules };
+    validateFrontendModuleRegistry(registry, workspaceDir);
+    return registry;
+}
+function writeFrontendTypePaths(workspaceDir, registry) {
+    const paths = {
+        "#dms/frontend-module": ["./frontend-module.ts"],
+        "@frontend/*": ["./frontend-modules/*"],
+        ...(0, layer_aliases_1.frontendLayerTypePaths)([...registry.modules].reverse().map((module) => module.root), { relativeTo: workspaceDir }),
+    };
+    const config = { compilerOptions: { paths } };
+    return (0, fs_sync_1.applyContent)(`${JSON.stringify(config, null, 2)}\n`, (0, node_path_1.join)(workspaceDir, "frontend-paths.generated.json"));
+}
+function writeFrontendModuleLoader(workspaceDir, registry) {
+    const modules = registry.modules.filter((module) => module.entry);
+    const imports = modules
+        .map((module, index) => `import module${index} from "@frontend/${module.id}/${module.entry}";`)
+        .join("\n");
+    const registrations = modules
+        .map((module, index) => `{ module: module${index}, options: { public: ${JSON.stringify(module.options)} } }`)
+        .join(", ");
+    const content = `${imports}\n\nimport type { DmsFrontendModuleRegistration } from "./frontend-module";\n\nexport const frontendModules: DmsFrontendModuleRegistration[] = [${registrations}];\n`;
+    return (0, fs_sync_1.applyContent)(content, (0, node_path_1.join)(workspaceDir, "frontend-modules.generated.ts"));
+}
+function writeModuleRegistry(workspaceDir, registry) {
+    const wroteRegistry = (0, fs_sync_1.applyContent)(`${JSON.stringify(registry, null, 2)}\n`, (0, node_path_1.join)(workspaceDir, "generated-frontend-modules.json"));
+    return writeFrontendModuleLoader(workspaceDir, registry) || wroteRegistry;
+}
+function moduleAssetRoots(moduleRoot) {
+    const layersRoot = (0, node_path_1.join)(moduleRoot, "layers");
+    if (!(0, node_fs_1.existsSync)(layersRoot)) {
+        return [{ absolutePath: moduleRoot, relativePrefix: "" }];
+    }
+    return (0, node_fs_1.readdirSync)(layersRoot).map((name) => ({
+        absolutePath: (0, node_path_1.join)(layersRoot, name),
+        relativePrefix: `layers/${name}/`,
+    }));
+}
+const PUBLIC_DIRECTORY = "public";
+function writePublicAssets(workspaceDir, registry) {
+    const files = new Map();
+    for (const module of [...registry.modules].reverse()) {
+        for (const root of moduleAssetRoots(module.root)) {
+            const source = (0, node_path_1.join)(root.absolutePath, PUBLIC_DIRECTORY);
+            for (const file of (0, fs_sync_1.collectFiles)(source)) {
+                files.set(file, (0, node_path_1.join)(source, file));
+            }
+        }
+    }
+    return (0, fs_sync_1.mirrorFiles)(files, (0, node_path_1.join)(workspaceDir, PUBLIC_DIRECTORY));
+}
+function discoverAssets(registry, directory, extensions) {
+    return registry.modules.flatMap((module) => {
+        return moduleAssetRoots(module.root).flatMap((assetRoot) => {
+            const root = (0, node_path_1.join)(assetRoot.absolutePath, directory);
+            return (0, fs_sync_1.collectFiles)(root)
+                .filter((file) => extensions.some((extension) => file.endsWith(extension)))
+                .sort()
+                .map((relativePath) => ({
+                moduleId: module.id,
+                relativePath: `${assetRoot.relativePrefix}${(0, fs_sync_1.toPosixPath)((0, node_path_1.join)(directory, relativePath))}`,
+            }));
+        });
+    });
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeLocaleMessages(source, existing) {
+    const merged = { ...source };
+    for (const [key, value] of Object.entries(existing)) {
+        const sourceValue = merged[key];
+        merged[key] =
+            isRecord(sourceValue) && isRecord(value)
+                ? mergeLocaleMessages(sourceValue, value)
+                : value;
+    }
+    return merged;
+}
+const LOCALE_DIRECTORY = "i18n/locales";
+function readLocaleFile(path) {
+    try {
+        return JSON.parse((0, node_fs_1.readFileSync)(path, "utf8"));
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid locale file ${path}: ${reason}`);
+    }
+}
+function readLocaleMessages(assets, registry) {
+    const roots = new Map(registry.modules.map((module) => [module.id, module.root]));
+    const messages = {};
+    for (const asset of assets) {
+        const locale = asset.relativePath.match(/(?:^|[/-])([a-z]{2})-[A-Z]{2}\.json$/)?.[1];
+        const root = roots.get(asset.moduleId);
+        if (!locale || !root)
+            continue;
+        const value = readLocaleFile((0, node_path_1.join)(root, asset.relativePath));
+        messages[locale] = mergeLocaleMessages(value, messages[locale] ?? {});
+    }
+    return messages;
+}
+function isLayerDirectory(relativePath) {
+    const segments = (0, fs_sync_1.toPosixPath)(relativePath).split("/");
+    return segments[0] === layer_aliases_1.MODULE_LAYERS_DIRNAME && segments.length <= 2;
+}
+function affectsAssetDirectory(directory, relativePath) {
+    if (isLayerDirectory(relativePath))
+        return true;
+    const segments = (0, fs_sync_1.toPosixPath)(relativePath).split("/");
+    const withinRoot = segments[0] === layer_aliases_1.MODULE_LAYERS_DIRNAME ? segments.slice(2) : segments;
+    return directory
+        .split("/")
+        .every((segment, index) => index >= withinRoot.length || withinRoot[index] === segment);
+}
+function affectsLocaleMessages(relativePath) {
+    return affectsAssetDirectory(LOCALE_DIRECTORY, relativePath);
+}
+function localeModuleSource(supportedLocales) {
+    const loaders = supportedLocales
+        .filter((locale) => locale !== "en")
+        .map((locale) => `  ${JSON.stringify(locale)}: () => import(${JSON.stringify(`./locales.generated/${locale}`)}),`);
+    return `import defaultMessages from "./locales.generated/en";
+
+type LocaleMessages = Record<string, unknown>;
+type LocaleLoader = () => Promise<{ default: LocaleMessages }>;
+interface LocaleMessagesTarget {
+  setLocaleMessage(locale: string, messages: LocaleMessages): void;
+}
+interface LocaleState {
+  messages: Record<string, LocaleMessages>;
+  targets: Set<LocaleMessagesTarget>;
+  version: number;
+}
+
+export const supportedLocales = ${JSON.stringify(supportedLocales)};
+const localeLoaders: Record<string, LocaleLoader> = {
+  "en": async () => ({ default: defaultMessages }),
+${loaders.join("\n")}
+};
+const shared: LocaleState | undefined = import.meta.hot?.data.state;
+const state: LocaleState = shared ?? {
+  messages: { en: defaultMessages },
+  targets: new Set(),
+  version: 0,
+};
+export const localeMessages = state.messages;
+
+async function readLocaleMessages(locale: string): Promise<LocaleMessages> {
+  return (await localeLoaders[locale]()).default;
+}
+
+export async function loadLocaleMessages(locale: string): Promise<LocaleMessages> {
+  const normalized = locale.slice(0, 2);
+  if (!localeLoaders[normalized]) return localeMessages.en;
+  localeMessages[normalized] ??= await readLocaleMessages(normalized);
+  return localeMessages[normalized];
+}
+
+/** Development only: applies every regenerated catalog to \`target\`. */
+export function syncLocaleMessages(target: LocaleMessagesTarget): void {
+  if (import.meta.hot) state.targets.add(target);
+}
+
+async function refreshLocaleMessages(): Promise<void> {
+  const version = ++state.version;
+  const locales = Object.keys(localeMessages).filter(
+    (locale) => locale in localeLoaders,
+  );
+  const catalogs = await Promise.all(locales.map(readLocaleMessages));
+  if (version !== state.version) return;
+  locales.forEach((locale, index) => {
+    localeMessages[locale] = catalogs[index];
+    for (const target of state.targets)
+      target.setLocaleMessage(locale, catalogs[index]);
+  });
+}
+
+if (import.meta.hot) {
+  import.meta.hot.data.state = state;
+  if (shared) void refreshLocaleMessages();
+  import.meta.hot.accept((next) => {
+    if (next?.supportedLocales.join() !== supportedLocales.join())
+      import.meta.hot?.invalidate("the list of locales changed");
+  });
+}
+`;
+}
+function writeLocaleMessages(workspaceDir, registry) {
+    const locales = discoverAssets(registry, LOCALE_DIRECTORY, [".json"]);
+    const messages = readLocaleMessages(locales, registry);
+    const outputDir = (0, node_path_1.join)(workspaceDir, "locales.generated");
+    const outputs = new Set();
+    let changed = false;
+    const apply = (content, path) => {
+        changed = (0, fs_sync_1.applyContent)(content, path) || changed;
+    };
+    (0, node_fs_1.mkdirSync)(outputDir, { recursive: true });
+    for (const [locale, value] of Object.entries(messages)) {
+        const catalog = JSON.stringify(value);
+        apply(catalog, (0, node_path_1.join)(outputDir, `${locale}.json`));
+        apply(`const messages = ${catalog};\nexport default messages;\n`, (0, node_path_1.join)(outputDir, `${locale}.ts`));
+        outputs.add(`${locale}.json`).add(`${locale}.ts`);
+    }
+    const supportedLocales = Object.keys(messages);
+    apply(JSON.stringify(supportedLocales), (0, node_path_1.join)(workspaceDir, "email-locales.generated.json"));
+    apply(localeModuleSource(supportedLocales), (0, node_path_1.join)(workspaceDir, "locales.generated.ts"));
+    for (const name of (0, node_fs_1.readdirSync)(outputDir)) {
+        if (outputs.has(name))
+            continue;
+        (0, node_fs_1.rmSync)((0, node_path_1.join)(outputDir, name), { recursive: true, force: true });
+        changed = true;
+    }
+    return changed;
+}
+const SHORTCUTS_DIRECTORY = "app/config";
+function writeShortcutExports(workspaceDir, registry) {
+    const registries = discoverAssets(registry, SHORTCUTS_DIRECTORY, [
+        "shortcuts-registry.ts",
+        "shortcuts-registry.js",
+    ]);
+    const imports = registries.map((asset, index) => `import registry${index} from "@frontend/${asset.moduleId}/${asset.relativePath}";`);
+    const spreads = registries.map((_, index) => `...registry${index}`);
+    const content = `${imports.join("\n")}\nconst aggregatedShortcuts = [${spreads.join(", ")}];\nexport { aggregatedShortcuts };\nexport default aggregatedShortcuts;\n`;
+    return (0, fs_sync_1.applyContent)(content, (0, node_path_1.join)(workspaceDir, "shortcuts-aggregated.generated.ts"));
+}
+exports.DERIVED_OUTPUTS = [
+    {
+        name: "module registry",
+        affects: (path) => (0, fs_sync_1.toPosixPath)(path) === config_1.FRONTEND_MODULE_ENTRY,
+        write: writeModuleRegistry,
+    },
+    {
+        name: "type paths",
+        affects: isLayerDirectory,
+        write: writeFrontendTypePaths,
+        restartNotice: "A layer directory was added or removed: restart 'ajs dms dev' to apply it. Vite reads the '#<layer>' aliases and the auto-imported directories at startup only.",
+    },
+    {
+        name: "locale catalogs",
+        affects: affectsLocaleMessages,
+        write: writeLocaleMessages,
+    },
+    {
+        name: "aggregated shortcuts",
+        affects: (path) => affectsAssetDirectory(SHORTCUTS_DIRECTORY, path),
+        write: writeShortcutExports,
+    },
+    {
+        name: "public assets",
+        affects: (path) => affectsAssetDirectory(PUBLIC_DIRECTORY, path),
+        write: writePublicAssets,
+    },
+];

package/dist/fs-sync.d.ts

@@ -3,7 +3,8 @@ export declare function toPosixPath(path: string, separator?: string): string;
 export declare function isBlocklistedCopyPath(src: string, srcPath: string): boolean;
 export declare function sanitizedPackageContent(raw: string): string;
 export declare function filesIdentical(srcPath: string, destPath: string): boolean;
-export declare function applyContent(content: string, destPath: string): void;
-export declare function applyFile(srcPath: string, destPath: string): void;
+export declare function applyContent(content: string, destPath: string): boolean;
+export declare function applyFile(srcPath: string, destPath: string): boolean;
+export declare function mirrorFiles(files: ReadonlyMap<string, string>, dest: string): boolean;
 export declare function collectFiles(dir: string, baseDir?: string): string[];
 export declare function syncDirectories(src: string, dest: string): void;

package/dist/fs-sync.js

@@ -10,6 +10,7 @@ exports.sanitizedPackageContent = sanitizedPackageContent;
 exports.filesIdentical = filesIdentical;
 exports.applyContent = applyContent;
 exports.applyFile = applyFile;
+exports.mirrorFiles = mirrorFiles;
 exports.collectFiles = collectFiles;
 exports.syncDirectories = syncDirectories;
 const node_fs_1 = require("node:fs");
@@ -59,7 +60,7 @@ function applyContent(content, destPath) {
     if ((0, node_fs_1.existsSync)(destPath)) {
         try {
             if ((0, node_fs_1.readFileSync)(destPath).equals(buf))
-                return;
+                return false;
         }
         catch {
         }
@@ -74,10 +75,11 @@ function applyContent(content, destPath) {
         if ((0, node_fs_1.existsSync)(tmp))
             (0, node_fs_1.rmSync)(tmp, { force: true });
     }
+    return true;
 }
 function applyFile(srcPath, destPath) {
     if (filesIdentical(srcPath, destPath))
-        return;
+        return false;
     (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(destPath), { recursive: true });
     const tmp = `${destPath}.ajs-dms-tmp-${process.pid}-${Date.now()}`;
     try {
@@ -88,6 +90,51 @@ function applyFile(srcPath, destPath) {
         if ((0, node_fs_1.existsSync)(tmp))
             (0, node_fs_1.rmSync)(tmp, { force: true });
     }
+    return true;
+}
+function clearWayTo(root, target) {
+    let cleared = false;
+    for (let dir = (0, node_path_1.dirname)(target); dir.length > root.length; dir = (0, node_path_1.dirname)(dir)) {
+        if ((0, node_fs_1.existsSync)(dir) && !(0, node_fs_1.statSync)(dir).isDirectory()) {
+            (0, node_fs_1.rmSync)(dir, { force: true });
+            cleared = true;
+        }
+    }
+    if ((0, node_fs_1.existsSync)(target) && (0, node_fs_1.statSync)(target).isDirectory()) {
+        (0, node_fs_1.rmSync)(target, { recursive: true, force: true });
+        cleared = true;
+    }
+    return cleared;
+}
+function pruneFiles(dir, keep, root = dir) {
+    let pruned = false;
+    for (const entry of (0, node_fs_1.readdirSync)(dir, { withFileTypes: true })) {
+        const path = (0, node_path_1.join)(dir, entry.name);
+        if (!entry.isDirectory()) {
+            if (keep.has((0, node_path_1.relative)(root, path)))
+                continue;
+            (0, node_fs_1.rmSync)(path, { force: true });
+            pruned = true;
+            continue;
+        }
+        pruned = pruneFiles(path, keep, root) || pruned;
+        if ((0, node_fs_1.readdirSync)(path).length === 0) {
+            (0, node_fs_1.rmSync)(path, { recursive: true, force: true });
+            pruned = true;
+        }
+    }
+    return pruned;
+}
+function mirrorFiles(files, dest) {
+    let changed = false;
+    for (const [file, source] of files) {
+        const target = (0, node_path_1.join)(dest, file);
+        changed = clearWayTo(dest, target) || changed;
+        changed = applyFile(source, target) || changed;
+    }
+    if (!(0, node_fs_1.existsSync)(dest))
+        return changed;
+    return pruneFiles(dest, new Set(files.keys())) || changed;
 }
 function loadGitignore(layerPath) {
     const ig = (0, ignore_1.default)();

package/dist/layer-watch.js

@@ -8,10 +8,10 @@ const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const chokidar_1 = __importDefault(require("chokidar"));
 const layers_1 = require("./layers");
-const materialize_1 = require("./materialize");
+const derived_outputs_1 = require("./derived-outputs");
 const fs_sync_1 = require("./fs-sync");
 const WATCH_DEBOUNCE_MS = 80;
-const LOCALE_REFRESH_DEBOUNCE_MS = 100;
+const DERIVED_REFRESH_DEBOUNCE_MS = 100;
 function createLayerSync(src, dest, onFlushed) {
     const fileUpserts = new Set();
     const fileDeletes = new Set();
@@ -133,23 +133,43 @@ function createLayerSync(src, dest, onFlushed) {
         },
     };
 }
-function createLocaleRefresher(workspaceDir, layers) {
-    const registry = (0, materialize_1.createFrontendModuleRegistry)(workspaceDir, layers);
+function createDerivedOutputRefresher(workspaceDir, layers) {
+    const pending = new Set();
     let timer = null;
+    const regenerate = (output, registry) => {
+        try {
+            if (output.write(workspaceDir, registry) && output.restartNotice)
+                console.warn(`[ajs-dms] ${output.restartNotice}`);
+        }
+        catch (err) {
+            console.warn(`[ajs-dms] ${output.name} not regenerated:`, err);
+        }
+    };
     const refresh = () => {
         timer = null;
+        const outputs = derived_outputs_1.DERIVED_OUTPUTS.filter((output) => pending.has(output));
+        pending.clear();
+        let registry;
         try {
-            (0, materialize_1.writeLocaleMessages)(workspaceDir, registry);
+            registry = (0, derived_outputs_1.createFrontendModuleRegistry)(workspaceDir, layers);
         }
         catch (err) {
-            console.warn("[ajs-dms] locale catalogs not regenerated:", err);
+            console.warn("[ajs-dms] derived files not regenerated:", err);
+            return;
         }
+        for (const output of outputs)
+            regenerate(output, registry);
     };
     return {
-        schedule() {
+        schedule(paths) {
+            const affected = derived_outputs_1.DERIVED_OUTPUTS.filter((output) => paths.some((path) => output.affects(path)));
+            if (affected.length === 0)
+                return;
+            for (const output of affected)
+                pending.add(output);
             if (timer)
                 clearTimeout(timer);
-            timer = setTimeout(refresh, LOCALE_REFRESH_DEBOUNCE_MS);
+            timer = setTimeout(refresh, DERIVED_REFRESH_DEBOUNCE_MS);
         },
         flushNow() {
             if (!timer)
@@ -162,16 +182,13 @@ function createLocaleRefresher(workspaceDir, layers) {
 function startLayerWatchers(workspaceDir, layers) {
     const watchers = [];
     const syncs = [];
-    const localeRefresher = createLocaleRefresher(workspaceDir, layers);
+    const refresher = createDerivedOutputRefresher(workspaceDir, layers);
     for (const layer of layers) {
         if (!layer.packageName)
             continue;
         const dest = (0, layers_1.getLayerWorkspacePath)(workspaceDir, layer);
         const src = layer.path;
-        const sync = createLayerSync(src, dest, (paths) => {
-            if (paths.some(materialize_1.affectsLocaleMessages))
-                localeRefresher.schedule();
-        });
+        const sync = createLayerSync(src, dest, (paths) => refresher.schedule(paths));
         syncs.push(sync);
         const watcher = chokidar_1.default.watch(src, {
             ignoreInitial: true,
@@ -189,6 +206,6 @@ function startLayerWatchers(workspaceDir, layers) {
         await Promise.all(watchers.map((w) => w.close().catch(() => { })));
         for (const sync of syncs)
             sync.flushNow();
-        localeRefresher.flushNow();
+        refresher.flushNow();
     };
 }

package/dist/layers.d.ts

@@ -2,6 +2,11 @@ import { ServedWithPath } from "./manifest";
 import { ManifestModule, ResolvedLayer } from "./workspace";
 export declare function assertLayerPathsServed(modules: ManifestModule[]): asserts modules is ServedWithPath[];
 export declare function assertCachedArchivesExist(modules: ManifestModule[], cacheDir: string, fetchedAt?: string): void;
+export interface LayerPackage {
+    name?: unknown;
+    engines?: Record<string, unknown>;
+}
+export declare function readLayerPackage(layerPath: string): LayerPackage | undefined;
 export declare function buildLayersFromPaths(modules: ManifestModule[]): ResolvedLayer[];
 export declare function downloadAndExtractLayers(backendUrl: string, packUrl: string, cacheDir: string, force: boolean, bootstrapSecret?: string): Promise<void>;
 export declare function buildLayersFromCache(modules: ManifestModule[], cacheDir: string): Promise<ResolvedLayer[]>;

package/dist/layers.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertLayerPathsServed = assertLayerPathsServed;
 exports.assertCachedArchivesExist = assertCachedArchivesExist;
+exports.readLayerPackage = readLayerPackage;
 exports.buildLayersFromPaths = buildLayersFromPaths;
 exports.downloadAndExtractLayers = downloadAndExtractLayers;
 exports.buildLayersFromCache = buildLayersFromCache;
@@ -40,18 +41,21 @@ function assertCachedArchivesExist(modules, cacheDir, fetchedAt) {
 function sortModulesByPriority(modules) {
     return [...modules].sort((a, b) => b.priority - a.priority);
 }
-function readLayerPackageName(layerPath) {
+function readLayerPackage(layerPath) {
     const pkgPath = (0, node_path_1.join)(layerPath, "package.json");
     if (!(0, node_fs_1.existsSync)(pkgPath))
         return undefined;
     try {
-        const pkg = JSON.parse((0, node_fs_1.readFileSync)(pkgPath, "utf-8"));
-        return typeof pkg.name === "string" ? pkg.name : undefined;
+        return JSON.parse((0, node_fs_1.readFileSync)(pkgPath, "utf-8"));
     }
     catch {
         return undefined;
     }
 }
+function readLayerPackageName(layerPath) {
+    const name = readLayerPackage(layerPath)?.name;
+    return typeof name === "string" ? name : undefined;
+}
 function resolveLayer(layerPath, mod) {
     return {
         path: layerPath,

package/dist/materialize.d.ts

@@ -1,22 +1,8 @@
-import { FrontendModuleOptions, ResolvedLayer } from "./workspace";
+import { ResolvedLayer } from "./workspace";
 export declare function getPackageRoot(): string;
 export declare function copyStaticTemplates(workspaceDir: string): void;
 export declare function writeWorkspacePackageJson(workspaceDir: string, layers: ResolvedLayer[]): void;
 export declare function materializeLayers(workspaceDir: string, layers: ResolvedLayer[]): void;
-export interface FrontendModuleRegistryEntry {
-    id: string;
-    packageName?: string;
-    root: string;
-    priority: number;
-    entry?: string;
-    options: FrontendModuleOptions;
-}
-export interface FrontendModuleRegistry {
-    modules: FrontendModuleRegistryEntry[];
-}
-export declare function createFrontendModuleRegistry(workspaceDir: string, layers: ResolvedLayer[]): FrontendModuleRegistry;
 export declare function collectAuthEstablishEndpoints(layers: ResolvedLayer[]): string[];
 export declare function writeFrontendModuleRegistry(workspaceDir: string, layers: ResolvedLayer[]): void;
-export declare function affectsLocaleMessages(relativePath: string): boolean;
-export declare function writeLocaleMessages(workspaceDir: string, registry: FrontendModuleRegistry): void;
 export declare function writeDmsMainCss(workspaceDir: string, layers: ResolvedLayer[]): void;