@gtkx/cli 1.2.2 → 1.4.0

package/src/deploy/settings/build-manifest.ts

@@ -0,0 +1,122 @@
+import { isRecord, sortStrings } from "@gtkx/utils";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import type { DeploySettings } from "../types.js";
+import {
+    BUILD_MANIFEST_FILENAME,
+    BUILD_MANIFEST_FORMAT_VERSION,
+    BUILD_MANIFEST_GENERATOR,
+    type BuildManifest,
+    type RecordedPackage,
+} from "../../internal/build-manifest.js";
+import {
+    assertUniqueSchemaBasenames,
+    projectRelativeSchemaPath,
+    SCHEMA_SUFFIX,
+} from "../../settings/schema.js";
+
+type ResolvedBuildManifest = {
+    packages: RecordedPackage[];
+    schemaFiles: string[];
+};
+
+const invalidManifest = (path: string): Error =>
+    new Error(`Cannot deploy: ${path} is not a valid GTKX build manifest. Run \`gtkx build\` again.`);
+
+const recordedSchemas = (value: unknown[], path: string): string[] =>
+    value.map((entry) => {
+        if (typeof entry !== "string") {
+            throw invalidManifest(path);
+        }
+
+        return entry;
+    });
+
+const recordedPackage = (value: unknown, path: string): RecordedPackage => {
+    if (
+        !isRecord(value) ||
+        typeof value.name !== "string" ||
+        typeof value.dir !== "string" ||
+        isAbsolute(value.dir) ||
+        (value.version !== null && typeof value.version !== "string")
+    ) {
+        throw invalidManifest(path);
+    }
+
+    return { name: value.name, version: value.version, dir: value.dir };
+};
+
+const parseBuildManifest = (value: unknown, path: string): BuildManifest => {
+    if (
+        !isRecord(value) ||
+        value.generator !== BUILD_MANIFEST_GENERATOR ||
+        value.formatVersion !== BUILD_MANIFEST_FORMAT_VERSION ||
+        !Array.isArray(value.schemas) ||
+        !Array.isArray(value.packages)
+    ) {
+        throw invalidManifest(path);
+    }
+
+    const packages: unknown[] = value.packages;
+
+    return {
+        generator: BUILD_MANIFEST_GENERATOR,
+        formatVersion: BUILD_MANIFEST_FORMAT_VERSION,
+        schemas: recordedSchemas(value.schemas, path),
+        packages: packages.map((entry) => recordedPackage(entry, path)),
+    };
+};
+
+const isFile = (path: string): boolean => {
+    try {
+        return statSync(path, { throwIfNoEntry: false })?.isFile() === true;
+    } catch {
+        return false;
+    }
+};
+
+const isInsideProject = (root: string, filePath: string): boolean => {
+    const rel = relative(root, filePath);
+
+    return rel.length > 0 && rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+};
+
+const resolveRecordedSchema = (root: string, manifestPath: string, entry: string): string => {
+    if (isAbsolute(entry) || !entry.endsWith(SCHEMA_SUFFIX)) {
+        throw new Error(`Cannot deploy: ${manifestPath} records an invalid GSettings schema path.`);
+    }
+
+    const filePath = resolve(root, entry);
+
+    if (!isInsideProject(root, filePath)) {
+        throw new Error(`Cannot deploy: ${manifestPath} records a GSettings schema outside the project.`);
+    }
+
+    if (!isFile(filePath)) {
+        throw new Error(`Cannot deploy: the recorded GSettings schema ${filePath} is missing.`);
+    }
+
+    if (projectRelativeSchemaPath(root, filePath) === null) {
+        throw new Error(`Cannot deploy: ${manifestPath} records a GSettings schema outside the project.`);
+    }
+
+    return filePath;
+};
+
+const readBuildManifest = (settings: DeploySettings): ResolvedBuildManifest => {
+    const manifestPath = join(settings.paths.dist, BUILD_MANIFEST_FILENAME);
+
+    if (!existsSync(manifestPath)) {
+        throw new Error(`Cannot deploy: ${manifestPath} is missing. Run \`gtkx build\` first.`);
+    }
+
+    const parsed: unknown = JSON.parse(readFileSync(manifestPath, "utf8"));
+    const manifest = parseBuildManifest(parsed, manifestPath);
+    const files = manifest.schemas.map((entry) => resolveRecordedSchema(settings.paths.root, manifestPath, entry));
+    const unique = sortStrings(new Set(files));
+    assertUniqueSchemaBasenames(unique);
+
+    return { packages: manifest.packages, schemaFiles: unique };
+};
+
+export { readBuildManifest };

package/src/deploy/settings/index.ts

@@ -22,6 +22,7 @@ import {
     resolveSummary,
     resolveVersionString,
 } from "./identity.js";
+import { resolveLibraries } from "./libraries.js";
 import { readPackageManifest } from "./package-manifest.js";
 import { resolvePaths } from "./paths.js";
 import { resolveScreenshots } from "./screenshots.js";
@@ -113,8 +114,6 @@ const resolveDesktopActions = (deploy: DeployConfig): DeployDesktopAction[] =>
         icon: action.icon ?? null,
     }));
 
-const resolveLibraries = (config: Config): string[] => (Array.isArray(config.libraries) ? config.libraries : []);
-
 const identitySlice = ({ identity, developer, date }: ResolvedCore): IdentitySlice => ({
     applicationId: identity.applicationId,
     binaryName: resolveBinaryName(identity),
@@ -181,8 +180,14 @@ const resolveDeploySettings = (request: SettingsRequest): DeploySettings => {
         extraFiles: resolveExtraFiles(deploy),
         versions: core.versions,
         arch: resolveArch(),
-        paths: resolvePaths({ root: request.root, deploy, outDirOverride: request.outDirOverride }),
-        libraries: resolveLibraries(request.config),
+        paths: resolvePaths({
+            root: request.root,
+            deploy,
+            applicationIcon: request.config.applicationIcon,
+            applicationId: request.config.applicationId,
+            outDirOverride: request.outDirOverride,
+        }),
+        ...resolveLibraries(request.root, request.config),
         deploy,
     };
 };

package/src/deploy/settings/libraries.ts

@@ -0,0 +1,57 @@
+import type { Config } from "@gtkx/config";
+import {
+    resolveLibraries as expandLibraries,
+    type GeneratedLibraries,
+    readGeneratedLibraries,
+    resolveGirPath,
+    resolveStore,
+} from "@gtkx/codegen";
+
+type ResolvedLibraries = {
+    libraries: string[];
+    minimumLibraryVersions: Record<string, string>;
+};
+
+const DEFAULT_LIBRARY = "Gtk-4.0";
+const DEFAULT_LIBRARY_PREFIX = "Gtk-";
+
+const generatedLibraries = (root: string): GeneratedLibraries | null => {
+    try {
+        return readGeneratedLibraries(resolveStore(root).gi.storeDir);
+    } catch {
+        return null;
+    }
+};
+
+const discoveredLibraries = (config: Config): string[] | null => {
+    try {
+        return expandLibraries(config.libraries, resolveGirPath(config.girPath));
+    } catch {
+        return null;
+    }
+};
+
+const configLibraries = (config: Config): string[] => {
+    const libraries = config.libraries;
+
+    if (!Array.isArray(libraries)) {
+        return discoveredLibraries(config) ?? [DEFAULT_LIBRARY];
+    }
+
+    return libraries.some((library) => library.startsWith(DEFAULT_LIBRARY_PREFIX))
+        ? [...libraries]
+        : [DEFAULT_LIBRARY, ...libraries];
+};
+
+const resolveLibraries = (root: string, config: Config): ResolvedLibraries => {
+    const generated = generatedLibraries(root);
+    const libraries = generated?.libraries ?? configLibraries(config);
+    const deploy = config.deploy ?? {};
+
+    return {
+        libraries,
+        minimumLibraryVersions: deploy.minimumLibraryVersions ?? {},
+    };
+};
+
+export { resolveLibraries };

package/src/deploy/settings/paths.ts

@@ -1,23 +1,19 @@
-import { type Stats, statSync } from "node:fs";
+import type { Config } from "@gtkx/config";
+import { statSync } from "node:fs";
 import { isAbsolute, join, relative, resolve } from "node:path";
 import type { DeployConfig, DeployPaths } from "../types.js";
-import { resolveDataDir } from "../../internal/data-dir.js";
-import { findSchemaFiles } from "../../settings/schema.js";
+import { resolveApplicationIcon } from "../../internal/icon-path.js";
 
 type PathsRequest = {
     root: string;
     deploy: DeployConfig;
+    applicationIcon: Config["applicationIcon"];
+    applicationId: Config["applicationId"];
     outDirOverride: string | undefined;
 };
 
-type ResolvedIcons = {
-    iconsDir: string | null;
-    iconFile: string | null;
-};
-
 const DEFAULT_OUT_DIR = "build";
 const DIST_DIR = "dist";
-const ICONS_DIR = "icons";
 const LICENSE_CANDIDATES = ["LICENSE", "LICENSE.md", "LICENSE.txt", "COPYING", "COPYING.md"];
 
 const isInside = (parent: string, candidate: string): boolean => {
@@ -37,17 +33,14 @@ const resolveOutDir = ({ root, deploy, outDirOverride }: PathsRequest): string =
     return outDir;
 };
 
-const getStats = (path: string): Stats | undefined => {
+const existingFile = (path: string): string | null => {
     try {
-        return statSync(path, { throwIfNoEntry: false });
+        return statSync(path, { throwIfNoEntry: false })?.isFile() === true ? path : null;
     } catch {
-        return undefined;
+        return null;
     }
 };
 
-const existingFile = (path: string): string | null => (getStats(path)?.isFile() === true ? path : null);
-const existingDir = (path: string): string | null => (getStats(path)?.isDirectory() === true ? path : null);
-
 const resolveLicenseFile = (root: string, configured: string | undefined): string | null => {
     if (configured !== undefined) {
         const path = resolve(root, configured);
@@ -62,37 +55,9 @@ const resolveLicenseFile = (root: string, configured: string | undefined): strin
     return LICENSE_CANDIDATES.map((name) => existingFile(join(root, name))).find((path) => path !== null) ?? null;
 };
 
-const configuredIcons = (root: string, configured: string): ResolvedIcons => {
-    const path = resolve(root, configured);
-
-    if (!isInside(root, path)) {
-        throw new Error(`Cannot use "${configured}" as the icon path: it is outside ${root}`);
-    }
-
-    if (existingDir(path) !== null) {
-        return { iconsDir: path, iconFile: null };
-    }
-
-    if (existingFile(path) === null) {
-        throw new Error(`Cannot read the icon path "${configured}": no such file or directory under ${root}`);
-    }
-
-    return { iconsDir: null, iconFile: path };
-};
-
-const defaultIcons = (root: string, dataDir: string | null): ResolvedIcons => ({
-    iconsDir: dataDir === null ? null : existingDir(join(root, dataDir, ICONS_DIR)),
-    iconFile: null,
-});
-
-const resolveIcons = (root: string, dataDir: string | null, configured: string | undefined): ResolvedIcons =>
-    configured === undefined ? defaultIcons(root, dataDir) : configuredIcons(root, configured);
-
 const resolvePaths = (request: PathsRequest): DeployPaths => {
     const { root, deploy } = request;
     const outDir = resolveOutDir(request);
-    const dataDir = resolveDataDir(root);
-    const { iconsDir, iconFile } = resolveIcons(root, dataDir, deploy.icons);
 
     return {
         root,
@@ -104,11 +69,9 @@ const resolvePaths = (request: PathsRequest): DeployPaths => {
         overlay: join(outDir, "overlay"),
         targets: join(outDir, "targets"),
         output: join(outDir, "out"),
-        dataDir,
-        iconsDir,
-        iconFile,
+        applicationIcon: resolveApplicationIcon(root, request.applicationId, request.applicationIcon),
         licenseFile: resolveLicenseFile(root, deploy.licenseFile),
-        schemaFiles: dataDir === null ? [] : findSchemaFiles(join(root, dataDir)),
+        schemaFiles: [],
     };
 };
 

package/src/deploy/targets/appimage.ts

@@ -1,5 +1,5 @@
 import { existsSync, mkdirSync, rmSync, statSync } from "node:fs";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import type {
     DeployArtifact,
     DeployManifest,
@@ -10,18 +10,21 @@ import type {
 } from "../types.js";
 import { runCliTool } from "../../internal/run-cli-tool.js";
 import { copyInto, copyTree, EXECUTABLE_MODE, writeInto } from "../payload/copy-tree.js";
-import { getIconSize } from "../payload/icons.js";
+import { type ApplicationIconVariant, classifyApplicationIcon } from "../payload/icons.js";
 import { FILE_TOOL } from "../tools.js";
 import { resolveAppimageTooling } from "../vendored/appimagetool.js";
 
+type RankedIcon = {
+    file: StagedFile;
+    variant: ApplicationIconVariant;
+};
+
 const PREFIX = "/usr";
 const TARGET_DIR = "appimage";
 const APPRUN_FILENAME = "AppRun";
 const APPDIR_NAME = "AppDir";
 const USR_DIR = "usr";
-const ICON_EXTENSIONS = [".svg", ".png", ".xpm"];
 const EXTRACT_AND_RUN = "APPIMAGE_EXTRACT_AND_RUN";
-const SCALABLE_RANK = Number.MAX_SAFE_INTEGER;
 
 const appimageTarget: DeployTarget = {
     name: "appimage",
@@ -50,31 +53,45 @@ const renderManifests = (payload: DeployPayload): DeployManifest[] => [
     { path: appRunPathFor(payload.settings), contents: renderAppRun(payload.settings) },
 ];
 
-const iconRank = (file: StagedFile): number =>
-    file.rel.endsWith(".svg") ? SCALABLE_RANK : (getIconSize(file.rel) ?? 0);
+const rankedIcon = (applicationId: string, file: StagedFile): RankedIcon | null => {
+    const variant = classifyApplicationIcon(applicationId, file.rel);
+
+    return variant === null ? null : { file, variant };
+};
+
+const isLargerIcon = (candidate: RankedIcon, best: RankedIcon): boolean =>
+    candidate.variant.scalable === best.variant.scalable
+        ? candidate.variant.effectivePixels > best.variant.effectivePixels
+        : candidate.variant.scalable;
+
+const largerIcon = (best: RankedIcon | undefined, candidate: RankedIcon): RankedIcon =>
+    best === undefined || isLargerIcon(candidate, best) ? candidate : best;
 
-const largestIcon = (icons: StagedFile[]): StagedFile | undefined => {
-    let best: StagedFile | undefined;
+const largestIcon = (applicationId: string, files: StagedFile[]): StagedFile | undefined => {
+    let best: RankedIcon | undefined;
 
-    for (const file of icons) {
-        if (best === undefined || iconRank(file) > iconRank(best)) {
-            best = file;
+    for (const file of files) {
+        const candidate = rankedIcon(applicationId, file);
+
+        if (candidate === null) {
+            continue;
         }
+
+        best = largerIcon(best, candidate);
     }
 
-    return best;
+    return best?.file;
 };
 
 const rootIconFor = (payload: DeployPayload): { rel: string; abs: string } => {
     const { applicationId } = payload.settings;
-    const names = new Set(ICON_EXTENSIONS.map((extension) => `${applicationId}${extension}`));
-    const icon = largestIcon(payload.stage.filter((file) => names.has(file.rel.split("/").at(-1) ?? "")));
+    const icon = largestIcon(applicationId, payload.stage);
 
     if (icon === undefined) {
         throw new Error(`Cannot build an AppImage without a ${applicationId} icon in the staged icon tree`);
     }
 
-    return { rel: icon.rel.split("/").at(-1) ?? "", abs: icon.abs };
+    return { rel: basename(icon.rel), abs: icon.abs };
 };
 
 const buildAppDir = (payload: DeployPayload): string => {

package/src/deploy/targets/flatpak-manifest.ts

@@ -110,6 +110,12 @@ const runtimeKeys = (settings: DeploySettings): FlatpakManifest => {
     };
 };
 
+const runtimeLabelFor = (settings: DeploySettings): string => {
+    const flatpak = settings.deploy.flatpak ?? {};
+
+    return `${flatpak.runtime ?? DEFAULT_RUNTIME}//${flatpak.runtimeVersion ?? DEFAULT_RUNTIME_VERSION}`;
+};
+
 const renderFlatpakManifest = (payload: DeployPayload): FlatpakManifest => {
     const settings = payload.settings;
 
@@ -123,4 +129,4 @@ const renderFlatpakManifest = (payload: DeployPayload): FlatpakManifest => {
     };
 };
 
-export { branchFor, finishArgsFor, hasDisplaySocket, renderFlatpakManifest };
+export { branchFor, finishArgsFor, hasDisplaySocket, renderFlatpakManifest, runtimeLabelFor };

package/src/deploy/targets/flatpak-pnpm.ts

@@ -9,12 +9,12 @@ type PnpmPin = {
     sha512: string;
 };
 
-const PNPM_VERSION = "11.21.0";
+const PNPM_VERSION = "11.22.0";
 const PNPM_MAJOR = 11;
-const PNPM_MINOR = 21;
+const PNPM_MINOR = 22;
 
-const PNPM_SHA512 = "521705bce689924eac72f5a3587122f362689ef6571e55ba80076fd637c11132ecffada26" +
-    "fad4ea79c485bfddbfd3d5a2a5b05805a77e893de71ec8a6cca3bb1";
+const PNPM_SHA512 = "1ff870c4c6133dfd88fb2afc46dd13d47f09c9794b438c6fdb47ca98caf3bc16381ee0be9" +
+    "3a091b8e3824cf01f889f46d7d9e20910fb0be1ab0fb5baa80dd621";
 
 const PNPM_DIR = "flatpak-pnpm";
 const PNPM_COMMAND = "pnpm";

package/src/deploy/targets/flatpak-source.ts

@@ -120,12 +120,11 @@ const metadataInstallCommands = (settings: DeploySettings): string[] => [
 const schemaInstallCommands = (settings: DeploySettings): string[] =>
     settings.paths.schemaFiles.map((file) => {
         const name = posix.basename(file);
+        const source = projectRelative(settings, file);
+        const destination = `${DESTINATION}/share/glib-2.0/schemas/${shellArgument(name)}`;
+        assertInsideProject(settings, { destination, source, resolved: file });
 
-        return installCommand(
-            projectRelative(settings, file),
-            `${DESTINATION}/share/glib-2.0/schemas/${shellArgument(name)}`,
-            "m644",
-        );
+        return installCommand(source, destination, "m644");
     });
 
 const iconInstallCommand = (settings: DeploySettings, source: string, rel: string): string =>
@@ -136,17 +135,17 @@ const iconInstallCommand = (settings: DeploySettings, source: string, rel: strin
     );
 
 const iconInstallCommands = (settings: DeploySettings): string[] => {
-    const { iconsDir, iconFile } = settings.paths;
+    const source = settings.paths.applicationIcon;
 
-    if (iconFile !== null) {
-        return [iconInstallCommand(settings, iconFile, iconPathFor(settings, iconFile))];
+    if (source.kind === "file") {
+        return [iconInstallCommand(settings, source.path, iconPathFor(settings, source.path))];
     }
 
-    if (iconsDir === null) {
+    if (source.kind === "none") {
         return [];
     }
 
-    return listFilesRecursive(iconsDir).map((icon) => iconInstallCommand(settings, icon.absPath, icon.rel));
+    return listFilesRecursive(source.path).map((icon) => iconInstallCommand(settings, icon.absPath, icon.rel));
 };
 
 const assertInsideProject = (settings: DeploySettings, installed: InstalledFile): void => {

package/src/deploy/types.ts

@@ -1,4 +1,5 @@
 import type { Config } from "@gtkx/config";
+import type { ResolvedApplicationIcon } from "../internal/icon-path.js";
 
 type DeployConfig = NonNullable<Config["deploy"]>;
 type DeployTargetName = NonNullable<DeployConfig["targets"]>[number];
@@ -21,7 +22,7 @@ type NodeRuntime = {
     path: string;
     licenseFile: string | null;
     version: string;
-    glibcFloor: string | null;
+    glibcMinimum: string | null;
     isStripped: boolean;
 };
 
@@ -106,9 +107,7 @@ type DeployPaths = {
     overlay: string;
     targets: string;
     output: string;
-    dataDir: string | null;
-    iconsDir: string | null;
-    iconFile: string | null;
+    applicationIcon: ResolvedApplicationIcon;
     licenseFile: string | null;
     schemaFiles: string[];
 };
@@ -145,6 +144,7 @@ type DeploySettings = {
     arch: DeployArch;
     paths: DeployPaths;
     libraries: string[];
+    minimumLibraryVersions: Record<string, string>;
     deploy: DeployConfig;
 };
 

package/src/dev/icon-dir.ts

@@ -1,18 +1,42 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { mkdirSync, symlinkSync } from "node:fs";
+import { dirname, join } from "node:path";
+import {
+    relativeIconPath,
+    resolveApplicationIcon,
+    type ResolvedApplicationIcon,
+} from "../internal/icon-path.js";
+import { createRetainedStagingDir } from "../internal/staging-dir.js";
 import { prependXdgDataDir } from "../internal/xdg-data-dirs.js";
 
-const prepareDevIconDir = (root: string, dataDir: string | null): string | null => {
-    if (dataDir === null) {
-        return null;
+const stageIconSource = (shareDir: string, applicationId: string, source: ResolvedApplicationIcon): void => {
+    if (source.kind === "theme") {
+        symlinkSync(source.path, join(shareDir, "icons"), "dir");
+
+        return;
+    }
+
+    if (source.kind === "none") {
+        return;
     }
 
-    const shareDir = join(root, dataDir);
+    const target = join(shareDir, "icons", relativeIconPath(applicationId, source.path));
+    mkdirSync(dirname(target), { recursive: true });
+    symlinkSync(source.path, target, "file");
+};
+
+const prepareDevIconDir = (
+    root: string,
+    applicationId: string,
+    configured: string | undefined,
+): string | null => {
+    const source = resolveApplicationIcon(root, applicationId, configured);
 
-    if (!existsSync(join(shareDir, "icons"))) {
+    if (source.kind === "none") {
         return null;
     }
 
+    const shareDir = createRetainedStagingDir("icons").retain();
+    stageIconSource(shareDir, applicationId, source);
     process.env.XDG_DATA_DIRS = prependXdgDataDir(shareDir, process.env.XDG_DATA_DIRS);
 
     return shareDir;

package/src/dev/runner-deps.ts

@@ -86,7 +86,11 @@ const defaultDevRunnerDeps = (): DevRunnerDeps => ({
     isRefreshBoundary,
     staleExportName,
     readFileRevision,
-    plugins: () => [...gtkxVitePlugins(DEV_MODE), ...gtkxFastRefresh(), gtkxReactDomPrebundle()],
+    plugins: (entryPath) => [
+        ...gtkxVitePlugins(DEV_MODE, entryPath),
+        ...gtkxFastRefresh(),
+        gtkxReactDomPrebundle(),
+    ],
     log: info,
     exit: (code: number): never => process.exit(code),
 });

package/src/dev/runner-main.ts

@@ -1,6 +1,6 @@
+import { loadConfig } from "@gtkx/config";
 import { error } from "@gtkx/utils";
 import { resolve } from "node:path";
-import { resolveDataDir } from "../internal/data-dir.js";
 import { DEV_ENTRY_ENV } from "./entry-env.js";
 import { prepareDevIconDir } from "./icon-dir.js";
 import { createDevRunner } from "./runner.js";
@@ -21,9 +21,9 @@ const main = async (): Promise<void> => {
         process.exit(1);
     }
 
-    const dataDir = resolveDataDir(cwd);
-    prepareDevSchemaDir(cwd, dataDir);
-    prepareDevIconDir(cwd, dataDir);
+    const { config, root } = await loadConfig(cwd, { mode: "development" });
+    prepareDevSchemaDir(root, config.future?.v2ResourceImports === true);
+    prepareDevIconDir(root, config.applicationId, config.applicationIcon);
     const entryPath = resolve(cwd, entryArg);
     const { defaultDevRunnerDeps } = await import("./runner-deps.js");
     const runner = createDevRunner(defaultDevRunnerDeps());

package/src/dev/runner.ts

@@ -32,7 +32,7 @@ type DevRunnerDeps = {
     isRefreshBoundary(module: Record<string, unknown>): boolean;
     staleExportName(previous: Record<string, unknown>, current: Record<string, unknown>): string | null;
     readFileRevision(path: string): Promise<string>;
-    plugins(): Plugin[];
+    plugins(entryPath: string): Plugin[];
     log(message: string): void;
     exit(code: number): never;
 };
@@ -602,7 +602,7 @@ 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()));
+        const server = await deps.createServer(createDevServerConfig(process.cwd(), deps.plugins(entryPath)));
         const session = createSession(server, deps);
         deps.installShutdownHandlers(onShutdownSignal(session));
 

package/src/dev/schema-dir.ts

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

package/src/internal/build-manifest.ts

@@ -0,0 +1,32 @@
+type RecordedPackage = {
+    name: string;
+    version: string | null;
+    dir: string;
+};
+
+type BuildManifest = {
+    generator: typeof BUILD_MANIFEST_GENERATOR;
+    formatVersion: typeof BUILD_MANIFEST_FORMAT_VERSION;
+    schemas: string[];
+    packages: RecordedPackage[];
+};
+
+type BuildManifestCollector = {
+    schemas: string[];
+};
+
+const BUILD_MANIFEST_FILENAME = "gtkx-schemas.json";
+const BUILD_MANIFEST_GENERATOR = "gtkx-build";
+const BUILD_MANIFEST_FORMAT_VERSION = 1;
+
+const createBuildManifestCollector = (): BuildManifestCollector => ({ schemas: [] });
+
+export {
+    BUILD_MANIFEST_FILENAME,
+    BUILD_MANIFEST_FORMAT_VERSION,
+    BUILD_MANIFEST_GENERATOR,
+    createBuildManifestCollector,
+    type BuildManifest,
+    type BuildManifestCollector,
+    type RecordedPackage,
+};