@gtkx/cli 1.0.0 → 1.2.0

package/src/dev/supervisor.ts

@@ -311,9 +311,6 @@ const runDevSupervisor = async (options: DevSupervisorOptions): Promise<never> =
 
 export {
     RESTART_EXIT_CODE,
-    defaultForkRunner,
     runDevSupervisor,
     type DevWatch,
-    type ForkRunner,
-    type SupervisedChild,
 };

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

@@ -1,10 +1,13 @@
 import type { InlineConfig, Plugin } from "vite";
+import { join } from "node:path";
 
 type DevServerModule = object;
+type DevServerWatchEvent = "add" | "change" | "unlink";
 
 type DevServerChangedModule = DevServerModule & {
     importers: Iterable<DevServerModule>;
     ssrModule?: Record<string, unknown> | null;
+    ssrTransformResult?: object | null;
 };
 
 type DevServerModuleGraph = {
@@ -12,20 +15,62 @@ type DevServerModuleGraph = {
     invalidateModule(module: DevServerModule): void;
 };
 
+type DevServerConfig = {
+    configFile: string | undefined;
+    configFileDependencies: string[];
+    envDir: string | false;
+    mode: string;
+};
+
 type DevServer = {
     close(): Promise<void>;
+    config: DevServerConfig;
     moduleGraph: DevServerModuleGraph;
     ssrLoadModule(id: string): Promise<Record<string, unknown>>;
+    ssrFixStacktrace(cause: Error): void;
     watcher: {
-        on(event: "change", listener: (changedPath: string) => void): void;
+        on(event: DevServerWatchEvent, listener: (changedPath: string) => void): void;
     };
 };
 
+const WRITE_STABILITY_THRESHOLD_MS = 50;
+const WRITE_POLL_INTERVAL_MS = 10;
+const ENV_FILE_SUFFIXES = ["", ".local"];
+
+const envFilesForMode = (config: DevServerConfig): string[] => {
+    const envDir = config.envDir;
+
+    if (envDir === false) {
+        return [];
+    }
+
+    return ENV_FILE_SUFFIXES.flatMap((suffix) => [
+        join(envDir, `.env${suffix}`),
+        join(envDir, `.env.${config.mode}${suffix}`),
+    ]);
+};
+
+const isServerConfigFile = (config: DevServerConfig, changedPath: string): boolean => {
+    if (changedPath === config.configFile || config.configFileDependencies.includes(changedPath)) {
+        return true;
+    }
+
+    return envFilesForMode(config).includes(changedPath);
+};
+
 const createDevServerConfig = (root: string, plugins: Plugin[]): InlineConfig => ({
     root,
     appType: "custom",
     plugins,
-    server: { middlewareMode: true },
+    server: {
+        middlewareMode: true,
+        watch: {
+            awaitWriteFinish: {
+                stabilityThreshold: WRITE_STABILITY_THRESHOLD_MS,
+                pollInterval: WRITE_POLL_INTERVAL_MS,
+            },
+        },
+    },
     optimizeDeps: { noDiscovery: true, include: [] },
     ssr: {
         external: true,
@@ -33,4 +78,10 @@ const createDevServerConfig = (root: string, plugins: Plugin[]): InlineConfig =>
     },
 });
 
-export { createDevServerConfig, type DevServer };
+export {
+    createDevServerConfig,
+    type DevServer,
+    type DevServerChangedModule,
+    type DevServerWatchEvent,
+    isServerConfigFile,
+};

package/src/internal/entry-arg.ts

@@ -1,10 +1,10 @@
 import type { PositionalArgDef, StringArgDef } from "citty";
-import { existsSync } from "node:fs";
+import { statSync } from "node:fs";
 import { resolve } from "node:path";
 
 const DEFAULT_ENTRY_BASE = "src/index";
-const DEFAULT_ENTRY_EXTENSION = ".tsx";
-const DEFAULT_ENTRY_EXTENSIONS = [DEFAULT_ENTRY_EXTENSION, ".jsx", ".ts", ".js"];
+const DEFAULT_ENTRY_EXTENSIONS = [".tsx", ".jsx", ".ts", ".js"];
+const DEFAULT_ENTRY_CANDIDATES = DEFAULT_ENTRY_EXTENSIONS.map((extension) => `${DEFAULT_ENTRY_BASE}${extension}`);
 const DEFAULT_ENTRY = `${DEFAULT_ENTRY_BASE}{${DEFAULT_ENTRY_EXTENSIONS.join(",")}}`;
 
 const cwdArg: { cwd: StringArgDef } = {
@@ -24,23 +24,37 @@ const entryArg: { entry: PositionalArgDef; cwd: StringArgDef } = {
 };
 
 const resolveCwd = (args: { cwd?: string }): string => (args.cwd ? resolve(args.cwd) : process.cwd());
+const isFile = (path: string): boolean => statSync(path, { throwIfNoEntry: false })?.isFile() === true;
+
+const missingDefaultEntryError = (cwd: string): Error =>
+    new Error(
+        `No entry file found in ${cwd}. Looked for ${DEFAULT_ENTRY_CANDIDATES.join(", ")}; ` +
+        "pass the entry file as an argument.",
+    );
 
 const resolveDefaultEntry = (cwd: string): string => {
-    for (const extension of DEFAULT_ENTRY_EXTENSIONS) {
-        const candidate = resolve(cwd, `${DEFAULT_ENTRY_BASE}${extension}`);
+    for (const candidate of DEFAULT_ENTRY_CANDIDATES) {
+        const path = resolve(cwd, candidate);
 
-        if (existsSync(candidate)) {
-            return candidate;
+        if (isFile(path)) {
+            return path;
         }
     }
 
-    return resolve(cwd, `${DEFAULT_ENTRY_BASE}${DEFAULT_ENTRY_EXTENSION}`);
+    throw missingDefaultEntryError(cwd);
 };
 
-const resolveEntry = (args: { entry?: string; cwd?: string }): { cwd: string; entry: string } => {
-    const cwd = resolveCwd(args);
+const resolveGivenEntry = (cwd: string, entry: string): string => {
+    const path = resolve(cwd, entry);
+
+    if (!isFile(path)) {
+        throw new Error(`No entry file at ${path}.`);
+    }
 
-    return { cwd, entry: args.entry ? resolve(cwd, args.entry) : resolveDefaultEntry(cwd) };
+    return path;
 };
 
+const resolveEntry = (cwd: string, entry: string | undefined): string =>
+    entry ? resolveGivenEntry(cwd, entry) : resolveDefaultEntry(cwd);
+
 export { cwdArg, entryArg, resolveCwd, resolveEntry };

package/src/internal/module-loads.ts

@@ -0,0 +1,32 @@
+type ModuleLoader = {
+    ssrLoadModule(id: string): Promise<Record<string, unknown>>;
+};
+
+const loadChains: WeakMap<object, Promise<void>> = new WeakMap();
+
+const settled = async (load: Promise<unknown>): Promise<void> => {
+    try {
+        await load;
+    } catch {
+        return;
+    }
+};
+
+const withExclusiveLoad = <T>(server: object, run: () => Promise<T>): Promise<T> => {
+    const pending = loadChains.get(server) ?? Promise.resolve();
+
+    const result = (async (): Promise<T> => {
+        await pending;
+
+        return run();
+    })();
+
+    loadChains.set(server, settled(result));
+
+    return result;
+};
+
+const loadModuleExclusively = (server: ModuleLoader, id: string): Promise<Record<string, unknown>> =>
+    withExclusiveLoad(server, () => server.ssrLoadModule(id));
+
+export { loadModuleExclusively, withExclusiveLoad };

package/src/internal/prepare-project.ts

@@ -0,0 +1,23 @@
+import { ensureGeneratedIn } from "../codegen/run-codegen.js";
+import { type CodegenContext, resolveCodegenContext } from "../codegen/store-resolver.js";
+import { resolveCwd, resolveEntry } from "./entry-arg.js";
+
+type ProjectArgs = { entry?: string; cwd?: string };
+type PreparedProject = { cwd: string; entry: string };
+type ResolvedProject = PreparedProject & { context: CodegenContext };
+
+const resolveProject = async (args: ProjectArgs, mode: string): Promise<ResolvedProject> => {
+    const cwd = resolveCwd(args);
+    const context = await resolveCodegenContext(cwd, mode);
+
+    return { cwd, entry: resolveEntry(cwd, args.entry), context };
+};
+
+const prepareProject = async (args: ProjectArgs, mode: string): Promise<PreparedProject> => {
+    const { cwd, entry, context } = await resolveProject(args, mode);
+    await ensureGeneratedIn(context, { shouldAnnounce: true, mode });
+
+    return { cwd, entry };
+};
+
+export { prepareProject, resolveProject };

package/src/internal/run-cli-tool.ts

@@ -5,17 +5,33 @@ type CliToolInvocation = {
     tool: string;
     args: string[];
     target?: string;
+    shouldStream?: boolean;
     options?: ExecFileSyncOptions;
 };
 
-const runCliTool = ({ tool, args, target, options }: CliToolInvocation): void => {
+const streamingOptions = (options: ExecFileSyncOptions | undefined): ExecFileSyncOptions => ({
+    ...options,
+    stdio: "inherit",
+});
+
+const optionsFor = (shouldStream: boolean | undefined, options: ExecFileSyncOptions | undefined): ExecFileSyncOptions |
+    undefined => (shouldStream === true ? streamingOptions(options) : options);
+
+const failureMessage = (tool: string, target: string | undefined, error: unknown): string => {
+    const details = formatChildProcessError(error);
+    const suffix = details ? `:\n${details}` : "";
+    const subject = target === undefined ? "" : ` for ${target}`;
+
+    return `${tool} failed${subject}${suffix}`;
+};
+
+const runCliTool = ({ tool, args, target, shouldStream, options }: CliToolInvocation): void => {
+    const executable = resolveExecutable(tool);
+
     try {
-        execFileSync(resolveExecutable(tool), args, options);
+        execFileSync(executable, args, optionsFor(shouldStream, options));
     } catch (error) {
-        const details = formatChildProcessError(error);
-        const suffix = details ? `:\n${details}` : "";
-        const subject = target === undefined ? "" : ` for ${target}`;
-        throw new Error(`${tool} failed${subject}${suffix}`, { cause: error });
+        throw new Error(failureMessage(tool, target, error), { cause: error });
     }
 };
 

package/src/internal/staging-dir.ts

@@ -2,12 +2,21 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
+type RetainedStagingDir = {
+    getPath: () => string | null;
+    adopt: (dir: string) => string;
+    retain: () => string;
+    release: () => void;
+};
+
 const removeTempDir = (dir: string): void => {
     rmSync(dir, { recursive: true, force: true, maxRetries: 5 });
 };
 
+const createStagingDir = (prefix: string): string => mkdtempSync(join(tmpdir(), `gtkx-${prefix}-`));
+
 const withStagingDir = <T>(prefix: string, produce: (dir: string) => T): T => {
-    const dir = mkdtempSync(join(tmpdir(), `gtkx-${prefix}-`));
+    const dir = createStagingDir(prefix);
 
     try {
         return produce(dir);
@@ -16,4 +25,50 @@ const withStagingDir = <T>(prefix: string, produce: (dir: string) => T): T => {
     }
 };
 
-export { removeTempDir, withStagingDir };
+const createRetainedStagingDir = (prefix: string): RetainedStagingDir => {
+    let path: string | null = null;
+    let cleanupProcessExit: (() => void) | null = null;
+
+    const release = (): void => {
+        if (path !== null && cleanupProcessExit) {
+            removeTempDir(path);
+            process.removeListener("exit", cleanupProcessExit);
+            cleanupProcessExit = null;
+        }
+
+        path = null;
+    };
+
+    const retain = (): string => {
+        if (path !== null) {
+            return path;
+        }
+
+        const dir = createStagingDir(prefix);
+        path = dir;
+
+        cleanupProcessExit = (): void => {
+            removeTempDir(dir);
+        };
+
+        process.once("exit", cleanupProcessExit);
+
+        return dir;
+    };
+
+    const adopt = (dir: string): string => {
+        release();
+        path = dir;
+
+        return dir;
+    };
+
+    return {
+        getPath: () => path,
+        adopt,
+        retain,
+        release,
+    };
+};
+
+export { createRetainedStagingDir, removeTempDir, type RetainedStagingDir, withStagingDir };

package/src/mcp/serialize-widget.ts

@@ -5,6 +5,7 @@ type WidgetIdResolver = (widget: Gtk.Widget) => string;
 
 type WidgetFormatting = {
     formatRole(role: Gtk.AccessibleRole): string;
+    getTypeTag(widget: Gtk.Widget): string;
     getWidgetText(widget: Gtk.Widget): string | null;
 };
 
@@ -36,7 +37,7 @@ const getChildren = (widget: Gtk.Widget): Gtk.Widget[] => {
 
 const createNode = (widget: Gtk.Widget, expansion: Expansion): SerializedWidget => ({
     id: expansion.resolveId(widget),
-    type: widget.constructor.name,
+    type: expansion.testing.getTypeTag(widget),
     role: expansion.testing.formatRole(widget.getAccessibleRole()),
     name: widget.getName() || null,
     text: expansion.testing.getWidgetText(widget),
@@ -88,4 +89,4 @@ const serializeWidget = (
     return root;
 };
 
-export { serializeWidget, type WidgetFormatting };
+export { serializeWidget };

package/src/mcp/testing-loader.ts

@@ -1,4 +1,6 @@
-type TestingModule = typeof import("@gtkx/testing");
+type TestingPublicModule = typeof import("@gtkx/testing");
+type TestingInternalModule = typeof import("@gtkx/testing/internal");
+type TestingModule = TestingPublicModule & Pick<TestingInternalModule, "getTypeTag">;
 type TestingModuleLoader = () => Promise<TestingModule>;
 
 type TestingModuleCache = {
@@ -14,8 +16,14 @@ type TestingModuleState = {
 
 const { setLoader: setTestingModuleLoader, load: loadTestingModule } = createTestingModuleCache();
 
-function defaultLoader(): Promise<TestingModule> {
-    return import("@gtkx/testing");
+function mergeTestingModule(publicApi: TestingPublicModule, internals: TestingInternalModule): TestingModule {
+    return { ...publicApi, getTypeTag: internals.getTypeTag };
+}
+
+async function defaultLoader(): Promise<TestingModule> {
+    const [publicApi, internals] = await Promise.all([import("@gtkx/testing"), import("@gtkx/testing/internal")]);
+
+    return mergeTestingModule(publicApi, internals);
 }
 
 function missingTestingPackageError(cause: unknown): Error {
@@ -70,4 +78,11 @@ function createTestingModuleCache(): TestingModuleCache {
     };
 }
 
-export { setTestingModuleLoader, loadTestingModule, type TestingModule, type TestingModuleLoader };
+export {
+    setTestingModuleLoader,
+    loadTestingModule,
+    mergeTestingModule,
+    type TestingInternalModule,
+    type TestingModule,
+    type TestingPublicModule,
+};

package/src/refresh-runtime.ts

@@ -1,8 +1,13 @@
-import RefreshRuntime from "react-refresh/runtime";
+import RefreshRuntime, { type Family } from "react-refresh/runtime";
 import "./refresh-globals.js";
 
 type ComponentType = (...args: unknown[]) => unknown;
 
+type PatchedExports = {
+    values: Set<unknown>;
+    families: Set<Family>;
+};
+
 function createModuleRegistration(moduleId: string): {
     $RefreshReg$: (type: ComponentType, id: string) => void;
     $RefreshSig$: typeof RefreshRuntime.createSignatureFunctionForTransform;
@@ -40,8 +45,49 @@ function isRefreshBoundary(moduleExports: Record<string, unknown>): boolean {
     return Object.keys(moduleExports).some((k) => k !== "__esModule");
 }
 
+const exportedFamilies = (moduleExports: Record<string, unknown>): Set<Family> => {
+    const families: Set<Family> = new Set();
+
+    for (const key in moduleExports) {
+        const family = RefreshRuntime.getFamilyByType(moduleExports[key]);
+
+        if (family) {
+            families.add(family);
+        }
+    }
+
+    return families;
+};
+
+const patchedExports = (moduleExports: Record<string, unknown>): PatchedExports => ({
+    values: new Set(Object.values(moduleExports)),
+    families: exportedFamilies(moduleExports),
+});
+
+const isPatchedExport = (patched: PatchedExports, value: unknown): boolean => {
+    if (patched.values.has(value)) {
+        return true;
+    }
+
+    const family = RefreshRuntime.getFamilyByType(value);
+
+    return family !== undefined && patched.families.has(family);
+};
+
+const staleExportName = (previous: Record<string, unknown>, current: Record<string, unknown>): string | null => {
+    const patched = patchedExports(current);
+
+    for (const key in previous) {
+        if (!isPatchedExport(patched, previous[key])) {
+            return key;
+        }
+    }
+
+    return null;
+};
+
 function performRefresh(): void {
     RefreshRuntime.performReactRefresh();
 }
 
-export { createModuleRegistration, isRefreshBoundary, performRefresh };
+export { createModuleRegistration, isRefreshBoundary, performRefresh, staleExportName };

package/src/settings/schema.ts

@@ -164,6 +164,5 @@ export {
     stageSchema,
     findSchemaFiles,
     stageAndCompileProjectSchemas,
-    schemaEnvPath,
     emitSchemaEnv,
 };

package/src/vite-plugins/asset-extensions.ts

@@ -25,5 +25,6 @@ const ASSET_EXTENSIONS = [
 
 const ASSET_RE = new RegExp(String.raw`\.(?:${ASSET_EXTENSIONS.join("|")})$`, "i");
 const ASSET_PATH_RE = new RegExp(String.raw`\.(?:${ASSET_EXTENSIONS.join("|")})(?:\?.*)?$`, "i");
+const ASSET_MENTION_RE = new RegExp(String.raw`\.(?:${ASSET_EXTENSIONS.join("|")})`, "i");
 
-export { ASSET_RE, ASSET_PATH_RE };
+export { ASSET_MENTION_RE, ASSET_PATH_RE, ASSET_RE };

package/src/vite-plugins/asset-imports.ts

@@ -0,0 +1,134 @@
+import type { ParseResult, ParserOptions, Plugin } from "vite";
+import { extname } from "node:path";
+import { parseSync } from "vite";
+import { ASSET_MENTION_RE } from "./asset-extensions.js";
+import { DATA_PREFIX, isAssetSpecifier, isDataAsset } from "./asset-specifier.js";
+import { RESOURCE_PATH_EXPORT } from "./resource-shared.js";
+import { stripQuery } from "./strip-query.js";
+
+type SourceLanguage = NonNullable<ParserOptions["lang"]>;
+type ParsedModule = ParseResult["module"];
+type ImportStatement = ParsedModule["staticImports"][number];
+type ExportStatement = ParsedModule["staticExports"][number];
+type ExportEntry = ExportStatement["entries"][number];
+type BindingEntry = { importName: { name: string | null }; isType: boolean };
+type NamedBinding = { name: string; source: string };
+
+const SOURCE_LANGUAGES: Map<string, SourceLanguage> = new Map([
+    [".cjs", "jsx"],
+    [".cts", "ts"],
+    [".js", "jsx"],
+    [".jsx", "jsx"],
+    [".mjs", "jsx"],
+    [".mts", "ts"],
+    [".ts", "ts"],
+    [".tsx", "tsx"],
+]);
+
+const NODE_MODULES = /(?:^|\/)node_modules\//;
+const VIRTUAL_PREFIX = "\0";
+const DEFAULT_BINDING = "default";
+const RESOURCE_BINDING = JSON.stringify(RESOURCE_PATH_EXPORT);
+const DATA_IMPORT_EXAMPLE = `"${DATA_PREFIX}<path>"`;
+const URL_FALLBACK = ", or import the default for the asset URL.";
+
+const BUNDLE_ADVICE =
+    `An asset staged into the GResource bundle exports ${RESOURCE_BINDING} and a "resource://" default, and ` +
+    "nothing else.";
+
+const QUERY_ADVICE =
+    "A query suffix hands the import to the Vite asset pipeline instead of the GResource bundle; drop the " +
+    `query to keep ${RESOURCE_BINDING}${URL_FALLBACK}`;
+
+const RELATIVE_ADVICE =
+    `Only assets imported through "${DATA_PREFIX}" are staged into the GResource bundle and export ` +
+    `${RESOURCE_BINDING}; move the file under the data directory and import it as ` +
+    `${DATA_IMPORT_EXAMPLE}${URL_FALLBACK}`;
+
+const boundName = (entry: BindingEntry): string | null => {
+    const { name } = entry.importName;
+
+    if (name === null || name === DEFAULT_BINDING || entry.isType) {
+        return null;
+    }
+
+    return name;
+};
+
+const importBindings = (statement: ImportStatement): NamedBinding[] =>
+    statement.entries
+        .map((entry) => boundName(entry))
+        .filter((name) => name !== null)
+        .map((name) => ({ name, source: statement.moduleRequest.value }));
+
+const exportBinding = (entry: ExportEntry): NamedBinding | null => {
+    const name = boundName(entry);
+    const source = entry.moduleRequest?.value;
+
+    return name === null || source === undefined ? null : { name, source };
+};
+
+const exportBindings = (statement: ExportStatement): NamedBinding[] =>
+    statement.entries.map((entry) => exportBinding(entry)).filter((binding) => binding !== null);
+
+const bindings = (parsed: ParsedModule): NamedBinding[] => [
+    ...parsed.staticImports.flatMap((statement) => importBindings(statement)),
+    ...parsed.staticExports.flatMap((statement) => exportBindings(statement)),
+];
+
+const isBacked = ({ name, source }: NamedBinding): boolean =>
+    isDataAsset(source) && name === RESOURCE_PATH_EXPORT;
+
+const unbackedBinding = (parsed: ParsedModule): NamedBinding | undefined =>
+    bindings(parsed).find((binding) => isAssetSpecifier(binding.source) && !isBacked(binding));
+
+const bundleAdvice = (source: string): string => {
+    if (isDataAsset(source)) {
+        return BUNDLE_ADVICE;
+    }
+
+    return source.startsWith(DATA_PREFIX) ? QUERY_ADVICE : RELATIVE_ADVICE;
+};
+
+const unbackedBindingError = (path: string, binding: NamedBinding): Error =>
+    new Error(
+        `${path}: ${JSON.stringify(binding.source)} does not export ${JSON.stringify(binding.name)}, which ` +
+        "gtkx build rejects and gtkx dev would bind as undefined. " +
+        bundleAdvice(binding.source),
+    );
+
+const isCheckedSource = (path: string): boolean => !path.startsWith(VIRTUAL_PREFIX) && !NODE_MODULES.test(path);
+
+const checkAssetImports = (code: string, id: string): void => {
+    const path = stripQuery(id);
+    const lang = SOURCE_LANGUAGES.get(extname(path).toLowerCase());
+
+    if (lang === undefined || !isCheckedSource(path) || !ASSET_MENTION_RE.test(code)) {
+        return;
+    }
+
+    const parsed = parseSync(path, code, { lang });
+
+    if (parsed.errors.length > 0) {
+        return;
+    }
+
+    const binding = unbackedBinding(parsed.module);
+
+    if (binding !== undefined) {
+        throw unbackedBindingError(path, binding);
+    }
+};
+
+function gtkxAssetImports(): Plugin {
+    return {
+        name: "gtkx:asset-imports",
+        enforce: "pre",
+
+        transform(code, id) {
+            checkAssetImports(code, id);
+        },
+    };
+}
+
+export { gtkxAssetImports };

package/src/vite-plugins/asset-specifier.ts

@@ -0,0 +1,9 @@
+import { DATA_IMPORT_PREFIX } from "../internal/data-dir.js";
+import { ASSET_PATH_RE, ASSET_RE } from "./asset-extensions.js";
+
+const DATA_PREFIX = `${DATA_IMPORT_PREFIX}/`;
+
+const isAssetSpecifier = (source: string): boolean => ASSET_PATH_RE.test(source);
+const isDataAsset = (source: string): boolean => source.startsWith(DATA_PREFIX) && ASSET_RE.test(source);
+
+export { DATA_PREFIX, isAssetSpecifier, isDataAsset };

package/src/vite-plugins/esm-extension.ts

@@ -0,0 +1,4 @@
+const ESM_EXTENSION = ".mjs";
+const BUNDLE_FILENAME = `bundle${ESM_EXTENSION}`;
+
+export { BUNDLE_FILENAME, ESM_EXTENSION };

package/src/vite-plugins/fast-refresh/swc-refresh.ts

@@ -89,4 +89,4 @@ function gtkxRefreshRuntime(): Plugin {
 
 const gtkxFastRefresh = (): Plugin[] => [gtkxSwcRefresh(), gtkxRefreshRuntime()];
 
-export { gtkxSwcRefresh, gtkxRefreshRuntime, gtkxFastRefresh };
+export { gtkxFastRefresh };

package/src/vite-plugins/index.ts

@@ -1,11 +1,13 @@
 import type { Plugin } from "vite";
 import { createConfigLoader } from "@gtkx/config/internal";
 import createConfigPlugin from "@gtkx/config/vite-plugin";
+import { gtkxAssetImports } from "./asset-imports.js";
 import { gtkxCss } from "./css.js";
 import { gtkxIcons } from "./icons.js";
 import { gtkxReactCompiler } from "./react-compiler.js";
 import { gtkxResources } from "./resources.js";
 import { gtkxSettings } from "./settings.js";
+import { gtkxStoreLinks } from "./store-links.js";
 import { gtkxUndeclaredLibrary } from "./undeclared-library.js";
 
 const gtkxVitePlugins = (mode?: string): Plugin[] => {
@@ -13,9 +15,11 @@ const gtkxVitePlugins = (mode?: string): Plugin[] => {
 
     return [
         createConfigPlugin({ name: "gtkx:config", loadConfig }),
+        gtkxStoreLinks(),
         gtkxUndeclaredLibrary(loadConfig),
         gtkxSettings(),
         gtkxIcons(),
+        gtkxAssetImports(),
         gtkxResources(loadConfig),
         gtkxCss(),
         gtkxReactCompiler(loadConfig),

package/src/vite-plugins/resource-shared.ts

@@ -5,6 +5,7 @@ const VIRTUAL_INIT = "\0gtkx-resources-init";
 const BUNDLE_FILENAME = "gtkx.gresource";
 const REL_SEPARATOR = "\0rel=";
 const REFRESH_EXPORT = "__refresh";
+const RESOURCE_PATH_EXPORT = "path";
 const { isVirtual, toVirtualId, fromVirtualId } = createVirtualNamespace(VIRTUAL_PREFIX);
 
 const escapeXml = (value: string): string =>
@@ -33,6 +34,7 @@ export {
     BUNDLE_FILENAME,
     REL_SEPARATOR,
     REFRESH_EXPORT,
+    RESOURCE_PATH_EXPORT,
     escapeXml,
     isVirtual,
     toVirtualId,