@gtkx/cli 1.6.0 → 2.0.0-beta.10

package/src/dev/runner-deps.ts

@@ -17,6 +17,7 @@ import { isRefreshBoundary, performRefresh, staleExportName } from "../refresh-r
 import { gtkxFastRefresh } from "../vite-plugins/fast-refresh/swc-refresh.js";
 import { gtkxVitePlugins } from "../vite-plugins/index.js";
 import { gtkxReactDomPrebundle } from "../vite-plugins/react-dom-prebundle.js";
+import { type CatalogWrites, createCatalogWrites } from "./catalog-writes.js";
 
 const DEV_MODE = "development";
 const APPLICATION_POLL_INTERVAL_MS = 50;
@@ -43,11 +44,22 @@ const waitForApplicationId = async (timeoutMs: number, shouldKeepWaiting: () =>
 
 const readFileRevision = (path: string): Promise<string> => readFile(path, "utf8");
 
-const defaultDevRunnerDeps = (): DevRunnerDeps => ({
+const devPlugins = (configFile: string, catalogWrites: CatalogWrites): DevRunnerDeps["plugins"] =>
+    (entryPath) => [
+        ...gtkxVitePlugins({ mode: DEV_MODE, entryPath, configFile, onCatalogsWritten: catalogWrites.record }),
+        ...gtkxFastRefresh(),
+        gtkxReactDomPrebundle(),
+    ];
+
+const createDevRunnerDeps = (
+    configFile: string,
+    deployOutDir: string | undefined,
+    catalogWrites: CatalogWrites,
+): DevRunnerDeps => ({
     createServer,
     waitForApplicationId,
     getConfiguredApplicationId: async (root: string) => {
-        const loaded = await loadConfig(root, { mode: DEV_MODE });
+        const loaded = await loadConfig(root, { mode: DEV_MODE, configFile });
 
         return loaded.config.applicationId;
     },
@@ -86,13 +98,14 @@ const defaultDevRunnerDeps = (): DevRunnerDeps => ({
     isRefreshBoundary,
     staleExportName,
     readFileRevision,
-    plugins: (entryPath) => [
-        ...gtkxVitePlugins(DEV_MODE, entryPath),
-        ...gtkxFastRefresh(),
-        gtkxReactDomPrebundle(),
-    ],
+    hasWrittenCatalog: catalogWrites.hasWritten,
+    deployOutDir,
+    plugins: devPlugins(configFile, catalogWrites),
     log: info,
     exit: (code: number): never => process.exit(code),
 });
 
+const defaultDevRunnerDeps = (configFile: string, deployOutDir: string | undefined): DevRunnerDeps =>
+    createDevRunnerDeps(configFile, deployOutDir, createCatalogWrites());
+
 export { defaultDevRunnerDeps };

package/src/dev/runner-main.ts

@@ -1,8 +1,8 @@
 import { loadConfig } from "@gtkx/config";
-import { resolveFuture } from "@gtkx/config/internal";
 import { error } from "@gtkx/utils";
 import { resolve } from "node:path";
-import { DEV_ENTRY_ENV } from "./entry-env.js";
+import { DEV_CONFIG_ENV, DEV_ENTRY_ENV } from "./entry-env.js";
+import { prepareDevFontDir } from "./font-dir.js";
 import { prepareDevIconDir } from "./icon-dir.js";
 import { prepareDevLocaleDir } from "./locale-dir.js";
 import { createDevRunner } from "./runner.js";
@@ -23,13 +23,21 @@ const main = async (): Promise<void> => {
         process.exit(1);
     }
 
-    const { config, root } = await loadConfig(cwd, { mode: "development" });
+    const configFile = process.env[DEV_CONFIG_ENV];
+
+    if (!configFile) {
+        error(`Missing ${DEV_CONFIG_ENV}`);
+        process.exit(1);
+    }
+
+    const { config, root } = await loadConfig(cwd, { mode: "development", configFile });
     prepareDevLocaleDir(root, config.applicationId);
-    prepareDevSchemaDir(root, resolveFuture(config.future).isResourceImported);
+    prepareDevSchemaDir(root);
     prepareDevIconDir(root, config.applicationId, config.applicationIcon);
+    prepareDevFontDir(root);
     const entryPath = resolve(cwd, entryArg);
     const { defaultDevRunnerDeps } = await import("./runner-deps.js");
-    const runner = createDevRunner(defaultDevRunnerDeps());
+    const runner = createDevRunner(defaultDevRunnerDeps(configFile, config.deploy?.outDir));
     await runner.run(entryPath);
 };
 

package/src/dev/runner.ts

@@ -2,6 +2,7 @@ import type { ApplicationInstance } from "@gtkx/runtime/internal";
 import type { InlineConfig, Plugin } from "vite";
 import { error, warn } from "@gtkx/utils";
 import { isCatalogSource } from "../i18n/catalogs.js";
+import { hasUnstagedFontImport } from "../internal/font-staging.js";
 import { loadModuleExclusively, withExclusiveLoad } from "../internal/module-loads.js";
 import { createChangeQueue, type WatchedChange } from "./change-queue.js";
 import { createFailureTracker, type FailureTracker } from "./failure-tracker.js";
@@ -33,6 +34,8 @@ type DevRunnerDeps = {
     isRefreshBoundary(module: Record<string, unknown>): boolean;
     staleExportName(previous: Record<string, unknown>, current: Record<string, unknown>): string | null;
     readFileRevision(path: string): Promise<string>;
+    hasWrittenCatalog(path: string): boolean;
+    deployOutDir: string | undefined;
     plugins(entryPath: string): Plugin[];
     log(message: string): void;
     exit(code: number): never;
@@ -370,21 +373,46 @@ const restartForServerConfig = async (session: DevSession, changedPath: string):
     await requestRestart(session);
 };
 
-const applyChange = async (session: DevSession, change: WatchedChange): Promise<void> => {
-    if (session.controller.isShuttingDown()) {
+const restartForFont = async (session: DevSession, changedPath: string): Promise<void> => {
+    session.deps.log(`Font import added: ${changedPath}`);
+    await requestRestart(session);
+};
+
+const restartForCatalog = async (session: DevSession, changedPath: string): Promise<void> => {
+    if (session.deps.hasWrittenCatalog(changedPath)) {
         return;
     }
 
-    if (isCatalogSource(session.server.config.root, change.path)) {
-        session.deps.log(`Translation catalog changed: ${change.path}`);
-        await requestRestart(session);
+    session.deps.log(`Translation catalog changed: ${changedPath}`);
+    await requestRestart(session);
+};
 
-        return;
+const didRestartForChange = async (session: DevSession, change: WatchedChange): Promise<boolean> => {
+    const { root } = session.server.config;
+
+    if (isCatalogSource(root, change.path)) {
+        await restartForCatalog(session, change.path);
+
+        return true;
     }
 
     if (isServerConfigFile(session.server.config, change.path)) {
         await restartForServerConfig(session, change.path);
 
+        return true;
+    }
+
+    if (change.event !== "unlink" && hasUnstagedFontImport(root, change.path)) {
+        await restartForFont(session, change.path);
+
+        return true;
+    }
+
+    return false;
+};
+
+const applyChange = async (session: DevSession, change: WatchedChange): Promise<void> => {
+    if (session.controller.isShuttingDown() || await didRestartForChange(session, change)) {
         return;
     }
 
@@ -610,7 +638,9 @@ const createSession = (server: DevServer, deps: DevRunnerDeps): DevSession => {
 
 const createDevRunner = (deps: DevRunnerDeps): DevRunner => ({
     async run(entryPath: string): Promise<void> {
-        const server = await deps.createServer(createDevServerConfig(process.cwd(), deps.plugins(entryPath)));
+        const server = await deps.createServer(
+            createDevServerConfig(process.cwd(), deps.deployOutDir, deps.plugins(entryPath)),
+        );
         const session = createSession(server, deps);
         deps.installShutdownHandlers(onShutdownSignal(session));
 

package/src/dev/schema-dir.ts

@@ -1,9 +1,7 @@
-import { resolveDataDir } from "../internal/data-dir.js";
 import { prependSchemaDir, stageAndCompileProjectSchemas } from "../settings/schema.js";
 
-const prepareDevSchemaDir = (root: string, isV2ResourceImports: boolean): string | null => {
-    const dataDir = isV2ResourceImports ? null : resolveDataDir(root);
-    const dir = stageAndCompileProjectSchemas(root, dataDir);
+const prepareDevSchemaDir = (root: string): string | null => {
+    const dir = stageAndCompileProjectSchemas(root);
 
     if (dir === null) {
         return null;

package/src/dev/supervisor.ts

@@ -1,9 +1,9 @@
 import { error, exitCodeForSignal, info, installGracefulShutdown } from "@gtkx/utils";
 import { fork as nodeFork } from "node:child_process";
-import { type FSWatcher, watch as watchFs } from "node:fs";
-import { basename, dirname } from "node:path";
+import { type FSWatcher, statSync, watch as watchFs } from "node:fs";
+import { basename, dirname, join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
-import { DEV_ENTRY_ENV } from "./entry-env.js";
+import { DEV_CONFIG_ENV, DEV_ENTRY_ENV } from "./entry-env.js";
 
 type SupervisedChild = {
     killed: boolean;
@@ -18,25 +18,31 @@ type ForkRunner = (modulePath: string, args: string[], env: NodeJS.ProcessEnv, c
 
 type DevWatch = {
     paths: string[];
-    regenerate: () => Promise<void>;
+    resolvePaths: () => string[];
+    regenerate: () => Promise<string[]>;
 };
 
 type SupervisorState = {
     runnerPath: string;
     entryPath: string;
+    configFile: string;
     cwd: string;
     args: string[];
     watch: DevWatch | undefined;
     watchers: FSWatcher[];
+    changedPaths: Set<string>;
+    restartTimer: DebounceTimer;
     fork: ForkRunner;
     child: SupervisedChild | null;
     isShuttingDown: boolean;
     isRestarting: boolean;
+    isRestartPending: boolean;
     capturedChildExit: number | undefined;
 };
 
 type DevSupervisorOptions = {
     entryPath: string;
+    configFile: string;
     cwd: string;
     args?: string[] | undefined;
     watch?: DevWatch | undefined;
@@ -128,7 +134,7 @@ const launch = (state: SupervisorState): void => {
     const child = state.fork(
         state.runnerPath,
         state.args,
-        { ...process.env, [DEV_ENTRY_ENV]: state.entryPath },
+        { ...process.env, [DEV_CONFIG_ENV]: state.configFile, [DEV_ENTRY_ENV]: state.entryPath },
         state.cwd,
     );
 
@@ -139,39 +145,94 @@ const launch = (state: SupervisorState): void => {
     });
 };
 
-const isRestartBlocked = (state: SupervisorState): boolean => state.isRestarting || state.isShuttingDown;
-
-const relaunchAfterExit = (state: SupervisorState): void => {
+const runPendingRestart = (state: SupervisorState): void => {
     state.isRestarting = false;
 
+    if (!state.isRestartPending || state.isShuttingDown) {
+        return;
+    }
+
+    state.isRestartPending = false;
+    void restart(state);
+};
+
+const relaunchAfterExit = (state: SupervisorState): void => {
     if (state.isShuttingDown) {
+        state.isRestarting = false;
+
         return;
     }
 
     info("Restarting dev runner...");
     launch(state);
+    runPendingRestart(state);
+};
+
+const isSupervisorShuttingDown = (state: SupervisorState): boolean => state.isShuttingDown;
+
+const reconcileConfigWatchers = (
+    state: SupervisorState,
+    paths: string[],
+    previous: ReadonlyMap<string, string | null>,
+): void => {
+    const changed = changedWatchPaths(previous, paths);
+
+    closeWatchers(state);
+
+    if (state.watch !== undefined) {
+        state.watch.paths = paths;
+    }
+
+    if (state.isShuttingDown) {
+        return;
+    }
+
+    installConfigWatchers(state);
+
+    if (changed.length > 0 && !state.isRestartPending) {
+        scheduleRestart(state, changed);
+    }
+};
+
+const consumeChangedPaths = (state: SupervisorState): string => {
+    const changed = [...state.changedPaths].map((path) => relative(state.cwd, path));
+    state.changedPaths.clear();
+
+    return changed.length === 0 ? basename(state.configFile) : changed.join(", ");
 };
 
 const restart = async (state: SupervisorState): Promise<void> => {
     const watch = state.watch;
 
-    if (watch === undefined || isRestartBlocked(state)) {
+    if (watch === undefined || state.isShuttingDown) {
+        return;
+    }
+
+    if (state.isRestarting) {
+        state.isRestartPending = true;
+
         return;
     }
 
     state.isRestarting = true;
-    info("gtkx.config.ts changed; regenerating bindings...");
+    info(`${consumeChangedPaths(state)} changed; regenerating bindings...`);
+    closeWatchers(state);
+    watch.paths = watch.resolvePaths();
+    const previous = snapshotWatchPaths(watch.paths);
+    installConfigWatchers(state);
 
     try {
-        await watch.regenerate();
+        const paths = await watch.regenerate();
+        reconcileConfigWatchers(state, paths, previous);
     } catch (error_) {
+        reconcileConfigWatchers(state, watch.resolvePaths(), previous);
         error("Codegen failed; keeping the current dev runner. Fix the error and save again.", error_);
-        state.isRestarting = false;
+        runPendingRestart(state);
 
         return;
     }
 
-    if (state.isShuttingDown) {
+    if (isSupervisorShuttingDown(state)) {
         state.isRestarting = false;
 
         return;
@@ -180,8 +241,8 @@ const restart = async (state: SupervisorState): Promise<void> => {
     const current = state.child;
 
     if (current === null) {
-        state.isRestarting = false;
         launch(state);
+        runPendingRestart(state);
 
         return;
     }
@@ -193,29 +254,103 @@ const restart = async (state: SupervisorState): Promise<void> => {
     forwardSignal(current, "SIGTERM");
 };
 
-const scheduleRestart = (state: SupervisorState, timer: DebounceTimer): void => {
+const scheduleRestart = (state: SupervisorState, changedPaths: string[] = []): void => {
+    const timer = state.restartTimer;
+
+    for (const path of changedPaths) {
+        state.changedPaths.add(path);
+    }
+
     if (timer.handle !== null) {
         clearTimeout(timer.handle);
     }
 
-    timer.handle = setTimeout(() => void restart(state), CONFIG_DEBOUNCE_MS);
+    timer.handle = setTimeout(() => {
+        timer.handle = null;
+        void restart(state);
+    }, CONFIG_DEBOUNCE_MS);
 };
 
-const isWatchedChange = (state: SupervisorState, names: Set<string>, filename: string | Buffer | null): boolean => {
+const watchedChangePath = (
+    state: SupervisorState,
+    directory: string,
+    names: Set<string>,
+    filename: string | Buffer | null,
+): string | undefined => {
     if (filename === null || state.isShuttingDown) {
+        return undefined;
+    }
+
+    const name = basename(filename.toString());
+
+    return names.has(name) ? join(directory, name) : undefined;
+};
+
+const isDirectory = (path: string): boolean => {
+    try {
+        return statSync(path, { throwIfNoEntry: false })?.isDirectory() === true;
+    } catch {
         return false;
     }
+};
 
-    return names.has(basename(filename.toString()));
+const nearestWatchTarget = (path: string): { directory: string; name: string } => {
+    let directory = dirname(path);
+    let name = basename(path);
+
+    while (!isDirectory(directory)) {
+        const parent = dirname(directory);
+
+        if (parent === directory) {
+            break;
+        }
+
+        name = basename(directory);
+        directory = parent;
+    }
+
+    return { directory, name };
 };
 
+const watchTargets = (paths: string[]): Set<string> =>
+    new Set(paths.flatMap((path) => {
+        const { directory, name } = nearestWatchTarget(path);
+
+        return [path, join(directory, name)];
+    }));
+
+const watchPathState = (path: string): string | null => {
+    try {
+        const stat = statSync(path, { bigint: true, throwIfNoEntry: false });
+
+        return stat === undefined
+            ? null
+            : [stat.dev, stat.ino, stat.mode, stat.size, stat.mtimeNs, stat.ctimeNs].join(":");
+    } catch {
+        return null;
+    }
+};
+
+const snapshotWatchPaths = (paths: string[]): Map<string, string | null> =>
+    new Map([...watchTargets(paths)].map((path) => [path, watchPathState(path)]));
+
+const changedWatchPaths = (
+    previous: ReadonlyMap<string, string | null>,
+    paths: string[],
+): string[] =>
+    [...watchTargets(paths)].filter((path) => {
+        const current = watchPathState(path);
+
+        return previous.has(path) ? previous.get(path) !== current : current !== null;
+    });
+
 const groupWatchNamesByDirectory = (paths: string[]): Map<string, Set<string>> => {
     const namesByDirectory: Map<string, Set<string>> = new Map();
 
     for (const path of paths) {
-        const directory = dirname(path);
+        const { directory, name } = nearestWatchTarget(path);
         const names = namesByDirectory.get(directory) ?? new Set<string>();
-        names.add(basename(path));
+        names.add(name);
         namesByDirectory.set(directory, names);
     }
 
@@ -226,16 +361,23 @@ const watchConfigDirectory = (
     state: SupervisorState,
     directory: string,
     names: Set<string>,
-    timer: DebounceTimer,
 ): void => {
-    const watcher = watchFs(directory, (_event, filename) => {
-        if (isWatchedChange(state, names, filename)) {
-            scheduleRestart(state, timer);
-        }
-    });
+    try {
+        const watcher = watchFs(directory, (_event, filename) => {
+            const changed = watchedChangePath(state, directory, names, filename);
+
+            if (changed !== undefined) {
+                scheduleRestart(state, [changed]);
+            }
+        });
 
-    watcher.on("error", (): void => undefined);
-    state.watchers.push(watcher);
+        watcher.on("error", (cause) => {
+            error(`Configuration watch failed for ${directory}`, cause);
+        });
+        state.watchers.push(watcher);
+    } catch (error_) {
+        error(`Configuration watch failed for ${directory}`, error_);
+    }
 };
 
 const installConfigWatchers = (state: SupervisorState): void => {
@@ -245,10 +387,8 @@ const installConfigWatchers = (state: SupervisorState): void => {
         return;
     }
 
-    const timer: DebounceTimer = { handle: null };
-
     for (const [directory, names] of groupWatchNamesByDirectory(watch.paths)) {
-        watchConfigDirectory(state, directory, names, timer);
+        watchConfigDirectory(state, directory, names);
     }
 };
 
@@ -256,6 +396,8 @@ const closeWatchers = (state: SupervisorState): void => {
     for (const watcher of state.watchers) {
         watcher.close();
     }
+
+    state.watchers = [];
 };
 
 const shutdownOnSignal = (state: SupervisorState, signal: NodeJS.Signals): Promise<void> =>
@@ -263,6 +405,11 @@ const shutdownOnSignal = (state: SupervisorState, signal: NodeJS.Signals): Promi
         state.isShuttingDown = true;
         closeWatchers(state);
 
+        if (state.restartTimer.handle !== null) {
+            clearTimeout(state.restartTimer.handle);
+            state.restartTimer.handle = null;
+        }
+
         if (!state.child) {
             resolve();
 
@@ -286,19 +433,23 @@ const installShutdown = (state: SupervisorState): void => {
 };
 
 const runDevSupervisor = async (options: DevSupervisorOptions): Promise<never> => {
-    const { entryPath, cwd, args = [], watch, fork = defaultForkRunner } = options;
+    const { entryPath, configFile, cwd, args = [], watch, fork = defaultForkRunner } = options;
 
     const state: SupervisorState = {
         runnerPath: fileURLToPath(DEV_RUNNER_URL),
         entryPath,
+        configFile,
         cwd,
         args,
         watch,
         watchers: [],
+        changedPaths: new Set(),
+        restartTimer: { handle: null },
         fork,
         child: null,
         isShuttingDown: false,
         isRestarting: false,
+        isRestartPending: false,
         capturedChildExit: undefined,
     };
 

package/src/dev/vite-dev-server.ts

@@ -1,5 +1,7 @@
 import type { InlineConfig, Plugin } from "vite";
+import { warn } from "@gtkx/utils";
 import { join } from "node:path";
+import { createWatchIgnore } from "./watch-ignore.js";
 
 type DevServerModule = object;
 type DevServerWatchEvent = "add" | "change" | "unlink";
@@ -59,13 +61,29 @@ const isServerConfigFile = (config: DevServerConfig, changedPath: string): boole
     return envFilesForMode(config).includes(changedPath);
 };
 
-const createDevServerConfig = (root: string, plugins: Plugin[]): InlineConfig => ({
+const watchErrorPlugin = (): Plugin => ({
+    name: "gtkx:watch-errors",
+    enforce: "pre",
+
+    configureServer(server) {
+        server.watcher.on("error", (cause) => {
+            warn("File watch error; the dev server keeps watching.", cause);
+        });
+    },
+});
+
+const createDevServerConfig = (
+    root: string,
+    deployOutDir: string | undefined,
+    plugins: Plugin[],
+): InlineConfig => ({
     root,
     appType: "custom",
-    plugins,
+    plugins: [watchErrorPlugin(), ...plugins],
     server: {
         middlewareMode: true,
         watch: {
+            ignored: createWatchIgnore(root, deployOutDir),
             awaitWriteFinish: {
                 stabilityThreshold: WRITE_STABILITY_THRESHOLD_MS,
                 pollInterval: WRITE_POLL_INTERVAL_MS,

package/src/dev/watch-ignore.ts

@@ -0,0 +1,16 @@
+import { isPathInside, isPathWithin } from "@gtkx/utils";
+import { resolve } from "node:path";
+import { deployOutDirFor } from "../internal/deploy-out-dir.js";
+
+const REFERENCE_DIR = ".gtkx";
+
+const createWatchIgnore = (root: string, deployOutDir: string | undefined): ((path: string) => boolean) => {
+    const projectRoot = resolve(root);
+    const generated = [deployOutDirFor(projectRoot, deployOutDir), resolve(projectRoot, REFERENCE_DIR)].filter(
+        (directory) => isPathInside(projectRoot, directory),
+    );
+
+    return (path) => generated.some((directory) => isPathWithin(directory, resolve(path)));
+};
+
+export { createWatchIgnore };

package/src/i18n/catalogs.ts

@@ -1,3 +1,4 @@
+import { isPathInside } from "@gtkx/utils";
 import {
     chmodSync,
     existsSync,
@@ -27,11 +28,17 @@ type CatalogProject = {
 };
 
 type PreparedCatalog = {
+    content: Buffer;
     isChanged: boolean;
     output: string;
     target: string;
 };
 
+type WrittenCatalog = {
+    content: Buffer;
+    path: string;
+};
+
 const PO_DIRNAME = "po";
 const LOCALE_DIRNAME = "locale";
 const LINGUAS_FILENAME = "LINGUAS";
@@ -132,6 +139,7 @@ const initializeCatalog = (catalog: Catalog, template: string, output: string):
             `--input=${template}`,
             `--output-file=${output}`,
         ],
+        options: { stdio: "pipe" },
         target: catalog.path,
     });
 };
@@ -163,16 +171,25 @@ const prepareCatalog = (
         initializeCatalog(catalog, template, output);
     }
 
+    const content = readFileSync(output);
+
     return {
-        isChanged: !isExisting || !readFileSync(output).equals(readFileSync(catalog.path)),
+        content,
+        isChanged: !isExisting || !content.equals(readFileSync(catalog.path)),
         output,
         target: catalog.path,
     };
 };
 
-const synchronizeCatalogs = (project: CatalogProject): void => {
+const replaceCatalog = (catalog: PreparedCatalog): WrittenCatalog => {
+    renameSync(catalog.output, catalog.target);
+
+    return { content: catalog.content, path: catalog.target };
+};
+
+const synchronizeCatalogs = (project: CatalogProject): WrittenCatalog[] => {
     if (project.catalogs.length === 0) {
-        return;
+        return [];
     }
 
     const template = join(project.poDir, `${project.domain}.pot`);
@@ -183,11 +200,7 @@ const synchronizeCatalogs = (project: CatalogProject): void => {
         const merged = project.catalogs.map((catalog, index) =>
             prepareCatalog(catalog, index, template, stagingDir));
 
-        for (const catalog of merged) {
-            if (catalog.isChanged) {
-                renameSync(catalog.output, catalog.target);
-            }
-        }
+        return merged.filter((catalog) => catalog.isChanged).map((catalog) => replaceCatalog(catalog));
     } finally {
         rmSync(stagingDir, { recursive: true, force: true });
     }
@@ -198,7 +211,7 @@ const isCatalogSource = (root: string, path: string): boolean => {
     const sourcePath = isAbsolute(path) ? resolve(path) : resolve(projectRoot, path);
     const poPath = relative(join(projectRoot, PO_DIRNAME), sourcePath);
 
-    if (poPath === "" || poPath === ".." || poPath.startsWith(`..${sep}`) || isAbsolute(poPath)) {
+    if (!isPathInside(join(projectRoot, PO_DIRNAME), sourcePath)) {
         return false;
     }
 
@@ -213,4 +226,5 @@ export {
     requiresCatalogInitialization,
     resolveCatalogProject,
     synchronizeCatalogs,
+    type WrittenCatalog,
 };