@serwist/turbopack 10.0.0-preview.10 → 10.0.0-preview.12

package/dist/index.d.ts

@@ -1,16 +1,16 @@
 import { NextResponse } from "next/server.js";
 import type { InjectManifestOptions } from "./types.js";
 /**
- * Creates a Route Handler that returns the precache manifest.
+ * Creates a Route Handler for Serwist files.
  * @param options Options for {@linkcode getFileManifestEntries}.
  */
 export declare const createSerwistRoute: (options: InjectManifestOptions) => {
-    dynamic: string;
-    dynamicParams: boolean;
-    revalidate: boolean;
-    generateStaticParams: () => {
+    dynamic: "force-static";
+    dynamicParams: false;
+    revalidate: false;
+    generateStaticParams: () => Promise<{
         path: string;
-    }[];
+    }[]>;
     GET: (_: Request, { params }: {
         params: Promise<{
             path: string;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAI9C,OAAO,KAAK,EAAE,qBAAqB,EAAiC,MAAM,YAAY,CAAC;AAuCvF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,GAAI,SAAS,qBAAqB;;;;;;;aA8DzC,OAAO,cAAc;QAAE,MAAM,EAAE,OAAO,CAAC;YAAE,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KAAE;CAYjF,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAI9C,OAAO,KAAK,EAAE,qBAAqB,EAAiC,MAAM,YAAY,CAAC;AAuCvF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,GAAI,SAAS,qBAAqB;;;;;;;aAgFzC,OAAO,cAAc;QAAE,MAAM,EAAE,OAAO,CAAC;YAAE,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KAAE;CAajF,CAAC"}

package/dist/index.js

@@ -61,7 +61,7 @@ const esbuild = import('esbuild-wasm');
 const logSerwistResult = (filePath, buildResult)=>{
     const { count, size, warnings } = buildResult;
     const hasWarnings = warnings && warnings.length > 0;
-    if (filePath === "sw.js") {
+    if (filePath === "sw.js" && (hasWarnings || count > 0)) {
         logger[hasWarnings ? "warn" : "event"](`${cyan(count)} precache entries ${dim(`(${(size / 1024).toFixed(2)} KiB)`)}${hasWarnings ? `\n${yellow([
             "⚠ warnings",
             ...warnings.map((w)=>`  ${w}`),
@@ -89,36 +89,33 @@ const contentTypeMap = {
 const createSerwistRoute = (options)=>{
     const dynamic = "force-static", dynamicParams = false, revalidate = false;
     const validation = validateGetManifestOptions(options).then((config)=>{
-        config.globIgnores.push(rebasePath({
-            file: config.swSrc,
-            baseDirectory: config.globDirectory
-        }));
-        if (!config.manifestTransforms) {
-            config.manifestTransforms = [];
-        }
-        config.manifestTransforms.push((manifestEntries)=>{
-            const manifest = manifestEntries.map((m)=>{
-                if (m.url.startsWith(".next/")) m.url = `/_next/${m.url.slice(6)}`;
-                if (m.url.startsWith("public/")) m.url = path.posix.join(config.basePath, m.url.slice(7));
-                return m;
-            });
-            return {
-                manifest,
-                warnings: []
-            };
-        });
-        return config;
+        return {
+            ...config,
+            disablePrecacheManifest: isDev,
+            additionalPrecacheEntries: isDev ? [] : config.additionalPrecacheEntries,
+            globIgnores: [
+                ...config.globIgnores,
+                rebasePath({
+                    file: config.swSrc,
+                    baseDirectory: config.globDirectory
+                })
+            ],
+            manifestTransforms: [
+                ...config.manifestTransforms ?? [],
+                (manifestEntries)=>{
+                    const manifest = manifestEntries.map((m)=>{
+                        if (m.url.startsWith(".next/")) m.url = `/_next/${m.url.slice(6)}`;
+                        if (m.url.startsWith("public/")) m.url = path.posix.join(config.basePath, m.url.slice(7));
+                        return m;
+                    });
+                    return {
+                        manifest,
+                        warnings: []
+                    };
+                }
+            ]
+        };
     });
-    const generateStaticParams = ()=>{
-        return [
-            {
-                path: "sw.js"
-            },
-            {
-                path: "sw.js.map"
-            }
-        ];
-    };
     let map = null;
     const loadMap = async (filePath)=>{
         const config = await validation;
@@ -131,22 +128,37 @@ const createSerwistRoute = (options)=>{
             warnings
         });
         const result = await (await esbuild).build({
+            sourcemap: true,
+            format: "esm",
+            target: [
+                "chrome64",
+                "edge79",
+                "firefox67",
+                "opera51",
+                "safari12"
+            ],
+            treeShaking: true,
+            minify: !isDev,
+            bundle: true,
+            ...config.esbuildOptions,
+            platform: "browser",
+            define: {
+                ...config.esbuildOptions.define,
+                ...injectionPoint ? {
+                    [injectionPoint]: manifestString
+                } : {}
+            },
+            outdir: config.cwd,
+            write: false,
+            entryNames: "[name]",
+            assetNames: "[name]-[hash]",
+            chunkNames: "[name]-[hash]",
             entryPoints: [
                 {
                     in: config.swSrc,
                     out: "sw"
                 }
-            ],
-            format: "esm",
-            sourcemap: true,
-            bundle: true,
-            write: false,
-            minify: !isDev,
-            define: injectionPoint ? {
-                [injectionPoint]: manifestString
-            } : undefined,
-            outdir: process.cwd(),
-            entryNames: "[name]"
+            ]
         });
         if (result.errors.length) {
             console.error("Failed to build the service worker.", result.errors);
@@ -160,10 +172,20 @@ const createSerwistRoute = (options)=>{
                 e.text
             ]));
     };
+    const generateStaticParams = async ()=>{
+        const config = await validation;
+        if (!map) map = await loadMap("root");
+        return [
+            ...map.keys().map((e)=>({
+                    path: path.relative(config.cwd, e)
+                }))
+        ];
+    };
     const GET = async (_, { params })=>{
         const { path: filePath } = await params;
+        const config = await validation;
         if (!map) map = await loadMap(filePath);
-        return new NextResponse(map.get(path.join(process.cwd(), filePath)), {
+        return new NextResponse(map.get(path.join(config.cwd, filePath)), {
             headers: {
                 "Content-Type": contentTypeMap[path.extname(filePath)] || "text/plain",
                 "Service-Worker-Allowed": "/"

package/dist/index.react.js

@@ -11,6 +11,7 @@ function SerwistProvider({ swUrl, register = true, reloadOnOnline = true, option
         if (!(window.serwist && window.serwist instanceof Serwist) && "serviceWorker" in navigator) {
             window.serwist = new Serwist(swUrl, {
                 ...options,
+                type: options?.type || "module",
                 scope: options?.scope || "/"
             });
         }

package/dist/index.schema.d.ts

@@ -1,144 +1,59 @@
 import z from "zod";
+export declare const turboPartial: z.ZodObject<{
+    cwd: z.ZodPrefault<z.ZodString>;
+    basePath: z.ZodString;
+    esbuildOptions: z.ZodPrefault<z.ZodRecord<z.ZodLiteral<"bundle" | "splitting" | "preserveSymlinks" | "external" | "packages" | "alias" | "loader" | "resolveExtensions" | "mainFields" | "conditions" | "allowOverwrite" | "tsconfig" | "outExtension" | "publicPath" | "inject" | "banner" | "footer" | "plugins" | "sourcemap" | "legalComments" | "sourceRoot" | "sourcesContent" | "format" | "globalName" | "target" | "supported" | "mangleProps" | "reserveProps" | "mangleQuoted" | "mangleCache" | "drop" | "dropLabels" | "minify" | "minifyWhitespace" | "minifyIdentifiers" | "minifySyntax" | "lineLimit" | "charset" | "treeShaking" | "ignoreAnnotations" | "jsx" | "jsxFactory" | "jsxFragment" | "jsxImportSource" | "jsxDev" | "jsxSideEffects" | "define" | "pure" | "keepNames" | "absPaths" | "color" | "logLevel" | "logLimit" | "logOverride" | "tsconfigRaw"> & z.z.core.$partial, z.ZodAny>>;
+}, z.z.core.$strict>;
 export declare const injectManifestOptions: z.ZodPipe<z.ZodObject<{
     cwd: z.ZodPrefault<z.ZodString>;
+    esbuildOptions: z.ZodPrefault<z.ZodRecord<z.ZodLiteral<"bundle" | "splitting" | "preserveSymlinks" | "external" | "packages" | "alias" | "loader" | "resolveExtensions" | "mainFields" | "conditions" | "allowOverwrite" | "tsconfig" | "outExtension" | "publicPath" | "inject" | "banner" | "footer" | "plugins" | "sourcemap" | "legalComments" | "sourceRoot" | "sourcesContent" | "format" | "globalName" | "target" | "supported" | "mangleProps" | "reserveProps" | "mangleQuoted" | "mangleCache" | "drop" | "dropLabels" | "minify" | "minifyWhitespace" | "minifyIdentifiers" | "minifySyntax" | "lineLimit" | "charset" | "treeShaking" | "ignoreAnnotations" | "jsx" | "jsxFactory" | "jsxFragment" | "jsxImportSource" | "jsxDev" | "jsxSideEffects" | "define" | "pure" | "keepNames" | "absPaths" | "color" | "logLevel" | "logLimit" | "logOverride" | "tsconfigRaw"> & z.z.core.$partial, z.ZodAny>>;
     basePath: z.ZodString;
-    globPatterns: z.ZodPrefault<z.ZodArray<z.ZodString>>;
-    globDirectory: z.ZodOptional<z.ZodString>;
-    injectionPoint: z.ZodPrefault<z.ZodString>;
-    swSrc: z.ZodString;
+    additionalPrecacheEntries: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodType<import("@serwist/build").ManifestEntry, import("@serwist/build").ManifestEntry, z.z.core.$ZodTypeInternals<import("@serwist/build").ManifestEntry, import("@serwist/build").ManifestEntry>>]>>>;
+    dontCacheBustURLsMatching: z.ZodOptional<z.ZodCustom<RegExp, RegExp>>;
+    manifestTransforms: z.ZodOptional<z.ZodArray<z.ZodType<import("@serwist/build").ManifestTransform, import("@serwist/build").ManifestTransform, z.z.core.$ZodTypeInternals<import("@serwist/build").ManifestTransform, import("@serwist/build").ManifestTransform>>>>;
+    maximumFileSizeToCacheInBytes: z.ZodDefault<z.ZodNumber>;
+    modifyURLPrefix: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     globFollow: z.ZodDefault<z.ZodBoolean>;
     globIgnores: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    globPatterns: z.ZodPrefault<z.ZodArray<z.ZodString>>;
     globStrict: z.ZodDefault<z.ZodBoolean>;
     templatedURLs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
-    additionalPrecacheEntries: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-        integrity: z.ZodOptional<z.ZodString>;
-        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        url: z.ZodString;
-    }, z.z.core.$strict>]>>>;
-    disablePrecacheManifest: z.ZodDefault<z.ZodBoolean>;
-    dontCacheBustURLsMatching: z.ZodOptional<z.ZodCustom<RegExp, RegExp>>;
-    manifestTransforms: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodCustom<z.z.core.$InferInnerFunctionTypeAsync<z.ZodTuple<[z.ZodArray<z.ZodObject<{
-        size: z.ZodNumber;
-        integrity: z.ZodOptional<z.ZodString>;
-        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        url: z.ZodString;
-    }, z.z.core.$strip>>, z.ZodOptional<z.ZodUnknown>], null>, z.ZodObject<{
-        manifest: z.ZodArray<z.ZodObject<{
-            size: z.ZodNumber;
-            integrity: z.ZodOptional<z.ZodString>;
-            revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            url: z.ZodString;
-        }, z.z.core.$strip>>;
-        warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.z.core.$strict>>, z.z.core.$InferInnerFunctionTypeAsync<z.ZodTuple<[z.ZodArray<z.ZodObject<{
-        size: z.ZodNumber;
-        integrity: z.ZodOptional<z.ZodString>;
-        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        url: z.ZodString;
-    }, z.z.core.$strip>>, z.ZodOptional<z.ZodUnknown>], null>, z.ZodObject<{
-        manifest: z.ZodArray<z.ZodObject<{
-            size: z.ZodNumber;
-            integrity: z.ZodOptional<z.ZodString>;
-            revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            url: z.ZodString;
-        }, z.z.core.$strip>>;
-        warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.z.core.$strict>>>, z.ZodTransform<z.z.core.$InferInnerFunctionTypeAsync<z.ZodTuple<[z.ZodArray<z.ZodObject<{
-        size: z.ZodNumber;
-        integrity: z.ZodOptional<z.ZodString>;
-        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        url: z.ZodString;
-    }, z.z.core.$strip>>, z.ZodOptional<z.ZodUnknown>], null>, z.ZodObject<{
-        manifest: z.ZodArray<z.ZodObject<{
-            size: z.ZodNumber;
-            integrity: z.ZodOptional<z.ZodString>;
-            revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            url: z.ZodString;
-        }, z.z.core.$strip>>;
-        warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.z.core.$strict>>, z.z.core.$InferInnerFunctionTypeAsync<z.ZodTuple<[z.ZodArray<z.ZodObject<{
-        size: z.ZodNumber;
-        integrity: z.ZodOptional<z.ZodString>;
-        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        url: z.ZodString;
-    }, z.z.core.$strip>>, z.ZodOptional<z.ZodUnknown>], null>, z.ZodObject<{
-        manifest: z.ZodArray<z.ZodObject<{
-            size: z.ZodNumber;
-            integrity: z.ZodOptional<z.ZodString>;
-            revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            url: z.ZodString;
-        }, z.z.core.$strip>>;
-        warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.z.core.$strict>>>>>>;
-    maximumFileSizeToCacheInBytes: z.ZodDefault<z.ZodNumber>;
-    modifyURLPrefix: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    injectionPoint: z.ZodPrefault<z.ZodString>;
+    swSrc: z.ZodString;
+    globDirectory: z.ZodOptional<z.ZodString>;
 }, z.z.core.$strict>, z.ZodTransform<{
     swSrc: string;
     globDirectory: string;
     cwd: string;
+    esbuildOptions: Partial<Record<"bundle" | "splitting" | "preserveSymlinks" | "external" | "packages" | "alias" | "loader" | "resolveExtensions" | "mainFields" | "conditions" | "allowOverwrite" | "tsconfig" | "outExtension" | "publicPath" | "inject" | "banner" | "footer" | "plugins" | "sourcemap" | "legalComments" | "sourceRoot" | "sourcesContent" | "format" | "globalName" | "target" | "supported" | "mangleProps" | "reserveProps" | "mangleQuoted" | "mangleCache" | "drop" | "dropLabels" | "minify" | "minifyWhitespace" | "minifyIdentifiers" | "minifySyntax" | "lineLimit" | "charset" | "treeShaking" | "ignoreAnnotations" | "jsx" | "jsxFactory" | "jsxFragment" | "jsxImportSource" | "jsxDev" | "jsxSideEffects" | "define" | "pure" | "keepNames" | "absPaths" | "color" | "logLevel" | "logLimit" | "logOverride" | "tsconfigRaw", any>>;
     basePath: string;
-    globPatterns: string[];
-    injectionPoint: string;
+    maximumFileSizeToCacheInBytes: number;
     globFollow: boolean;
     globIgnores: string[];
+    globPatterns: string[];
     globStrict: boolean;
-    disablePrecacheManifest: boolean;
-    maximumFileSizeToCacheInBytes: number;
-    templatedURLs?: Record<string, string | string[]> | undefined;
-    additionalPrecacheEntries?: (string | {
-        url: string;
-        integrity?: string | undefined;
-        revision?: string | null | undefined;
-    })[] | undefined;
+    injectionPoint: string;
+    additionalPrecacheEntries?: (string | import("@serwist/build").ManifestEntry)[] | undefined;
     dontCacheBustURLsMatching?: RegExp | undefined;
-    manifestTransforms?: z.z.core.$InferInnerFunctionTypeAsync<z.ZodTuple<[z.ZodArray<z.ZodObject<{
-        size: z.ZodNumber;
-        integrity: z.ZodOptional<z.ZodString>;
-        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        url: z.ZodString;
-    }, z.z.core.$strip>>, z.ZodOptional<z.ZodUnknown>], null>, z.ZodObject<{
-        manifest: z.ZodArray<z.ZodObject<{
-            size: z.ZodNumber;
-            integrity: z.ZodOptional<z.ZodString>;
-            revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            url: z.ZodString;
-        }, z.z.core.$strip>>;
-        warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.z.core.$strict>>[] | undefined;
+    manifestTransforms?: import("@serwist/build").ManifestTransform[] | undefined;
     modifyURLPrefix?: Record<string, string> | undefined;
+    templatedURLs?: Record<string, string | string[]> | undefined;
 }, {
     cwd: string;
+    esbuildOptions: Partial<Record<"bundle" | "splitting" | "preserveSymlinks" | "external" | "packages" | "alias" | "loader" | "resolveExtensions" | "mainFields" | "conditions" | "allowOverwrite" | "tsconfig" | "outExtension" | "publicPath" | "inject" | "banner" | "footer" | "plugins" | "sourcemap" | "legalComments" | "sourceRoot" | "sourcesContent" | "format" | "globalName" | "target" | "supported" | "mangleProps" | "reserveProps" | "mangleQuoted" | "mangleCache" | "drop" | "dropLabels" | "minify" | "minifyWhitespace" | "minifyIdentifiers" | "minifySyntax" | "lineLimit" | "charset" | "treeShaking" | "ignoreAnnotations" | "jsx" | "jsxFactory" | "jsxFragment" | "jsxImportSource" | "jsxDev" | "jsxSideEffects" | "define" | "pure" | "keepNames" | "absPaths" | "color" | "logLevel" | "logLimit" | "logOverride" | "tsconfigRaw", any>>;
     basePath: string;
-    globPatterns: string[];
-    injectionPoint: string;
-    swSrc: string;
+    maximumFileSizeToCacheInBytes: number;
     globFollow: boolean;
     globIgnores: string[];
+    globPatterns: string[];
     globStrict: boolean;
-    disablePrecacheManifest: boolean;
-    maximumFileSizeToCacheInBytes: number;
-    globDirectory?: string | undefined;
-    templatedURLs?: Record<string, string | string[]> | undefined;
-    additionalPrecacheEntries?: (string | {
-        url: string;
-        integrity?: string | undefined;
-        revision?: string | null | undefined;
-    })[] | undefined;
+    injectionPoint: string;
+    swSrc: string;
+    additionalPrecacheEntries?: (string | import("@serwist/build").ManifestEntry)[] | undefined;
     dontCacheBustURLsMatching?: RegExp | undefined;
-    manifestTransforms?: z.z.core.$InferInnerFunctionTypeAsync<z.ZodTuple<[z.ZodArray<z.ZodObject<{
-        size: z.ZodNumber;
-        integrity: z.ZodOptional<z.ZodString>;
-        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        url: z.ZodString;
-    }, z.z.core.$strip>>, z.ZodOptional<z.ZodUnknown>], null>, z.ZodObject<{
-        manifest: z.ZodArray<z.ZodObject<{
-            size: z.ZodNumber;
-            integrity: z.ZodOptional<z.ZodString>;
-            revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            url: z.ZodString;
-        }, z.z.core.$strip>>;
-        warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.z.core.$strict>>[] | undefined;
+    manifestTransforms?: import("@serwist/build").ManifestTransform[] | undefined;
     modifyURLPrefix?: Record<string, string> | undefined;
+    templatedURLs?: Record<string, string | string[]> | undefined;
+    globDirectory?: string | undefined;
 }>>;
 //# sourceMappingURL=index.schema.d.ts.map

package/dist/index.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.schema.d.ts","sourceRoot":"","sources":["../src/index.schema.ts"],"names":[],"mappings":"AAEA,OAAO,CAAC,MAAM,KAAK,CAAC;AAGpB,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgB9B,CAAC"}
+{"version":3,"file":"index.schema.d.ts","sourceRoot":"","sources":["../src/index.schema.ts"],"names":[],"mappings":"AAEA,OAAO,CAAC,MAAM,KAAK,CAAC;AAIpB,eAAO,MAAM,YAAY;;;;oBAIvB,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgB9B,CAAC"}

package/dist/index.schema.js

@@ -1,20 +1,83 @@
 import path from 'node:path';
-import { injectPartial, globPartial, basePartial } from '@serwist/build/schema';
+import { injectPartial, globPartial, basePartial, assertType } from '@serwist/build/schema';
 import z from 'zod';
 
 const DEFAULT_GLOB_PATTERNS = [
     ".next/static/**/*.{js,css,html,ico,apng,png,avif,jpg,jpeg,jfif,pjpeg,pjp,gif,svg,webp,json,webmanifest}",
     "public/**/*"
 ];
+const SUPPORTED_ESBUILD_OPTIONS = [
+    "sourcemap",
+    "legalComments",
+    "sourceRoot",
+    "sourcesContent",
+    "format",
+    "globalName",
+    "target",
+    "supported",
+    "define",
+    "treeShaking",
+    "minify",
+    "mangleProps",
+    "reserveProps",
+    "mangleQuoted",
+    "mangleCache",
+    "drop",
+    "dropLabels",
+    "minifyWhitespace",
+    "minifyIdentifiers",
+    "minifySyntax",
+    "lineLimit",
+    "charset",
+    "ignoreAnnotations",
+    "jsx",
+    "jsxFactory",
+    "jsxFragment",
+    "jsxImportSource",
+    "jsxDev",
+    "jsxSideEffects",
+    "pure",
+    "keepNames",
+    "absPaths",
+    "color",
+    "logLevel",
+    "logLimit",
+    "logOverride",
+    "tsconfigRaw",
+    "bundle",
+    "splitting",
+    "preserveSymlinks",
+    "external",
+    "packages",
+    "alias",
+    "loader",
+    "resolveExtensions",
+    "mainFields",
+    "conditions",
+    "allowOverwrite",
+    "tsconfig",
+    "outExtension",
+    "publicPath",
+    "inject",
+    "banner",
+    "footer",
+    "plugins"
+];
 
+const turboPartial = z.strictObject({
+    cwd: z.string().prefault(process.cwd()),
+    basePath: z.string(),
+    esbuildOptions: z.partialRecord(z.literal(SUPPORTED_ESBUILD_OPTIONS), z.any()).prefault({})
+});
 const injectManifestOptions = z.strictObject({
     ...basePartial.shape,
     ...globPartial.shape,
     ...injectPartial.shape,
-    cwd: z.string().prefault(process.cwd()),
-    basePath: z.string(),
+    ...turboPartial.shape,
     globPatterns: z.array(z.string()).prefault(DEFAULT_GLOB_PATTERNS),
     globDirectory: z.string().optional()
+}).omit({
+    disablePrecacheManifest: true
 }).transform((input)=>{
     return {
         ...input,
@@ -22,5 +85,9 @@ const injectManifestOptions = z.strictObject({
         globDirectory: input.globDirectory ?? input.cwd
     };
 });
+assertType();
+assertType();
+assertType();
+assertType();
 
-export { injectManifestOptions };
+export { injectManifestOptions, turboPartial };

package/dist/lib/constants.d.ts

@@ -1,2 +1,3 @@
 export declare const DEFAULT_GLOB_PATTERNS: string[];
+export declare const SUPPORTED_ESBUILD_OPTIONS: readonly ["sourcemap", "legalComments", "sourceRoot", "sourcesContent", "format", "globalName", "target", "supported", "define", "treeShaking", "minify", "mangleProps", "reserveProps", "mangleQuoted", "mangleCache", "drop", "dropLabels", "minifyWhitespace", "minifyIdentifiers", "minifySyntax", "lineLimit", "charset", "ignoreAnnotations", "jsx", "jsxFactory", "jsxFragment", "jsxImportSource", "jsxDev", "jsxSideEffects", "pure", "keepNames", "absPaths", "color", "logLevel", "logLimit", "logOverride", "tsconfigRaw", "bundle", "splitting", "preserveSymlinks", "external", "packages", "alias", "loader", "resolveExtensions", "mainFields", "conditions", "allowOverwrite", "tsconfig", "outExtension", "publicPath", "inject", "banner", "footer", "plugins"];
 //# sourceMappingURL=constants.d.ts.map

package/dist/lib/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/lib/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB,UAGjC,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/lib/constants.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,qBAAqB,UAGjC,CAAC;AAEF,eAAO,MAAM,yBAAyB,ovBA0Dc,CAAC"}

package/dist/types.d.ts

@@ -1,5 +1,9 @@
 import type { BasePartial, BaseResolved, GlobPartial, GlobResolved, InjectPartial, InjectResolved, OptionalGlobDirectoryPartial, RequiredGlobDirectoryResolved } from "@serwist/build";
-import type { Prettify } from "@serwist/utils";
+import type { Prettify, Require } from "@serwist/utils";
+import type { BuildOptions } from "esbuild-wasm";
+import type { SUPPORTED_ESBUILD_OPTIONS } from "./lib/constants.js";
+export type EsbuildSupportedOptions = (typeof SUPPORTED_ESBUILD_OPTIONS)[number];
+export type EsbuildOptions = Pick<BuildOptions, EsbuildSupportedOptions>;
 export interface TurboPartial {
     /**
      * The path to your working directory.
@@ -12,8 +16,9 @@ export interface TurboPartial {
      * is not configured, set to `/`.
      */
     basePath: string;
+    esbuildOptions?: EsbuildOptions;
 }
-export type TurboResolved = Required<TurboPartial>;
-export type InjectManifestOptions = Prettify<BasePartial & GlobPartial & InjectPartial & OptionalGlobDirectoryPartial & TurboPartial>;
-export type InjectManifestOptionsComplete = Prettify<BaseResolved & GlobResolved & InjectResolved & RequiredGlobDirectoryResolved & TurboResolved>;
+export type TurboResolved = Require<TurboPartial, "cwd" | "esbuildOptions">;
+export type InjectManifestOptions = Prettify<Omit<BasePartial & GlobPartial & InjectPartial & OptionalGlobDirectoryPartial & TurboPartial, "disablePrecacheManifest">>;
+export type InjectManifestOptionsComplete = Prettify<Omit<BaseResolved & GlobResolved & InjectResolved & RequiredGlobDirectoryResolved & TurboResolved, "disablePrecacheManifest">>;
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EACX,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,aAAa,EACb,cAAc,EACd,4BAA4B,EAC5B,6BAA6B,EAC9B,MAAM,gBAAgB,CAAC;AAExB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAI/C,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC,YAAY,CAAC,CAAC;AAEnD,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC,WAAW,GAAG,WAAW,GAAG,aAAa,GAAG,4BAA4B,GAAG,YAAY,CAAC,CAAC;AAEtI,MAAM,MAAM,6BAA6B,GAAG,QAAQ,CAAC,YAAY,GAAG,YAAY,GAAG,cAAc,GAAG,6BAA6B,GAAG,aAAa,CAAC,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EACX,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,aAAa,EACb,cAAc,EACd,4BAA4B,EAC5B,6BAA6B,EAC9B,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAEpE,MAAM,MAAM,uBAAuB,GAAG,CAAC,OAAO,yBAAyB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjF,MAAM,MAAM,cAAc,GAAG,IAAI,CAAC,YAAY,EAAE,uBAAuB,CAAC,CAAC;AAEzE,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC;AAED,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,YAAY,EAAE,KAAK,GAAG,gBAAgB,CAAC,CAAC;AAE5E,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAC1C,IAAI,CAAC,WAAW,GAAG,WAAW,GAAG,aAAa,GAAG,4BAA4B,GAAG,YAAY,EAAE,yBAAyB,CAAC,CACzH,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG,QAAQ,CAClD,IAAI,CAAC,YAAY,GAAG,YAAY,GAAG,cAAc,GAAG,6BAA6B,GAAG,aAAa,EAAE,yBAAyB,CAAC,CAC9H,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serwist/turbopack",
-  "version": "10.0.0-preview.10",
+  "version": "10.0.0-preview.12",
   "type": "module",
   "sideEffects": false,
   "description": "A module that integrates Serwist into your Next.js / Turbopack application.",
@@ -67,9 +67,9 @@
     "esbuild-wasm": "0.25.8",
     "kolorist": "1.8.0",
     "zod": "4.0.5",
-    "@serwist/build": "10.0.0-preview.10",
-    "@serwist/window": "10.0.0-preview.10",
-    "serwist": "10.0.0-preview.10"
+    "@serwist/build": "10.0.0-preview.12",
+    "@serwist/window": "10.0.0-preview.12",
+    "serwist": "10.0.0-preview.12"
   },
   "devDependencies": {
     "@types/node": "24.0.14",
@@ -80,8 +80,8 @@
     "rollup": "4.45.1",
     "type-fest": "4.41.0",
     "typescript": "5.8.3",
-    "@serwist/configs": "10.0.0-preview.10",
-    "@serwist/utils": "10.0.0-preview.10"
+    "@serwist/configs": "10.0.0-preview.12",
+    "@serwist/utils": "10.0.0-preview.12"
   },
   "peerDependencies": {
     "next": ">=14.0.0",

package/src/index.react.tsx

@@ -21,7 +21,7 @@ export function SerwistProvider({ swUrl, register = true, reloadOnOnline = true,
   const [serwist] = useState(() => {
     if (typeof window === "undefined") return null;
     if (!(window.serwist && window.serwist instanceof Serwist) && "serviceWorker" in navigator) {
-      window.serwist = new Serwist(swUrl, { ...options, scope: options?.scope || "/" });
+      window.serwist = new Serwist(swUrl, { ...options, type: options?.type || "module", scope: options?.scope || "/" });
     }
     return window.serwist ?? null;
   });

package/src/index.schema.ts

@@ -1,18 +1,25 @@
 import path from "node:path";
-import { basePartial, globPartial, injectPartial } from "@serwist/build/schema";
+import { assertType, type Equals, basePartial, globPartial, injectPartial } from "@serwist/build/schema";
 import z from "zod";
-import { DEFAULT_GLOB_PATTERNS } from "./lib/constants.js";
+import { DEFAULT_GLOB_PATTERNS, SUPPORTED_ESBUILD_OPTIONS } from "./lib/constants.js";
+import type { InjectManifestOptions, InjectManifestOptionsComplete, TurboPartial, TurboResolved } from "./types.js";
+
+export const turboPartial = z.strictObject({
+  cwd: z.string().prefault(process.cwd()),
+  basePath: z.string(),
+  esbuildOptions: z.partialRecord(z.literal(SUPPORTED_ESBUILD_OPTIONS), z.any()).prefault({}),
+});
 
 export const injectManifestOptions = z
   .strictObject({
     ...basePartial.shape,
     ...globPartial.shape,
     ...injectPartial.shape,
-    cwd: z.string().prefault(process.cwd()),
-    basePath: z.string(),
+    ...turboPartial.shape,
     globPatterns: z.array(z.string()).prefault(DEFAULT_GLOB_PATTERNS),
     globDirectory: z.string().optional(),
   })
+  .omit({ disablePrecacheManifest: true })
   .transform((input) => {
     return {
       ...input,
@@ -20,3 +27,8 @@ export const injectManifestOptions = z
       globDirectory: input.globDirectory ?? input.cwd,
     };
   });
+
+assertType<Equals<TurboPartial, z.input<typeof turboPartial>>>();
+assertType<Equals<TurboResolved, z.output<typeof turboPartial>>>();
+assertType<Equals<InjectManifestOptions, z.input<typeof injectManifestOptions>>>();
+assertType<Equals<InjectManifestOptionsComplete, z.output<typeof injectManifestOptions>>>();

package/src/index.ts

@@ -1,3 +1,6 @@
+// Workaround for Next.js + Turbopack, while plugins are still
+// not supported. This relies on Next.js Route Handlers and file
+// name determinism.
 import path from "node:path";
 import { type BuildResult, getFileManifestEntries, rebasePath } from "@serwist/build";
 import { SerwistConfigError, validationErrorMap } from "@serwist/build/schema";
@@ -16,7 +19,7 @@ const logSerwistResult = (filePath: string, buildResult: Pick<BuildResult, "coun
   const hasWarnings = warnings && warnings.length > 0;
   // The route is reinitiated for each `path` param, so we only log results
   // if we're prerendering for sw.js.
-  if (filePath === "sw.js") {
+  if (filePath === "sw.js" && (hasWarnings || count > 0)) {
     logger[hasWarnings ? "warn" : "event"](
       `${cyan(count)} precache entries ${dim(`(${(size / 1024).toFixed(2)} KiB)`)}${
         hasWarnings ? `\n${yellow(["⚠ warnings", ...warnings.map((w) => `  ${w}`), ""].join("\n"))}` : ""
@@ -46,40 +49,45 @@ const contentTypeMap: Record<string, string> = {
 };
 
 /**
- * Creates a Route Handler that returns the precache manifest.
+ * Creates a Route Handler for Serwist files.
  * @param options Options for {@linkcode getFileManifestEntries}.
  */
 export const createSerwistRoute = (options: InjectManifestOptions) => {
-  const dynamic = "force-static",
-    dynamicParams = false,
-    revalidate = false;
+  const dynamic = "force-static" as const,
+    dynamicParams = false as const,
+    revalidate = false as const;
   const validation = validateGetManifestOptions(options).then((config) => {
-    // Make sure we leave swSrc out of the precache manifest.
-    config.globIgnores.push(
-      rebasePath({
-        file: config.swSrc,
-        baseDirectory: config.globDirectory,
-      }),
-    );
-    if (!config.manifestTransforms) {
-      config.manifestTransforms = [];
-    }
-    config.manifestTransforms.push((manifestEntries) => {
-      const manifest = manifestEntries.map((m) => {
-        // Replace all references to .next/ with "/_next/".
-        if (m.url.startsWith(".next/")) m.url = `/_next/${m.url.slice(6)}`;
-        // Replace all references to public/ with "$(basePath)/".
-        if (m.url.startsWith("public/")) m.url = path.posix.join(config.basePath, m.url.slice(7));
-        return m;
-      });
-      return { manifest, warnings: [] };
-    });
-    return config;
+    return {
+      ...config,
+      disablePrecacheManifest: isDev,
+      additionalPrecacheEntries: isDev ? [] : config.additionalPrecacheEntries,
+      globIgnores: [
+        ...config.globIgnores,
+        // Make sure we leave swSrc out of the precache manifest.
+        rebasePath({
+          file: config.swSrc,
+          baseDirectory: config.globDirectory,
+        }),
+      ],
+      manifestTransforms: [
+        ...(config.manifestTransforms ?? []),
+        (manifestEntries) => {
+          const manifest = manifestEntries.map((m) => {
+            // Replace all references to .next/ with "/_next/".
+            if (m.url.startsWith(".next/")) m.url = `/_next/${m.url.slice(6)}`;
+            // Replace all references to public/ with "$(basePath)/".
+            if (m.url.startsWith("public/")) m.url = path.posix.join(config.basePath, m.url.slice(7));
+            return m;
+          });
+          return { manifest, warnings: [] };
+        },
+      ],
+    };
   });
-  const generateStaticParams = () => {
-    return [{ path: "sw.js" }, { path: "sw.js.map" }];
-  };
   let map: Map<string, string> | null = null;
+  // NOTE: ALL FILES MUST HAVE DETERMINISTIC NAMES. THIS IS BECAUSE
+  // THE FOLLOWING MAP IS LOADED SEPARATELY FOR `generateStaticParams`
+  // AND EVERY `GET` REQUEST TO EACH OF THE FILES.
   const loadMap = async (filePath: string) => {
     const config = await validation;
     const { count, size, manifestEntries, warnings } = await getFileManifestEntries(config);
@@ -88,19 +96,27 @@ export const createSerwistRoute = (options: InjectManifestOptions) => {
     const manifestString = manifestEntries === undefined ? "undefined" : JSON.stringify(manifestEntries, null, 2);
     logSerwistResult(filePath, { count, size, warnings });
     const result = await (await esbuild).build({
-      entryPoints: [{ in: config.swSrc, out: "sw" }],
-      format: "esm",
       sourcemap: true,
+      format: "esm",
+      target: ["chrome64", "edge79", "firefox67", "opera51", "safari12"],
+      treeShaking: true,
+      minify: !isDev,
       bundle: true,
+      ...config.esbuildOptions,
+      platform: "browser",
+      define: {
+        ...config.esbuildOptions.define,
+        ...(injectionPoint ? { [injectionPoint]: manifestString } : {}),
+      },
+      outdir: config.cwd,
       write: false,
-      minify: !isDev,
-      define: injectionPoint
-        ? {
-            [injectionPoint]: manifestString,
-          }
-        : undefined,
-      outdir: process.cwd(),
       entryNames: "[name]",
+      // Asset and chunk names must be at the top, as our path is `/serwist/[path]`,
+      // not `/serwist/[...path]`, meaning that we can't resolve paths deeper
+      // than one level.
+      assetNames: "[name]-[hash]",
+      chunkNames: "[name]-[hash]",
+      entryPoints: [{ in: config.swSrc, out: "sw" }],
     });
     if (result.errors.length) {
       console.error("Failed to build the service worker.", result.errors);
@@ -111,11 +127,17 @@ export const createSerwistRoute = (options: InjectManifestOptions) => {
     }
     return new Map(result.outputFiles.map((e) => [e.path, e.text]));
   };
+  const generateStaticParams = async () => {
+    const config = await validation;
+    if (!map) map = await loadMap("root");
+    return [...map.keys().map((e) => ({ path: path.relative(config.cwd, e) }))];
+  };
   const GET = async (_: Request, { params }: { params: Promise<{ path: string }> }) => {
     // TODO: obviously, files get stale in development when we pull this off.
     const { path: filePath } = await params;
+    const config = await validation;
     if (!map) map = await loadMap(filePath);
-    return new NextResponse(map.get(path.join(process.cwd(), filePath)), {
+    return new NextResponse(map.get(path.join(config.cwd, filePath)), {
       headers: {
         "Content-Type": contentTypeMap[path.extname(filePath)] || "text/plain",
         "Service-Worker-Allowed": "/",

package/src/lib/constants.ts

@@ -1,4 +1,66 @@
+import type { BuildOptions } from "esbuild-wasm";
+
 export const DEFAULT_GLOB_PATTERNS = [
   ".next/static/**/*.{js,css,html,ico,apng,png,avif,jpg,jpeg,jfif,pjpeg,pjp,gif,svg,webp,json,webmanifest}",
   "public/**/*",
 ];
+
+export const SUPPORTED_ESBUILD_OPTIONS = [
+  // CommonOptions
+  "sourcemap",
+  "legalComments",
+  "sourceRoot",
+  "sourcesContent",
+  "format",
+  "globalName",
+  "target",
+  "supported",
+  "define",
+  "treeShaking",
+  "minify",
+  "mangleProps",
+  "reserveProps",
+  "mangleQuoted",
+  "mangleCache",
+  "drop",
+  "dropLabels",
+  "minifyWhitespace",
+  "minifyIdentifiers",
+  "minifySyntax",
+  "lineLimit",
+  "charset",
+  "ignoreAnnotations",
+  "jsx",
+  "jsxFactory",
+  "jsxFragment",
+  "jsxImportSource",
+  "jsxDev",
+  "jsxSideEffects",
+  "pure",
+  "keepNames",
+  "absPaths",
+  "color",
+  "logLevel",
+  "logLimit",
+  "logOverride",
+  "tsconfigRaw",
+  // BuildOptions
+  "bundle",
+  "splitting",
+  "preserveSymlinks",
+  "external",
+  "packages",
+  "alias",
+  "loader",
+  "resolveExtensions",
+  "mainFields",
+  "conditions",
+  "allowOverwrite",
+  "tsconfig",
+  "outExtension",
+  "publicPath",
+  "inject",
+  "banner",
+  "footer",
+  "plugins",
+] as const satisfies readonly (keyof BuildOptions)[];

package/src/types.ts

@@ -8,10 +8,13 @@ import type {
   OptionalGlobDirectoryPartial,
   RequiredGlobDirectoryResolved,
 } from "@serwist/build";
-import { assertType, type Equals } from "@serwist/build/schema";
-import type { Prettify } from "@serwist/utils";
-import type z from "zod";
-import type { injectManifestOptions } from "./index.schema.js";
+import type { Prettify, Require } from "@serwist/utils";
+import type { BuildOptions } from "esbuild-wasm";
+import type { SUPPORTED_ESBUILD_OPTIONS } from "./lib/constants.js";
+
+export type EsbuildSupportedOptions = (typeof SUPPORTED_ESBUILD_OPTIONS)[number];
+
+export type EsbuildOptions = Pick<BuildOptions, EsbuildSupportedOptions>;
 
 export interface TurboPartial {
   /**
@@ -25,13 +28,15 @@ export interface TurboPartial {
    * is not configured, set to `/`.
    */
   basePath: string;
+  esbuildOptions?: EsbuildOptions;
 }
 
-export type TurboResolved = Required<TurboPartial>;
-
-export type InjectManifestOptions = Prettify<BasePartial & GlobPartial & InjectPartial & OptionalGlobDirectoryPartial & TurboPartial>;
+export type TurboResolved = Require<TurboPartial, "cwd" | "esbuildOptions">;
 
-export type InjectManifestOptionsComplete = Prettify<BaseResolved & GlobResolved & InjectResolved & RequiredGlobDirectoryResolved & TurboResolved>;
+export type InjectManifestOptions = Prettify<
+  Omit<BasePartial & GlobPartial & InjectPartial & OptionalGlobDirectoryPartial & TurboPartial, "disablePrecacheManifest">
+>;
 
-assertType<Equals<InjectManifestOptions, z.input<typeof injectManifestOptions>>>();
-assertType<Equals<InjectManifestOptionsComplete, z.output<typeof injectManifestOptions>>>();
+export type InjectManifestOptionsComplete = Prettify<
+  Omit<BaseResolved & GlobResolved & InjectResolved & RequiredGlobDirectoryResolved & TurboResolved, "disablePrecacheManifest">
+>;