@gtkx/cli 2.0.0-beta.7 → 2.0.0-beta.9

package/src/dev/font-dir.ts

@@ -1,13 +1,8 @@
 import { stageProjectFonts } from "../internal/font-staging.js";
 import { prependXdgDataDir } from "../internal/xdg-data-dirs.js";
 
-const prepareDevFontDir = (root: string): string | null => {
+const prepareDevFontDir = (root: string): string => {
     const shareDir = stageProjectFonts(root);
-
-    if (shareDir === null) {
-        return null;
-    }
-
     process.env.XDG_DATA_DIRS = prependXdgDataDir(shareDir, process.env.XDG_DATA_DIRS);
 
     return shareDir;

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";
@@ -371,6 +372,11 @@ const restartForServerConfig = async (session: DevSession, changedPath: string):
     await requestRestart(session);
 };
 
+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;
@@ -380,20 +386,32 @@ const restartForCatalog = async (session: DevSession, changedPath: string): Prom
     await requestRestart(session);
 };
 
-const applyChange = async (session: DevSession, change: WatchedChange): Promise<void> => {
-    if (session.controller.isShuttingDown()) {
-        return;
-    }
+const didRestartForChange = async (session: DevSession, change: WatchedChange): Promise<boolean> => {
+    const { root } = session.server.config;
 
-    if (isCatalogSource(session.server.config.root, change.path)) {
+    if (isCatalogSource(root, change.path)) {
         await restartForCatalog(session, change.path);
 
-        return;
+        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;
     }
 

package/src/internal/font-staging.ts

@@ -1,57 +1,129 @@
 import { sortStrings } from "@gtkx/utils";
-import { mkdirSync, mkdtempSync, readFileSync, symlinkSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { lstatSync, mkdirSync, readFileSync, symlinkSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, isAbsolute, join, resolve } from "node:path";
 import { parseFontSpecifier } from "../vite-plugins/asset-specifier.js";
 import { fontFileName, FONTS_DIR } from "./font-path.js";
-import { discoverSourceImports, sourceDirFor, type SourceImport } from "./source-imports.js";
-import { removeTempDir } from "./staging-dir.js";
+import { discoverSourceImports, type SourceImport, sourceLanguage } from "./source-imports.js";
+import { createRetainedStagingDir } from "./staging-dir.js";
 
-const FONT_STAGING_PREFIX = "gtkx-fonts-";
+type FontStagingStatus = "absent" | "staged" | "unmanaged";
+
+const FONT_DIR_ENV = "GTKX_DEV_FONT_DIR";
+const FONT_QUERY = "?font";
+const fontStaging = createRetainedStagingDir("fonts");
 
 const isRelativeImport = (source: string): boolean => source.startsWith("./") || source.startsWith("../");
 
-const fontFileFor = ({ importer, source }: SourceImport): string | null => {
+const existingPath = (path: string): string | null =>
+    lstatSync(path, { throwIfNoEntry: false }) === undefined ? null : path;
+
+const resolveRelativeImport = (importer: string, assetSource: string): string | null =>
+    existingPath(resolve(dirname(importer), assetSource));
+
+const resolveAbsoluteImport = (root: string, assetSource: string): string | null =>
+    existingPath(assetSource) ?? existingPath(join(root, assetSource));
+
+const resolvePackageImport = (importer: string, assetSource: string): string | null => {
+    try {
+        return createRequire(importer).resolve(assetSource);
+    } catch {
+        return null;
+    }
+};
+
+const resolveFontImport = (root: string, importer: string, assetSource: string): string | null => {
+    if (isRelativeImport(assetSource)) {
+        return resolveRelativeImport(importer, assetSource);
+    }
+
+    if (isAbsolute(assetSource)) {
+        return resolveAbsoluteImport(root, assetSource);
+    }
+
+    return resolvePackageImport(importer, assetSource);
+};
+
+const fontFileFor = (root: string, { importer, source }: SourceImport): string | null => {
     const specifier = parseFontSpecifier(source);
 
-    return specifier === null || !isRelativeImport(source)
-        ? null
-        : resolve(dirname(importer), specifier.assetSource);
+    return specifier === null ? null : resolveFontImport(root, importer, specifier.assetSource);
 };
 
-const findImportedFontFiles = (imports: SourceImport[]): string[] => {
-    const files = imports
-        .map((entry) => fontFileFor(entry))
+const projectFontFiles = (root: string): string[] => {
+    const files = discoverSourceImports(root)
+        .map((entry) => fontFileFor(root, entry))
         .filter((path): path is string => path !== null);
 
     return sortStrings(new Set(files));
 };
 
+const stagedPath = (fontsDir: string, sourcePath: string, content: Buffer): string =>
+    join(fontsDir, fontFileName(sourcePath, content));
+
 const stageFont = (fontsDir: string, sourcePath: string): void => {
-    const fileName = fontFileName(sourcePath, readFileSync(sourcePath));
+    const target = stagedPath(fontsDir, sourcePath, readFileSync(sourcePath));
+
+    if (existingPath(target) !== null) {
+        return;
+    }
 
-    symlinkSync(sourcePath, join(fontsDir, fileName), "file");
+    symlinkSync(sourcePath, target, "file");
 };
 
-const stageProjectFonts = (root: string): string | null => {
-    const fontFiles = findImportedFontFiles(discoverSourceImports(sourceDirFor(root)));
+const stagedFontsDir = (): string | null => {
+    const shareDir = process.env[FONT_DIR_ENV];
 
-    if (fontFiles.length === 0) {
-        return null;
+    return shareDir === undefined || shareDir.length === 0 ? null : join(shareDir, FONTS_DIR);
+};
+
+const stagedFontStatus = (sourcePath: string, content: Buffer): FontStagingStatus => {
+    const fontsDir = stagedFontsDir();
+
+    if (fontsDir === null) {
+        return "unmanaged";
     }
 
-    const shareDir = mkdtempSync(join(tmpdir(), FONT_STAGING_PREFIX));
-    mkdirSync(join(shareDir, FONTS_DIR));
+    return existingPath(stagedPath(fontsDir, sourcePath, content)) === null ? "absent" : "staged";
+};
+
+const hasFontImportMention = (filePath: string): boolean => {
+    if (sourceLanguage(filePath) === undefined) {
+        return false;
+    }
+
+    try {
+        return readFileSync(filePath, "utf8").includes(FONT_QUERY);
+    } catch {
+        return false;
+    }
+};
+
+const isUnstagedFont = (fontsDir: string, sourcePath: string): boolean =>
+    existingPath(stagedPath(fontsDir, sourcePath, readFileSync(sourcePath))) === null;
+
+const hasUnstagedFontImport = (root: string, filePath: string): boolean => {
+    const fontsDir = stagedFontsDir();
+
+    if (fontsDir === null || !hasFontImportMention(filePath)) {
+        return false;
+    }
+
+    return projectFontFiles(root).some((sourcePath) => isUnstagedFont(fontsDir, sourcePath));
+};
+
+const stageProjectFonts = (root: string): string => {
+    const shareDir = fontStaging.retain();
+    const fontsDir = join(shareDir, FONTS_DIR);
+    mkdirSync(fontsDir, { recursive: true });
 
-    for (const sourcePath of fontFiles) {
-        stageFont(join(shareDir, FONTS_DIR), sourcePath);
+    for (const sourcePath of projectFontFiles(root)) {
+        stageFont(fontsDir, sourcePath);
     }
 
-    process.once("exit", () => {
-        removeTempDir(shareDir);
-    });
+    process.env[FONT_DIR_ENV] = shareDir;
 
     return shareDir;
 };
 
-export { stageProjectFonts };
+export { hasUnstagedFontImport, stagedFontStatus, stageProjectFonts };

package/src/internal/icon-staging.ts

@@ -0,0 +1,58 @@
+import { mkdirSync, rmSync, symlinkSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { relativeIconPath, resolveApplicationIcon, type ResolvedApplicationIcon } from "./icon-path.js";
+import { createRetainedStagingDir, type RetainedStagingDir } from "./staging-dir.js";
+
+const ICONS_DIR = "icons";
+const stagingDirs: Map<string, RetainedStagingDir> = new Map();
+
+const stagingFor = (root: string): RetainedStagingDir => {
+    const existing = stagingDirs.get(root);
+
+    if (existing !== undefined) {
+        return existing;
+    }
+
+    const staging = createRetainedStagingDir("icons");
+    stagingDirs.set(root, staging);
+
+    return staging;
+};
+
+const resetIconsDir = (shareDir: string): string => {
+    const iconsDir = join(shareDir, ICONS_DIR);
+    rmSync(iconsDir, { recursive: true, force: true });
+
+    return iconsDir;
+};
+
+const stageIconSource = (
+    iconsDir: string,
+    applicationId: string,
+    source: Exclude<ResolvedApplicationIcon, { kind: "none" }>,
+): void => {
+    if (source.kind === "theme") {
+        symlinkSync(source.path, iconsDir, "dir");
+
+        return;
+    }
+
+    const target = join(iconsDir, relativeIconPath(applicationId, source.path));
+    mkdirSync(dirname(target), { recursive: true });
+    symlinkSync(source.path, target, "file");
+};
+
+const stageProjectIcons = (root: string, applicationId: string, configured: string | undefined): string | null => {
+    const source = resolveApplicationIcon(root, applicationId, configured);
+
+    if (source.kind === "none") {
+        return null;
+    }
+
+    const shareDir = stagingFor(root).retain();
+    stageIconSource(resetIconsDir(shareDir), applicationId, source);
+
+    return shareDir;
+};
+
+export { stageProjectIcons };

package/src/internal/source-imports.ts

@@ -41,7 +41,7 @@ const discoverSourceFiles = (dir: string): string[] =>
     sortStringsBy(
         globSync("**/{*,.*}", {
             cwd: dir,
-            exclude: ["**/{build,coverage,dist,node_modules,out-tsc}/**", "**/.gtkx-output-*/**"],
+            exclude: ["**/{build,coverage,dist,node_modules,out-tsc}/**", "**/.gtkx-output-*/**", "**/.git/**"],
             withFileTypes: true,
         })
             .filter((entry) => entry.isFile())

package/src/vite-plugins/font-worker-env.ts

@@ -1,6 +1,6 @@
 import type { UserConfig } from "vite";
 import type { Plugin } from "vitest/config";
-import { createConfigLoader } from "@gtkx/config/internal";
+import { createConfigLoader, viteProjectRoot } from "@gtkx/config/internal";
 import { stageProjectFonts } from "../internal/font-staging.js";
 import { prependXdgDataDir } from "../internal/xdg-data-dirs.js";
 
@@ -12,13 +12,9 @@ function gtkxFontWorkerEnv(configFile?: string): Plugin {
         enforce: "pre",
 
         async config(config: UserConfig) {
-            const loaded = await loadConfig.load(config.root ?? process.cwd());
+            const loaded = await loadConfig.load(viteProjectRoot(config));
             const shareDir = stageProjectFonts(loaded.root);
 
-            if (shareDir === null) {
-                return;
-            }
-
             return {
                 test: { env: { XDG_DATA_DIRS: prependXdgDataDir(shareDir, process.env.XDG_DATA_DIRS) } },
             };

package/src/vite-plugins/font.ts

@@ -4,6 +4,7 @@ import { parseSync } from "vite";
 import type { AssetEmitter } from "./asset-emitter.js";
 import { prependBanner } from "../internal/banner.js";
 import { fontFileName, FONTS_DIR } from "../internal/font-path.js";
+import { stagedFontStatus } from "../internal/font-staging.js";
 import { sourceLanguage } from "../internal/source-imports.js";
 import { xdgDataDirsBanner } from "../internal/xdg-banner.js";
 import { parseFontSpecifier } from "./asset-specifier.js";
@@ -13,7 +14,9 @@ import { createVirtualNamespace } from "./virtual-module.js";
 
 type PluginState = {
     isBuild: boolean;
+    root: string;
     emitted: Set<string>;
+    importers: Map<string, string>;
 };
 
 type ResolveContext = Parameters<typeof resolveToVirtual>[0];
@@ -36,8 +39,14 @@ const unreadableFontError = (filePath: string): string =>
     `Cannot read a font family name from ${filePath}; ?font expects a TrueType, OpenType, ` +
     "TrueType Collection, WOFF, or WOFF2 font";
 
+const unstagedFontError = (filePath: string, importer: string): string =>
+    `${filePath} was not staged before the toolkit started, so ${importer} would resolve its family to a ` +
+    "fallback font. Fonts are staged from ?font imports found in source files under the project root; move " +
+    "the import there, or restart to pick it up.";
+
 const resolveFontId = async (
     ctx: ResolveContext,
+    state: PluginState,
     request: ResolveRequest,
 ): Promise<RetainedFontModuleId | undefined> => {
     if (parseFontSpecifier(request.source) === null) {
@@ -46,7 +55,13 @@ const resolveFontId = async (
 
     const virtualId = await resolveToVirtual(ctx, request);
 
-    return virtualId === undefined ? undefined : { id: virtualId, moduleSideEffects: true };
+    if (virtualId === undefined) {
+        return undefined;
+    }
+
+    state.importers.set(virtualId, request.importer ?? state.root);
+
+    return { id: virtualId, moduleSideEffects: true };
 };
 
 const emitFont = (ctx: LoadContext, state: PluginState, filePath: string, content: Buffer): void => {
@@ -77,6 +92,8 @@ const loadFontModule = (ctx: LoadContext, state: PluginState, id: string): strin
 
     if (state.isBuild) {
         emitFont(ctx, state, filePath, content);
+    } else if (stagedFontStatus(filePath, content) === "absent") {
+        return ctx.error(unstagedFontError(filePath, state.importers.get(id) ?? state.root));
     }
 
     return `export default ${JSON.stringify(family)};`;
@@ -112,7 +129,7 @@ const fontBanner = (state: PluginState) => (chunk: Rollup.RenderedChunk): string
     state.emitted.size === 0 ? "" : xdgDataDirsBanner(chunk);
 
 function gtkxFont(): Plugin {
-    const state: PluginState = { isBuild: false, emitted: new Set() };
+    const state: PluginState = { isBuild: false, root: "", emitted: new Set(), importers: new Map() };
 
     return {
         name: "gtkx:font",
@@ -120,10 +137,11 @@ function gtkxFont(): Plugin {
 
         configResolved(config) {
             state.isBuild = config.command === "build";
+            state.root = config.root;
         },
 
         resolveId(source, importer, options) {
-            return resolveFontId(this, { source, importer, options });
+            return resolveFontId(this, state, { source, importer, options });
         },
 
         load(id) {

package/src/vite-plugins/icon-worker-env.ts

@@ -0,0 +1,36 @@
+import type { UserConfig } from "vite";
+import type { Plugin } from "vitest/config";
+import { createConfigLoader, viteProjectRoot } from "@gtkx/config/internal";
+import { stageProjectIcons } from "../internal/icon-staging.js";
+import { prependXdgDataDir } from "../internal/xdg-data-dirs.js";
+
+function gtkxIconWorkerEnv(configFile?: string): Plugin {
+    const loadConfig = createConfigLoader({ configFile });
+
+    return {
+        name: "gtkx:icon-worker-env",
+        enforce: "pre",
+
+        async config(config: UserConfig) {
+            const loaded = await loadConfig.load(viteProjectRoot(config));
+
+            const shareDir = stageProjectIcons(
+                loaded.root,
+                loaded.config.applicationId,
+                loaded.config.applicationIcon,
+            );
+
+            if (shareDir === null) {
+                return;
+            }
+
+            const existing = config.test?.env?.XDG_DATA_DIRS ?? process.env.XDG_DATA_DIRS;
+
+            return {
+                test: { env: { XDG_DATA_DIRS: prependXdgDataDir(shareDir, existing) } },
+            };
+        },
+    };
+}
+
+export { gtkxIconWorkerEnv };

package/src/vite-plugins/icons.ts

@@ -1,6 +1,6 @@
 import type { ConfigLoader } from "@gtkx/config";
 import type { Plugin, UserConfig } from "vite";
-import { createConfigLoader } from "@gtkx/config/internal";
+import { createConfigLoader, viteProjectRoot } from "@gtkx/config/internal";
 import { info } from "@gtkx/utils";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
@@ -37,7 +37,7 @@ const findIconFiles = (state: PluginState): ListedFile[] => {
 };
 
 const applyUserConfig = async (state: PluginState, config: UserConfig, loadConfig: ConfigLoader): Promise<void> => {
-    const { config: gtkxConfig, root } = await loadConfig.load(config.root ?? process.cwd());
+    const { config: gtkxConfig, root } = await loadConfig.load(viteProjectRoot(config));
     state.applicationId = gtkxConfig.applicationId;
     state.source = resolveApplicationIcon(root, gtkxConfig.applicationId, gtkxConfig.applicationIcon);
 };

package/src/vite-plugins/react-compiler.ts

@@ -3,7 +3,7 @@ import type { ResolvedReactCompilerOptions } from "@gtkx/config/internal";
 import type { Plugin, ResolvedConfig, UserConfig } from "vite";
 import { transformAsync } from "@babel/core";
 import babelPresetTypescriptNs from "@babel/preset-typescript";
-import { createConfigLoader } from "@gtkx/config/internal";
+import { createConfigLoader, viteProjectRoot } from "@gtkx/config/internal";
 import babelPluginReactCompilerNs from "babel-plugin-react-compiler";
 
 type ReactCompilerState = {
@@ -62,7 +62,7 @@ function gtkxReactCompiler(loadConfig: ConfigLoader = createConfigLoader()): Plu
         enforce: "pre",
 
         async config(config: UserConfig) {
-            const resolved = await loadConfig.resolve(config.root ?? process.cwd());
+            const resolved = await loadConfig.resolve(viteProjectRoot(config));
             state.options = resolved.reactCompiler;
         },
 

package/src/vite-plugins/resources.ts

@@ -1,6 +1,6 @@
 import type { ConfigLoader } from "@gtkx/config";
 import type { ModuleNode, Plugin, ResolvedConfig, Rolldown, UserConfig, ViteDevServer } from "vite";
-import { createConfigLoader, resourceBasePath } from "@gtkx/config/internal";
+import { createConfigLoader, resourceBasePath, viteProjectRoot } from "@gtkx/config/internal";
 import { error, info, isPathInside, isRecord, sortStrings, toPosixPath } from "@gtkx/utils";
 import { copyFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { basename, dirname, extname, isAbsolute, join, posix, relative, sep } from "node:path";
@@ -1283,7 +1283,7 @@ const reconcileImporter = async (ctx: ResolveContext, state: PluginState, id: st
 };
 
 const resolveResourceConfig = async (state: PluginState, config: UserConfig, loadConfig: ConfigLoader) => {
-    const loaded = await loadConfig.load(config.root ?? process.cwd());
+    const loaded = await loadConfig.load(viteProjectRoot(config));
     state.prefix = resourceBasePath(loaded.config.applicationId);
     state.root = loaded.root;
 

package/src/vite-plugins/settings-worker-env.ts

@@ -1,6 +1,6 @@
 import type { UserConfig } from "vite";
 import type { Plugin } from "vitest/config";
-import { createConfigLoader } from "@gtkx/config/internal";
+import { createConfigLoader, viteProjectRoot } from "@gtkx/config/internal";
 import { prependSchemaDir, stageAndCompileProjectSchemas } from "../settings/schema.js";
 
 function gtkxSettingsWorkerEnv(configFile?: string): Plugin {
@@ -11,7 +11,7 @@ function gtkxSettingsWorkerEnv(configFile?: string): Plugin {
         enforce: "pre",
 
         async config(config: UserConfig) {
-            const loaded = await loadConfig.load(config.root ?? process.cwd());
+            const loaded = await loadConfig.load(viteProjectRoot(config));
             const dir = stageAndCompileProjectSchemas(loaded.root);
 
             if (dir === null) {

package/src/vite-plugins/store-links.ts

@@ -1,5 +1,6 @@
 import type { Plugin, UserConfig } from "vite";
 import { ensureStoreLinks } from "@gtkx/codegen/internal";
+import { viteProjectRoot } from "@gtkx/config/internal";
 
 const GENERATED_MODULE_PREFIX = /^@gtkx\/(?:gi\/|jsx(?:\/|$))/;
 
@@ -11,7 +12,7 @@ function gtkxStoreLinks(): Plugin {
         enforce: "pre",
 
         config(config: UserConfig) {
-            state.root = config.root ?? process.cwd();
+            state.root = viteProjectRoot(config);
         },
 
         resolveId(source) {

package/src/vite-plugins/undeclared-library.ts

@@ -2,7 +2,7 @@ import type { StoreOptions } from "@gtkx/codegen";
 import type { ConfigLoader } from "@gtkx/config";
 import type { Plugin, UserConfig } from "vite";
 import { discoverGirNamespaces, resolveGirPath, resolveStore } from "@gtkx/codegen";
-import { createConfigLoader } from "@gtkx/config/internal";
+import { createConfigLoader, viteProjectRoot } from "@gtkx/config/internal";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 
@@ -129,7 +129,7 @@ function gtkxUndeclaredLibrary(loadConfig: ConfigLoader = createConfigLoader()):
         enforce: "pre",
 
         config(config: UserConfig) {
-            state.root = config.root ?? process.cwd();
+            state.root = viteProjectRoot(config);
         },
 
         async resolveId(source, importer, options) {

package/src/vite-plugins/worker.ts

@@ -7,12 +7,17 @@ import { stripQuery } from "./strip-query.js";
 type WorkerReplacement = {
     start: number;
     end: number;
-    fileName: string;
+    referenceId: string;
+};
+
+type WorkerReferences = {
+    byModule: Map<string, string>;
+    claimed: Set<string>;
 };
 
 type EmitContext = {
     context: Rollup.PluginContext;
-    emitted: Map<string, string>;
+    references: WorkerReferences;
 };
 
 type SourceRange = {
@@ -83,10 +88,12 @@ const isWorkerConstruction = (code: string, matchIndex: number): boolean =>
 
 const hasWorkerCandidate = (code: string): boolean => code.includes("import.meta.url") && code.includes("Worker");
 
-const workerUrlExpression = (fileName: string): string => {
-    const specifier = JSON.stringify(`./${fileName}`);
+const workerUrlReference = (referenceId: string): string => `import.meta.ROLLUP_FILE_URL_${referenceId}`;
+
+const workerUrlExpression = (relativePath: string): string => {
+    const specifier = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
 
-    return `new URL(${specifier}, import.meta.url)`;
+    return `new URL(${JSON.stringify(specifier)}, import.meta.url)`;
 };
 
 const inlineWorkerExample = (specifier: string): string =>
@@ -125,17 +132,22 @@ const suggestionFor = async (emit: EmitContext, scan: ScanContext, specifier: st
 };
 
 const claimWorker = (emit: EmitContext, resolvedId: string): string => {
-    const existing = emit.emitted.get(resolvedId);
+    const existing = emit.references.byModule.get(resolvedId);
 
     if (existing !== undefined) {
         return existing;
     }
 
-    const fileName = workerFileName(resolvedId);
-    emit.emitted.set(resolvedId, fileName);
-    emit.context.emitFile({ type: "chunk", id: resolvedId, fileName });
+    const referenceId = emit.context.emitFile({
+        type: "chunk",
+        id: resolvedId,
+        fileName: workerFileName(resolvedId),
+    });
 
-    return fileName;
+    emit.references.byModule.set(resolvedId, referenceId);
+    emit.references.claimed.add(referenceId);
+
+    return referenceId;
 };
 
 const isRewritableUrl = (scan: ScanContext, match: RegExpExecArray): boolean =>
@@ -158,7 +170,7 @@ const replacementFor = async (
         throw unresolvedWorkerError(scan, specifier, await suggestionFor(emit, scan, specifier));
     }
 
-    return { start: match.index, end: match.index + match[0].length, fileName: claimWorker(emit, resolved.id) };
+    return { start: match.index, end: match.index + match[0].length, referenceId: claimWorker(emit, resolved.id) };
 };
 
 const collectReplacements = async (emit: EmitContext, scan: ScanContext): Promise<WorkerReplacement[]> => {
@@ -196,8 +208,8 @@ const applyReplacements = (code: string, replacements: WorkerReplacement[]): str
     let output = "";
     let cursor = 0;
 
-    for (const { start, end, fileName } of replacements) {
-        output += code.slice(cursor, start) + workerUrlExpression(fileName);
+    for (const { start, end, referenceId } of replacements) {
+        output += code.slice(cursor, start) + workerUrlReference(referenceId);
         cursor = end;
     }
 
@@ -222,14 +234,18 @@ const transformWorkerUrls = async (emit: EmitContext, code: string, id: string):
 };
 
 function gtkxWorker(): Plugin {
-    const emitted: Map<string, string> = new Map();
+    const references: WorkerReferences = { byModule: new Map(), claimed: new Set() };
 
     return {
         name: "gtkx:worker",
         apply: "build",
 
         transform(code, id) {
-            return transformWorkerUrls({ context: this, emitted }, code, id);
+            return transformWorkerUrls({ context: this, references }, code, id);
+        },
+
+        resolveFileUrl({ referenceId, relativePath }) {
+            return references.claimed.has(referenceId) ? workerUrlExpression(relativePath) : null;
         },
     };
 }