@gjsify/rolldown-plugin-gjsify 0.64.15 → 0.64.16

package/lib/app/browser.js

@@ -34,6 +34,7 @@ import { unresolvedWorkspaceImportPlugin } from '../plugins/unresolved-workspace
 import { GSCHEMA_REGISTER, gschemaPlugin } from '../plugins/gschema.js';
 import { gresourcePlugin } from '../plugins/gresource.js';
 import { implicitGlobalAssignPlugin } from '../plugins/implicit-global-assign.js';
+import { workerUrlPlugin } from '../plugins/worker-url.js';
 export const setupForBrowser = async (input) => {
     const userExternal = input.userExternal ?? [];
     const external = [...userExternal];
@@ -148,6 +149,8 @@ export const setupForBrowser = async (input) => {
         gschemaPlugin({ mode: 'emit', register: GSCHEMA_REGISTER.browser }),
         gresourcePlugin({ compressed: 'strip' }),
         implicitGlobalAssignPlugin(),
+        // `new Worker(new URL('./x', import.meta.url))` → the file the CLI builds beside the bundle.
+        ...(input.pluginOptions.workers ? [workerUrlPlugin(input.pluginOptions.workers)] : []),
         cssAsStringPlugin(),
         // `order: 'post'` — see app/gjs.ts. The browser target's whole job is to
         // replace Node builtins with their `@gjsify/*` browser entries; when one

package/lib/app/gjs.js

@@ -24,6 +24,7 @@ import { consoleAssignPlugin } from '../plugins/console-assign.js';
 import { gschemaPlugin } from '../plugins/gschema.js';
 import { gresourcePlugin } from '../plugins/gresource.js';
 import { implicitGlobalAssignPlugin } from '../plugins/implicit-global-assign.js';
+import { workerUrlPlugin } from '../plugins/worker-url.js';
 import { shebangPlugin, resolveShebangLine, inputShebangStripPlugin } from '../plugins/shebang.js';
 import { wrapInputWithSideEffects } from '../utils/entry-wrapper.js';
 const _shimDir = dirname(fileURLToPath(import.meta.url));
@@ -206,6 +207,8 @@ export const setupForGjs = async (input) => {
         gschemaPlugin({ mode: 'ignore' }),
         gresourcePlugin({ compressed: 'keep' }),
         implicitGlobalAssignPlugin(),
+        // `new Worker(new URL('./x', import.meta.url))` → the file the CLI builds beside the bundle.
+        ...(input.pluginOptions.workers ? [workerUrlPlugin(input.pluginOptions.workers)] : []),
         // `gi://Ns?version=X&optional` → a guarded import (ADR 0087), claimed `pre`
         // so the externals policy never sees the flagged specifier.
         giOptionalPlugin('gjs'),

package/lib/app/node.js

@@ -14,6 +14,7 @@ import { giOptionalPlugin } from '../plugins/gi-optional.js';
 import { gschemaPlugin } from '../plugins/gschema.js';
 import { gresourcePlugin } from '../plugins/gresource.js';
 import { implicitGlobalAssignPlugin } from '../plugins/implicit-global-assign.js';
+import { workerUrlPlugin } from '../plugins/worker-url.js';
 import { unresolvedWorkspaceImportPlugin } from '../plugins/unresolved-workspace-import.js';
 import { nodeNativeExternalPlugin } from '../plugins/node-native-external.js';
 import { platformResolvePlugin, desktopSuffixChain, desktopOsSuffix, DESKTOP_REFUSED_SUFFIXES, } from '../plugins/platform-resolve.js';
@@ -356,6 +357,8 @@ export const setupForNode = async (input) => {
         gschemaPlugin({ mode: 'ignore' }),
         gresourcePlugin({ compressed: 'keep' }),
         implicitGlobalAssignPlugin(),
+        // `new Worker(new URL('./x', import.meta.url))` → the file the CLI builds beside the bundle.
+        ...(input.pluginOptions.workers ? [workerUrlPlugin(input.pluginOptions.workers)] : []),
         // Decides the fate of `@girs/*` before `aliasPlugin` and the default
         // resolver (same composition order as `app/browser.ts`). `emptyGirs` is
         // gated on `gjsSourceBuild`:

package/lib/index.d.ts

@@ -13,6 +13,8 @@ export type { GiSystemProbe } from './plugins/gi-runtime-paths.js';
 export type { ProcessStubPluginOptions } from './plugins/process-stub.js';
 export { findImplicitGlobalAssignments, rewriteImplicitGlobalAssignments, implicitGlobalAssignPlugin, IMPLICIT_GLOBAL_ASSIGN_PLUGIN, } from './plugins/implicit-global-assign.js';
 export type { ImplicitGlobalAssignment } from './plugins/implicit-global-assign.js';
+export { workerUrlPlugin, findWorkerUrls, rewriteWorkerUrls, WorkerEntries, WORKER_URL_PLUGIN, } from './plugins/worker-url.js';
+export type { WorkerUrlSite } from './plugins/worker-url.js';
 export { gschemaPlugin, parseGschema, GSCHEMA_PLUGIN, GSCHEMA_REGISTER } from './plugins/gschema.js';
 export type { GschemaOut, GschemaKey, GschemaPluginOptions } from './plugins/gschema.js';
 export { gresourcePlugin, compileGresource, prepareGresourceXml, gresourceModuleSource, GRESOURCE_PLUGIN, } from './plugins/gresource.js';

package/lib/index.js

@@ -9,6 +9,7 @@ export { giRuntimePathsStub } from './plugins/gi-runtime-paths.js';
 export { giOptionalPlugin, giOptionalShimSource, giOptionalNodeShimSource, giOptionalMarkerSource, parseOptionalGiSpecifier, GI_OPTIONAL_FLAG, GI_OPTIONAL_MARKER, } from './plugins/gi-optional.js';
 export { bindConsoleLocally, consoleAssignPlugin, freeConsoleAssignmentInsertion, CONSOLE_LOCAL_BINDING, } from './plugins/console-assign.js';
 export { findImplicitGlobalAssignments, rewriteImplicitGlobalAssignments, implicitGlobalAssignPlugin, IMPLICIT_GLOBAL_ASSIGN_PLUGIN, } from './plugins/implicit-global-assign.js';
+export { workerUrlPlugin, findWorkerUrls, rewriteWorkerUrls, WorkerEntries, WORKER_URL_PLUGIN, } from './plugins/worker-url.js';
 export { gschemaPlugin, parseGschema, GSCHEMA_PLUGIN, GSCHEMA_REGISTER } from './plugins/gschema.js';
 export { gresourcePlugin, compileGresource, prepareGresourceXml, gresourceModuleSource, GRESOURCE_PLUGIN, } from './plugins/gresource.js';
 export { cssAsStringPlugin } from './plugins/css-as-string.js';

package/lib/plugins/worker-url.d.ts

@@ -0,0 +1,40 @@
+import type { Plugin } from 'rolldown';
+export declare const WORKER_URL_PLUGIN = "gjsify-worker-url";
+/** One `new URL('<spec>', import.meta.url)` argument of a Worker constructor. */
+export interface WorkerUrlSite {
+    /** The specifier as written — what the registry resolves relative to the importer. */
+    readonly specifier: string;
+    /** Inclusive start offset of the string literal, quotes included. */
+    readonly start: number;
+    /** Exclusive end offset of the string literal. */
+    readonly end: number;
+}
+/** Every Worker constructor in `code` that names its script by a literal URL, source order. */
+export declare function findWorkerUrls(code: string, id: string): WorkerUrlSite[];
+/**
+ * What a worker script is called next to the bundle, and which sources still need building.
+ *
+ * ONE instance per `gjsify build`, shared with every nested worker build: the name a source
+ * gets must be the same in the bundle that spawns it and in the one that spawns it from
+ * another worker, and a source already built must not be built again.
+ */
+export declare class WorkerEntries {
+    #private;
+    readonly extension: string;
+    /** @param extension the main bundle's extension (`.js`, `.mjs`), mirrored so a worker loads like its parent. */
+    constructor(extension?: string);
+    /** The file name (no directory) the worker built from `source` gets beside the bundle. */
+    register(source: string): string;
+    /** Registered sources not yet handed out, with their file names; each is returned once. */
+    takePending(): {
+        source: string;
+        fileName: string;
+    }[];
+}
+/** `code` with each resolvable worker URL pointed at its emitted file, or null when nothing changed. */
+export declare function rewriteWorkerUrls(code: string, id: string, resolveSource: (specifier: string) => Promise<string | null>, entries: WorkerEntries): Promise<string | null>;
+/**
+ * Composed by `--app gjs|node|browser` when the CLI hands over a {@link WorkerEntries}; absent
+ * registry, absent plugin — a library build keeps its `new URL` for the consumer's own bundler.
+ */
+export declare function workerUrlPlugin(entries: WorkerEntries): Plugin;

package/lib/plugins/worker-url.js

@@ -0,0 +1,209 @@
+// `new Worker(new URL('./x.ts', import.meta.url))` — ship the worker next to the bundle.
+//
+// A bundle is ONE file, so after `gjsify build` the literal still names `./x.ts`, a path
+// that exists beside the SOURCE and nowhere beside the artifact: at runtime the Worker dies
+// with `Cannot find module …/x.ts` (#2338). esbuild and Vite turn the same expression into a
+// second entry and rewrite the URL; this does the same.
+//
+// THE SPLIT, AND WHY IT IS NOT ALL IN THE PLUGIN. A plugin could `emitFile` the worker as a
+// chunk, but the native rolldown engine (`@gjsify/rolldown-native`, the only engine under
+// GJS) exposes no `emitFile` — `applyBrowserHtml` is a CLI step for the same reason. So the
+// plugin does the half every engine can do, the URL rewrite, and records each worker it saw
+// in a {@link WorkerEntries} registry; the CLI then bundles every registered source as its
+// own app build, next to the main output, with the main build's config. A nested build runs
+// this plugin again, so a worker that starts a worker is followed with no extra rule, and the
+// shared registry is what ends a cycle (a worker that spawns itself).
+//
+// WHAT COUNTS. `new <Worker>(new URL(<string literal>, import.meta.url), …)` where `<Worker>`
+// is the identifier `Worker` (the WHATWG global from `@gjsify/web-worker`, or the name imported
+// from `worker_threads` — also under an alias) or a `<x>.Worker` member (`wt.Worker`,
+// `import * as wt`). Anything else is left byte-identical, on purpose: a computed specifier
+// has no build-time answer, and a rewrite of the wrong `new URL` would break a program that
+// was fine.
+//
+// WHY AN AST: `new Worker(new URL(` inside a string, a comment or a template shares the bytes
+// of the shape. The parser is the shared one (`utils/inline-static-reads.ts`), so a `.ts`
+// source arrives with its type syntax intact.
+import { basename, extname } from 'node:path';
+import { parseSource } from '../utils/inline-static-reads.js';
+import { REWRITE_FILTER } from './rewrite-node-modules-paths.js';
+export const WORKER_URL_PLUGIN = 'gjsify-worker-url';
+const WORKER_THREADS = /^(?:node:)?worker_threads$/;
+function childrenOf(node) {
+    const out = [];
+    for (const value of Object.values(node)) {
+        const items = Array.isArray(value) ? value : [value];
+        for (const item of items) {
+            if (item !== null && typeof item === 'object' && typeof item.type === 'string') {
+                out.push(item);
+            }
+        }
+    }
+    return out;
+}
+/** Local names that `worker_threads`' `Worker` is bound to — `import { Worker as W }` yields `W`. */
+function workerAliases(program) {
+    const aliases = new Set(['Worker']);
+    for (const stmt of childrenOf(program)) {
+        if (stmt.type !== 'ImportDeclaration' || typeof stmt.source?.value !== 'string')
+            continue;
+        if (!WORKER_THREADS.test(stmt.source.value))
+            continue;
+        for (const spec of stmt.specifiers ?? []) {
+            if (spec.type === 'ImportSpecifier' && spec.imported?.name === 'Worker' && spec.local?.name) {
+                aliases.add(spec.local.name);
+            }
+        }
+    }
+    return aliases;
+}
+function isWorkerCallee(callee, aliases) {
+    if (!callee)
+        return false;
+    if (callee.type === 'Identifier')
+        return callee.name !== undefined && aliases.has(callee.name);
+    return (callee.type === 'MemberExpression' &&
+        callee.computed !== true &&
+        callee.property?.type === 'Identifier' &&
+        callee.property.name === 'Worker');
+}
+function isImportMetaUrl(node) {
+    return (node?.type === 'MemberExpression' &&
+        node.computed !== true &&
+        node.property?.name === 'url' &&
+        node.object?.type === 'MetaProperty' &&
+        node.object.meta?.name === 'import');
+}
+/** The `new URL('<literal>', import.meta.url)` shape, as the literal node, or null. */
+function urlLiteral(node) {
+    if (node?.type !== 'NewExpression' || node.callee?.type !== 'Identifier' || node.callee.name !== 'URL')
+        return null;
+    const [spec, base] = node.arguments ?? [];
+    if (spec?.type !== 'Literal' || typeof spec.value !== 'string')
+        return null;
+    return isImportMetaUrl(base) ? spec : null;
+}
+/** Every Worker constructor in `code` that names its script by a literal URL, source order. */
+export function findWorkerUrls(code, id) {
+    let program;
+    try {
+        program = parseSource(code, id);
+    }
+    catch {
+        // A module the pinned parser cannot read keeps its literal; the bundler reports the parse itself.
+        return [];
+    }
+    const aliases = workerAliases(program);
+    const sites = [];
+    const stack = [program];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node.type === 'NewExpression' && isWorkerCallee(node.callee, aliases)) {
+            const literal = urlLiteral(node.arguments?.[0]);
+            if (literal) {
+                sites.push({ specifier: literal.value, start: literal.start, end: literal.end });
+            }
+        }
+        for (const child of childrenOf(node))
+            stack.push(child);
+    }
+    return sites.sort((a, b) => a.start - b.start);
+}
+/** Only a relative specifier names a file beside the importer; `file:`, `http:` and `/abs` do not. */
+const isRelative = (specifier) => /^\.\.?\//.test(specifier);
+/**
+ * What a worker script is called next to the bundle, and which sources still need building.
+ *
+ * ONE instance per `gjsify build`, shared with every nested worker build: the name a source
+ * gets must be the same in the bundle that spawns it and in the one that spawns it from
+ * another worker, and a source already built must not be built again.
+ */
+export class WorkerEntries {
+    extension;
+    #names = new Map();
+    #taken = new Set();
+    #built = new Set();
+    /** @param extension the main bundle's extension (`.js`, `.mjs`), mirrored so a worker loads like its parent. */
+    constructor(extension = '.js') {
+        this.extension = extension;
+    }
+    /** The file name (no directory) the worker built from `source` gets beside the bundle. */
+    register(source) {
+        const known = this.#names.get(source);
+        if (known !== undefined)
+            return known;
+        const stem = basename(source, extname(source));
+        let name = `${stem}.worker${this.extension}`;
+        // Two sources with one stem (`a/worker.ts`, `b/worker.ts`) must not overwrite each other.
+        if (this.#taken.has(name))
+            name = `${stem}-${pathHash(source)}.worker${this.extension}`;
+        this.#taken.add(name);
+        this.#names.set(source, name);
+        return name;
+    }
+    /** Registered sources not yet handed out, with their file names; each is returned once. */
+    takePending() {
+        const pending = [];
+        for (const [source, fileName] of this.#names) {
+            if (this.#built.has(source))
+                continue;
+            this.#built.add(source);
+            pending.push({ source, fileName });
+        }
+        return pending;
+    }
+}
+/** FNV-1a over the path, base 36 — stable across builds and engines, no crypto dependency. */
+function pathHash(path) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < path.length; i++) {
+        hash ^= path.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193) >>> 0;
+    }
+    return hash.toString(36);
+}
+/** `code` with each resolvable worker URL pointed at its emitted file, or null when nothing changed. */
+export async function rewriteWorkerUrls(code, id, resolveSource, entries) {
+    const sites = findWorkerUrls(code, id).filter((site) => isRelative(site.specifier));
+    if (sites.length === 0)
+        return null;
+    let out = code;
+    let changed = false;
+    // Descending, so each splice leaves the offsets of the ones before it valid.
+    for (const site of sites.sort((a, b) => b.start - a.start)) {
+        const source = await resolveSource(site.specifier);
+        if (source === null)
+            continue;
+        out = `${out.slice(0, site.start)}${JSON.stringify(`./${entries.register(source)}`)}${out.slice(site.end)}`;
+        changed = true;
+    }
+    return changed ? out : null;
+}
+/**
+ * Composed by `--app gjs|node|browser` when the CLI hands over a {@link WorkerEntries}; absent
+ * registry, absent plugin — a library build keeps its `new URL` for the consumer's own bundler.
+ */
+export function workerUrlPlugin(entries) {
+    return {
+        name: WORKER_URL_PLUGIN,
+        transform: {
+            filter: { id: REWRITE_FILTER },
+            async handler(code, id) {
+                if (!REWRITE_FILTER.test(id))
+                    return null;
+                // Cheap gate: the parse is paid only by a module that can contain the shape.
+                if (!code.includes('import.meta.url') || !code.includes('Worker'))
+                    return null;
+                const out = await rewriteWorkerUrls(code, id, async (specifier) => {
+                    const resolved = await this.resolve(specifier, id);
+                    if (!resolved || resolved.external) {
+                        this.warn(`${id}: cannot resolve worker script ${specifier}; left as written`);
+                        return null;
+                    }
+                    return resolved.id.split('?')[0];
+                }, entries);
+                return out === null ? null : { code: out, map: null };
+            },
+        },
+    };
+}

package/lib/types/plugin-options.d.ts

@@ -1,3 +1,4 @@
+import type { WorkerEntries } from '../plugins/worker-url.js';
 import type { NativescriptLocaleOptions } from '../plugins/nativescript-locale.js';
 import type { App } from './app.js';
 import type { SourceDialect } from './source-dialect.js';
@@ -9,6 +10,12 @@ export interface GjsifyCssOptions {
     minify?: boolean;
 }
 export interface PluginOptions {
+    /**
+     * Registry the worker-URL plugin records `new Worker(new URL('./x', import.meta.url))`
+     * targets in. Set by the CLI for `--app gjs|node|browser`, which then builds every
+     * registered source beside the bundle; unset leaves the URL untouched.
+     */
+    workers?: WorkerEntries;
     debug?: boolean;
     app?: App;
     aliases?: Record<string, string>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/rolldown-plugin-gjsify",
-    "version": "0.64.15",
+    "version": "0.64.16",
     "description": "Rolldown / Rollup / Vite plugin orchestrator for GJS, Node, and Browser targets",
     "type": "module",
     "main": "lib/index.js",
@@ -67,13 +67,13 @@
     ],
     "license": "MIT",
     "dependencies": {
-        "@gjsify/console": "^0.64.15",
-        "@gjsify/resolve-npm": "^0.64.15",
-        "@gjsify/rolldown-plugin-deepkit": "^0.64.15",
-        "@gjsify/rolldown-plugin-pnp": "^0.64.15",
-        "@gjsify/utils": "^0.64.15",
-        "@gjsify/vite-plugin-blueprint": "^0.64.15",
-        "@gjsify/vite-plugin-gettext": "^0.64.15",
+        "@gjsify/console": "^0.64.16",
+        "@gjsify/resolve-npm": "^0.64.16",
+        "@gjsify/rolldown-plugin-deepkit": "^0.64.16",
+        "@gjsify/rolldown-plugin-pnp": "^0.64.16",
+        "@gjsify/utils": "^0.64.16",
+        "@gjsify/vite-plugin-blueprint": "^0.64.16",
+        "@gjsify/vite-plugin-gettext": "^0.64.16",
         "@rollup/pluginutils": "^5.4.0",
         "acorn": "^8.17.0",
         "acorn-typescript": "^1.4.13",
@@ -83,7 +83,7 @@
         "sass": "^1.101.0"
     },
     "peerDependencies": {
-        "@gjsify/lightningcss-native": "^0.64.15",
+        "@gjsify/lightningcss-native": "^0.64.16",
         "rolldown": "^1.1.4"
     },
     "peerDependenciesMeta": {
@@ -95,8 +95,8 @@
         }
     },
     "devDependencies": {
-        "@gjsify/cli": "^0.64.15",
-        "@gjsify/unit": "^0.64.15",
+        "@gjsify/cli": "^0.64.16",
+        "@gjsify/unit": "^0.64.16",
         "@types/node": "^25.9.2",
         "rolldown": "^1.1.4",
         "typescript": "^6.0.3"