@freshpack/webpack 0.0.0-stage → 1.0.1

package/CHANGELOG.md

@@ -0,0 +1,10 @@
+# @freshpack/webpack
+
+## 1.0.1
+
+### Patch Changes
+
+- prepack
+
+- Updated dependencies:
+  - @freshpack/core@3.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yaroslav Bolyukin <iam@lach.pw>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/denoEnv.d.ts

@@ -0,0 +1,12 @@
+import { type Compiler } from "webpack";
+export type DenoEnvOptions = {
+    allowedEnv?: (string | RegExp)[];
+};
+/**
+ * DenoEnvPlugin replaces calls to `Deno.env.get` with a constant expression of environment variable name.
+ */
+export declare class DenoEnvPlugin {
+    #private;
+    constructor(opts?: DenoEnvOptions);
+    apply(compiler: Compiler): void;
+}

package/denoEnv.js

@@ -0,0 +1,61 @@
+import Webpack from "webpack";
+const NAME = "DenoEnvPlugin";
+const PARSER_TYPES = [
+    "javascript/auto",
+    "javascript/dynamic",
+    "javascript/esm",
+];
+/**
+ * DenoEnvPlugin replaces calls to `Deno.env.get` with a constant expression of environment variable name.
+ */
+export class DenoEnvPlugin {
+    #allowed;
+    constructor(opts = {}) {
+        this.#allowed = [
+            ...opts.allowedEnv ?? [],
+            /^FRESH_PUBLIC_/,
+            "NODE_ENV",
+            "DENO_DEPLOYMENT_ID",
+            "GITHUB_SHA",
+            "CI_COMMIT_SHA",
+            "CI",
+        ];
+    }
+    #isAllowed(name) {
+        return this.#allowed.some((allowed) => allowed instanceof RegExp ? allowed.test(name) : allowed === name);
+    }
+    #value(name, compiler) {
+        if (name === "NODE_ENV") {
+            const mode = compiler.options.mode;
+            if (mode !== undefined && mode !== "none")
+                return mode;
+        }
+        return Deno.env.get(name);
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap(NAME, (_compilation, { normalModuleFactory }) => {
+            const handler = (parser) => {
+                parser.hooks.call.for("Deno.env.get").tap(NAME, (expr) => {
+                    const [arg] = expr.arguments;
+                    if (expr.arguments.length !== 1 || arg.type !== "Literal" ||
+                        typeof arg.value !== "string") {
+                        return;
+                    }
+                    const name = arg.value;
+                    if (!this.#isAllowed(name)) {
+                        throw new Error(`Env var is not allowed in bundling: ${name}`);
+                    }
+                    const value = this.#value(name, compiler);
+                    const dep = new Webpack.dependencies.ConstDependency(value === undefined ? "undefined" : JSON.stringify(value), expr.range);
+                    if (expr.loc)
+                        dep.loc = expr.loc;
+                    parser.state.module.addPresentationalDependency(dep);
+                    return true;
+                });
+            };
+            for (const type of PARSER_TYPES) {
+                normalModuleFactory.hooks.parser.for(type).tap(NAME, handler);
+            }
+        });
+    }
+}

package/fresh.d.ts

@@ -0,0 +1,39 @@
+import { type FsRouteFileNoMod } from "@freshpack/core/internal-dev";
+import Webpack from "webpack";
+import { ProdBuildCache } from "@freshpack/core/internal";
+import { type DenoEnvOptions } from "./denoEnv.js";
+import { type RawImportsOptions } from "./rawImports.js";
+interface WebpackFreshCompilation extends Webpack.Compilation {
+    freshRoutes: FsRouteFileNoMod<unknown>[];
+    freshIslands: {
+        entryName: string;
+        filePath: string;
+    }[];
+    freshRoot: string;
+    buildId: string;
+    prodBuildCache: ProdBuildCache<unknown>;
+}
+export declare function assertFreshCompilation(compilation: Webpack.Compilation): asserts compilation is WebpackFreshCompilation;
+export declare class FreshPlugin {
+    #private;
+    baseUrl: URL;
+    importHelper: (path: string) => Promise<Record<string, unknown>>;
+    options: {
+        env?: DenoEnvOptions;
+        rawImports?: RawImportsOptions;
+    };
+    /**
+     * @param baseUrl Location of fresh project root directory, you can specify it as `new URL('.', import.meta.url)` in build.ts
+     * @param importHelper JSR dynamic file import workaround: You should pass `(path) => import(path)` here, where the function
+     *                     should be defined anywhere outside of JSR published package. See this for details: https://github.com/denoland/deno/discussions/26266
+     *                     This function will always be called with absolute path.
+     */
+    constructor(baseUrl: URL, importHelper: (path: string) => Promise<Record<string, unknown>>, options?: {
+        env?: DenoEnvOptions;
+        rawImports?: RawImportsOptions;
+    });
+    pathRelativeToBase(path: string): string;
+    pathRelativeToDist(path: string): string;
+    apply(compiler: Webpack.Compiler): void;
+}
+export {};

package/fresh.js

@@ -0,0 +1,268 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { crawlFsItem, } from "@freshpack/core/internal-dev";
+import Webpack from "webpack";
+import { assertAbsolutePath, assertDirURL, manglePath, stripFileUrl, } from "./util.js";
+import { assert } from "@std/assert";
+import { IslandPreparer, ProdBuildCache } from "@freshpack/core/internal";
+import { extname as extnamePosix, join as joinPosix, relative as relativePosix, } from "@std/path/posix";
+import { contentType as getStdContentType } from "@std/media-types/content-type";
+import { encodeHex } from "@std/encoding";
+import { UnmapPlugin } from "./unmap.js";
+import { DenoEnvPlugin } from "./denoEnv.js";
+import { ViteIgnorePlugin } from "./viteComment.js";
+import { RawImportsPlugin } from "./rawImports.js";
+import { js, toJsRaw } from "./quasiquote.js";
+export function assertFreshCompilation(compilation) {
+    assert("freshRoutes" in compilation && "freshIslands" in compilation &&
+        "freshRoot" in compilation, "missing fresh data in compilation, did you add WebpackFreshEntries plugin?");
+}
+function getMainChunkName(basePath, e) {
+    const entryChunk = e.getEntrypointChunk();
+    const files = [...entryChunk.files].map((v) => joinPosix(basePath, v));
+    return files[0];
+}
+function getChunkFiles(basePath, e) {
+    return e.getFiles().map((v) => joinPosix(basePath, v));
+}
+export class FreshPlugin {
+    baseUrl;
+    importHelper;
+    options;
+    /**
+     * @param baseUrl Location of fresh project root directory, you can specify it as `new URL('.', import.meta.url)` in build.ts
+     * @param importHelper JSR dynamic file import workaround: You should pass `(path) => import(path)` here, where the function
+     *                     should be defined anywhere outside of JSR published package. See this for details: https://github.com/denoland/deno/discussions/26266
+     *                     This function will always be called with absolute path.
+     */
+    constructor(baseUrl, importHelper, options = {}) {
+        this.baseUrl = baseUrl;
+        this.importHelper = importHelper;
+        this.options = options;
+        assertDirURL(this.baseUrl);
+        if (!importHelper) {
+            console.warn("[FreshPlugin]", "importHelper is not set, jsr release of @freshpack/webpack doesn't work without it: https://github.com/denoland/deno/discussions/26266#discussioncomment-12198284");
+            this.importHelper = (path) => import(__rewriteRelativeImportExtension(path));
+        }
+    }
+    pathRelativeToBase(path) {
+        return relativePosix(this.baseUrl.pathname, path);
+    }
+    #dist;
+    pathRelativeToDist(path) {
+        assert(this.#dist, "dist path was not determined yet");
+        return relativePosix(this.#dist, path);
+    }
+    apply(compiler) {
+        {
+            // HACK: Webpack does not export EntryDependency, and it is impossible to use EntryPlugin, as
+            // it wants to modify make stage, yet we have already reached this stage when we want to use
+            // this plugin.
+            //
+            // Solvable by creating custom dependency plugin, or requiring user to manually specify
+            // at least one entry... Or by registering EntryDependency manually as done here.
+            const EntryDependency = Webpack.EntryPlugin.createDependency(`dummy`, {}).constructor;
+            compiler.hooks.compilation.tap(FreshPlugin.name, (compilation, { normalModuleFactory }) => {
+                compilation.dependencyFactories.set(EntryDependency, normalModuleFactory);
+            });
+        }
+        (new UnmapPlugin()).apply(compiler);
+        (new DenoEnvPlugin(this.options.env)).apply(compiler);
+        (new ViteIgnorePlugin()).apply(compiler);
+        (new RawImportsPlugin(this.options.rawImports)).apply(compiler);
+        // Some @std and other packages detect deno on presence of Deno global, dead-code-elimnate this stuff
+        (new Webpack.DefinePlugin({ Deno: "undefined" })).apply(compiler);
+        compiler.hooks.make.tapPromise(FreshPlugin.name, async (_compilation) => {
+            const compilation = _compilation;
+            this.#dist = compilation.outputOptions.path;
+            const compilationId = Date.now().toString(36);
+            // Ensure hot chunks are resolved from correct path, they can't contain compilationId in name
+            compilation.outputOptions.publicPath = "/";
+            {
+                // Chunks are content-addressed in prod, and have readable names using standard fresh cache pruning in dev
+                if (compiler.options.mode === "production") {
+                    compilation.outputOptions.filename =
+                        `_fresh/js/c/[contenthash].mjs`;
+                    compilation.outputOptions.chunkFilename =
+                        `_fresh/js/c/[contenthash].mjs`;
+                    compilation.outputOptions.workerChunkFilename =
+                        `_fresh/js/c/[contenthash].mjs`;
+                }
+                else {
+                    compilation.outputOptions.filename =
+                        `_fresh/js/${compilationId}/[id].mjs`;
+                    compilation.outputOptions.chunkFilename =
+                        `_fresh/js/${compilationId}/[id].mjs`;
+                    compilation.outputOptions.workerChunkFilename =
+                        `_fresh/js/${compilationId}/[id].mjs`;
+                }
+                // Assets are always content-addressed
+                compilation.outputOptions.assetModuleFilename =
+                    `_fresh/js/c/[hash][ext][query]`;
+                compilation.outputOptions.webassemblyModuleFilename =
+                    `_fresh/js/c/[hash].wasm`;
+            }
+            compilation.hooks.processAssets.tapPromise({
+                name: FreshPlugin.name,
+                stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE,
+            }, async (assets) => {
+                compilation.getAssets();
+                const cacheOut = [
+                    js `import{IslandPreparer,ProdBuildCache}from"@freshpack/core/internal"`,
+                    js `const islands=new Map()`,
+                    js `const islandPreparer=new IslandPreparer()`,
+                ];
+                const staticFiles = new Map();
+                const islands = new Map();
+                const islandPreparer = new IslandPreparer();
+                for (const island of compilation.freshIslands) {
+                    const entrypoint = compilation.entrypoints.get(island.entryName);
+                    assert(entrypoint, `unable to find island entrypoint: ${island.entryName}`);
+                    const file = getMainChunkName(`/`, entrypoint);
+                    islandPreparer.prepare(islands, await this.importHelper(island.filePath), file, island.entryName, []);
+                    const importPath = this.pathRelativeToDist(island.filePath);
+                    cacheOut.push(js `islandPreparer.prepare(islands,await import(${importPath}),${file},${island.entryName},[])`);
+                }
+                const fsRoutesOut = [];
+                const fsRoutes = await Promise.all(compilation.freshRoutes.map(async (v) => {
+                    const importPath = this.pathRelativeToDist(v.filePath);
+                    fsRoutesOut.push(toJsRaw({
+                        id: v.id,
+                        mod: v.lazy
+                            ? js `()=>import(${importPath})`
+                            : js `await import(${importPath})`,
+                        type: v.type,
+                        pattern: v.pattern,
+                        routePattern: v.routePattern,
+                    }));
+                    assertAbsolutePath(v.filePath);
+                    return {
+                        ...v,
+                        mod: v.lazy
+                            ? () => this.importHelper(v.filePath)
+                            : await this.importHelper(v.filePath),
+                    };
+                }));
+                cacheOut.push(js `const fsRoutes=${fsRoutesOut}`);
+                const clientEntrypoint = compilation.entrypoints.get("client-entry");
+                assert(clientEntrypoint, `unable to find client entrypoint`);
+                const clientEntry = getMainChunkName(`/`, clientEntrypoint);
+                const clientEntryAssets = getChunkFiles(`/`, clientEntrypoint);
+                const staticFilesOut = new Map();
+                for (const _asset of compilation.getAssets()) {
+                    const asset = compilation.getAsset(_asset.name);
+                    const file_ = assets[asset.name]
+                        .buffer();
+                    const file = file_;
+                    const hash = await crypto.subtle.digest("SHA-1", file.buffer);
+                    const ext = extnamePosix(asset.name);
+                    const contentType = getStdContentType(ext) ?? "text/plain";
+                    const name = "/" + asset.name;
+                    staticFiles.set(name, {
+                        name,
+                        filePath: asset.name,
+                        contentType,
+                        hash: encodeHex(hash),
+                        data: file,
+                        size: file.length,
+                    });
+                    staticFilesOut.set(name, toJsRaw({
+                        name,
+                        filePath: js `new URL(${asset.name}, import.meta.url).pathname`,
+                        hash: encodeHex(hash),
+                        contentType,
+                    }));
+                }
+                cacheOut.push(js `const staticFiles=${staticFilesOut}`);
+                cacheOut.push(js `export default new ProdBuildCache(${compilation.freshRoot}, ${({
+                    version: compilationId,
+                    clientEntry,
+                    entryAssets: toJsRaw(clientEntryAssets),
+                    islands: js `islands`,
+                    fsRoutes: js `fsRoutes`,
+                    staticFiles: js `staticFiles`,
+                })})`);
+                // Here ProdBuildCache is being used as MemoryBuildCache from fresh
+                const cache = new ProdBuildCache(compilation.freshRoot, {
+                    version: compilationId,
+                    clientEntry,
+                    fsRoutes,
+                    staticFiles,
+                    islands,
+                    entryAssets: clientEntryAssets,
+                });
+                cache.readFile = (pathname) => {
+                    const st = staticFiles.get(pathname);
+                    if (!st) {
+                        return Promise.resolve(null);
+                    }
+                    return Promise.resolve({
+                        contentType: st.contentType,
+                        hash: st.hash,
+                        readable: new ReadableStream({
+                            start(v) {
+                                v.enqueue(st.data);
+                                v.close();
+                            },
+                        }),
+                        size: st.size,
+                        close() { },
+                    });
+                };
+                compilation.prodBuildCache = cache;
+                compilation.emitAsset("./cache.mjs", new compiler.webpack.sources.RawSource(cacheOut.map((v) => v._jsRaw).join("\n")));
+            });
+            const item = await crawlFsItem({
+                islandDir: stripFileUrl(new URL("islands", this.baseUrl).href),
+                routeDir: stripFileUrl(new URL("routes", this.baseUrl).href),
+                ignore: [],
+            });
+            compilation.freshRoutes = item.routes;
+            compilation.freshIslands = [];
+            compilation.freshRoot = this.pathRelativeToBase(".");
+            const addEntryPromises = [];
+            let isId = 0;
+            for (const island of item.islands) {
+                const name = compiler.options.mode === "production"
+                    ? `is${isId++}`
+                    : manglePath(island);
+                compilation.freshIslands.push({ entryName: name, filePath: island });
+                addEntryPromises.push(new Promise((res, rej) => compilation.addEntry("", Webpack.EntryPlugin.createDependency(`${island}`, {
+                    name,
+                }), {
+                    name,
+                    library: {
+                        type: "module",
+                    },
+                }, (err) => {
+                    if (err)
+                        return rej(err);
+                    res();
+                })));
+            }
+            {
+                const name = "client-entry";
+                const file = stripFileUrl(new URL("./client.ts", this.baseUrl).href);
+                addEntryPromises.push(new Promise((res, rej) => compilation.addEntry("", Webpack.EntryPlugin.createDependency(file, {
+                    name,
+                }), {
+                    name,
+                    library: {
+                        type: "module",
+                    },
+                }, (e) => {
+                    if (e)
+                        return rej(e);
+                    res();
+                })));
+            }
+            await Promise.all(addEntryPromises);
+        });
+    }
+}

package/mod.d.ts

@@ -0,0 +1,7 @@
+export { DenoEnvPlugin } from "./denoEnv.js";
+export { FreshPlugin } from "./fresh.js";
+export { ViteIgnorePlugin } from "./viteComment.js";
+export { DenoPreactRefreshPlugin } from "./prefresh-forked/index.js";
+export { DenoLoaderPlugin } from "./resolve.js";
+export { type RawImportsOptions, RawImportsPlugin } from "./rawImports.js";
+export { UnmapPlugin } from "./unmap.js";

package/mod.js

@@ -0,0 +1,7 @@
+export { DenoEnvPlugin } from "./denoEnv.js";
+export { FreshPlugin } from "./fresh.js";
+export { ViteIgnorePlugin } from "./viteComment.js";
+export { DenoPreactRefreshPlugin } from "./prefresh-forked/index.js";
+export { DenoLoaderPlugin } from "./resolve.js";
+export { RawImportsPlugin } from "./rawImports.js";
+export { UnmapPlugin } from "./unmap.js";

package/package.json

@@ -1,6 +1,74 @@
 {
   "name": "@freshpack/webpack",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.1",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./mod.d.ts",
+      "default": "./mod.js"
+    },
+    "./fresh": {
+      "types": "./fresh.d.ts",
+      "default": "./fresh.js"
+    },
+    "./util": {
+      "types": "./util.d.ts",
+      "default": "./util.js"
+    },
+    "./unmap": {
+      "types": "./unmap.d.ts",
+      "default": "./unmap.js"
+    },
+    "./requireHook": {
+      "types": "./requireHook.d.ts",
+      "default": "./requireHook.js"
+    }
+  },
+  "dependencies": {
+    "@deno/loader": "npm:@jsr/deno__loader@^0.5.0",
+    "@freshpack/core": "3.0.2",
+    "@prefresh/utils": "^1.2.1",
+    "@std/assert": "npm:@jsr/std__assert@^1.0.19",
+    "@std/encoding": "npm:@jsr/std__encoding@^1.0.11",
+    "@std/media-types": "npm:@jsr/std__media-types@^1.1.0",
+    "@std/path": "npm:@jsr/std__path@^1.1.6",
+    "webpack": "^5.111.1"
+  },
+  "files": [
+    "denoEnv.d.ts",
+    "denoEnv.js",
+    "fresh.d.ts",
+    "fresh.js",
+    "mod.d.ts",
+    "mod.js",
+    "prefresh-forked/index.d.ts",
+    "prefresh-forked/index.js",
+    "prefresh-forked/loader/index.d.ts",
+    "prefresh-forked/loader/index.js",
+    "prefresh-forked/loader/runtime.js",
+    "prefresh-forked/utils/Runtime.d.ts",
+    "prefresh-forked/utils/Runtime.js",
+    "prefresh-forked/utils/constants.d.ts",
+    "prefresh-forked/utils/constants.js",
+    "prefresh-forked/utils/prefresh.d.ts",
+    "prefresh-forked/utils/prefresh.js",
+    "quasiquote.d.ts",
+    "quasiquote.js",
+    "rawBytesLoader.d.ts",
+    "rawBytesLoader.js",
+    "rawImports.d.ts",
+    "rawImports.js",
+    "requireHook.d.ts",
+    "requireHook.js",
+    "resolve.d.ts",
+    "resolve.js",
+    "transpileLoader.d.ts",
+    "transpileLoader.js",
+    "unmap.d.ts",
+    "unmap.js",
+    "util.d.ts",
+    "util.js",
+    "viteComment.d.ts",
+    "viteComment.js"
+  ]
 }

package/prefresh-forked/index.d.ts

@@ -0,0 +1,15 @@
+import Webpack from "webpack";
+type Options = {
+    overlay?: {
+        module: string;
+    };
+    entryOptions?: string | Webpack.EntryOptions;
+};
+export declare class DenoPreactRefreshPlugin {
+    options: Options;
+    matcher: (str: string) => boolean;
+    constructor(options: Options);
+    webpack5(compiler: Webpack.Compiler, RuntimeGlobals: typeof Webpack.RuntimeGlobals): void;
+    apply(compiler: Webpack.Compiler): void;
+}
+export {};

package/prefresh-forked/index.js

@@ -0,0 +1,57 @@
+/* FIXME: Typings are awful in this file, the port was very crude */
+import Webpack from "webpack";
+import { injectRefreshFunctions, matcherOptions, NAME, prefreshUtils, } from "./utils/constants.js";
+import { PrefreshRuntimeModule } from "./utils/Runtime.js";
+import { defineRequire } from "../requireHook.js";
+const internalPrefreshLoader = defineRequire("@freshpack/webpack/internal-prefresh-loader", await import("./loader/index.js"));
+export class DenoPreactRefreshPlugin {
+    options;
+    matcher;
+    constructor(options) {
+        this.options = options;
+        this.matcher = Webpack.ModuleFilenameHelpers.matchObject.bind(undefined, matcherOptions);
+    }
+    webpack5(compiler, RuntimeGlobals) {
+        compiler.hooks.compilation.tap(NAME, (compilation, { normalModuleFactory }) => {
+            if (compilation.compiler !== compiler) {
+                return;
+            }
+            injectRefreshFunctions(compilation);
+            compilation.hooks.additionalTreeRuntimeRequirements.tap(NAME, (chunk, runtimeRequirements) => {
+                runtimeRequirements.add(RuntimeGlobals.interceptModuleExecution);
+                compilation.addRuntimeModule(chunk, new PrefreshRuntimeModule());
+            });
+            normalModuleFactory.hooks.afterResolve.tap(NAME, ({ createData: data }) => {
+                if (this.matcher(data.resource) &&
+                    !data.resource.includes("@prefresh") &&
+                    !data.resource.includes("/prefresh-forked/loader/") &&
+                    !data.resource.includes("/prefresh-forked/utils/")) {
+                    data.loaders.unshift({
+                        loader: internalPrefreshLoader,
+                        options: undefined,
+                    });
+                }
+            });
+        });
+    }
+    apply(compiler) {
+        if (compiler.options.mode === "production") {
+            return;
+        }
+        const provide = {
+            [prefreshUtils]: import.meta.resolve("./utils/prefresh.js"),
+        };
+        if (this.options.overlay) {
+            provide.__prefresh_errors__ = import.meta.resolve(this.options.overlay.module);
+        }
+        const providePlugin = new Webpack.ProvidePlugin(provide);
+        providePlugin.apply(compiler);
+        const dependency = Webpack.EntryPlugin.createDependency("@prefresh/core", { name: "@prefresh/core" });
+        compiler.hooks.make.tapAsync(NAME, (compilation, callback) => {
+            compilation.addEntry(compiler.context, dependency, this.options.entryOptions ?? {}, callback);
+        });
+        this.webpack5(compiler, compiler.webpack
+            ? compiler.webpack.RuntimeGlobals
+            : Webpack.RuntimeGlobals);
+    }
+}

package/prefresh-forked/loader/index.d.ts

@@ -0,0 +1,2 @@
+import type Webpack from "webpack";
+export default function RefreshHotLoader(this: any, source: Webpack.sources.SourceMapSource, inputSourceMap: Webpack.sources.SourceMapSource["source"]): void;

package/prefresh-forked/loader/index.js

@@ -0,0 +1,4 @@
+import runtimeText from "./runtime.js" with { type: "text" };
+export default function RefreshHotLoader(source, inputSourceMap) {
+    this.callback(null, source + "\n\n" + runtimeText, inputSourceMap);
+}

package/prefresh-forked/loader/runtime.js

@@ -0,0 +1,70 @@
+// declare const __prefresh_utils__: any;
+// declare const __prefresh_errors__: any;
+// declare const __webpack_module__: any;
+// declare const __webpack_modules__: any;
+// declare const error: any;
+
+const isPrefreshComponent = __prefresh_utils__.shouldBind(__webpack_module__);
+
+// `@vanilla-extract/webpack` does some custom preprocessing where
+// `module.hot` is partially replaced. This leads to our injected
+// code being executed although it shouldn't be:
+//
+// Intermediate result:
+//
+//   if (true) { // <- inlined by intermediate compile step
+//     const previousHotModuleExports = module.hot.data && ...
+//                    // Crash happens here ---^
+//
+// It crashes at that line because some intermediate compiler isn't
+// running in hot mode, but the overall guard condition was compiled
+// down to being truthy. By moving `module.hot` outside of the
+// condition of the if-statement, it will be left as is.
+const moduleHot = __webpack_module__.hot;
+
+if (moduleHot) {
+  const currentExports = __prefresh_utils__.getExports(__webpack_module__);
+  const previousHotModuleExports = moduleHot.data &&
+    moduleHot.data.moduleExports;
+
+  __prefresh_utils__.registerExports(currentExports, __webpack_module__.id);
+
+  if (isPrefreshComponent) {
+    if (previousHotModuleExports) {
+      try {
+        __prefresh_utils__.flush();
+        if (
+          typeof __prefresh_errors__ !== "undefined" &&
+          __prefresh_errors__ &&
+          __prefresh_errors__.clearRuntimeErrors
+        ) {
+          __prefresh_errors__.clearRuntimeErrors();
+        }
+      } catch (e) {
+        // Only available in newer webpack versions.
+        if (moduleHot.invalidate) {
+          moduleHot.invalidate();
+        } else {
+          console.log("[PREFRESH] Failed to flush updates:", e);
+          self.location.reload();
+        }
+      }
+    }
+
+    moduleHot.dispose((data) => {
+      data.moduleExports = __prefresh_utils__.getExports(__webpack_module__);
+    });
+
+    moduleHot.accept(function errorRecovery() {
+      if (
+        typeof __prefresh_errors__ !== "undefined" &&
+        __prefresh_errors__ &&
+        __prefresh_errors__.handleRuntimeError
+      ) {
+        __prefresh_errors__.handleRuntimeError(error);
+      }
+
+      __webpack_modules__[__webpack_module__.id].hot.accept(errorRecovery);
+    });
+  }
+}