@serwist/build 10.0.0-preview.1 → 10.0.0-preview.10

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@serwist/build",
-  "version": "10.0.0-preview.1",
+  "version": "10.0.0-preview.10",
   "type": "module",
+  "sideEffects": false,
   "description": "A module that integrates into your build process, helping you generate a manifest of local files that should be precached.",
   "files": [
     "src",
@@ -17,7 +18,7 @@
     "file manifest"
   ],
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.0.0"
   },
   "author": "Google's Web DevRel Team",
   "contributors": [
@@ -48,20 +49,20 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "common-tags": "1.8.2",
-    "glob": "10.4.5",
-    "pretty-bytes": "6.1.1",
+    "glob": "11.0.3",
+    "pretty-bytes": "7.0.0",
     "source-map": "0.8.0-beta.0",
-    "zod": "3.24.2",
-    "@serwist/utils": "10.0.0-preview.1"
+    "zod": "4.0.5",
+    "@serwist/utils": "10.0.0-preview.10"
   },
   "devDependencies": {
     "@types/common-tags": "1.8.4",
-    "@types/node": "22.13.5",
-    "rollup": "4.34.8",
-    "type-fest": "4.35.0",
-    "typescript": "5.7.3",
-    "@serwist/configs": "10.0.0-preview.1"
+    "@types/node": "24.0.14",
+    "rollup": "4.45.1",
+    "type-fest": "4.41.0",
+    "typescript": "5.8.3",
+    "@serwist/utils": "10.0.0-preview.10",
+    "@serwist/configs": "10.0.0-preview.10"
   },
   "peerDependencies": {
     "typescript": ">=5.0.0"
@@ -75,6 +76,7 @@
     "build": "rimraf dist && NODE_OPTIONS='--max-old-space-size=4096' NODE_ENV=production rollup --config rollup.config.js",
     "dev": "rollup --config rollup.config.js --watch",
     "lint": "biome lint ./src",
+    "qcheck": "biome check ./src",
     "typecheck": "tsc"
   }
 }

package/src/index.schema.ts

@@ -1,16 +1,18 @@
-import { type Assignable, type Equals, assertType } from "./schema/assertType.js";
+import { type Assignable, assertType, type Equals } from "./schema/assert-type.js";
 import { basePartial } from "./schema/base.js";
-import { getManifestOptions } from "./schema/getManifest.js";
+import { SerwistConfigError, validationErrorMap } from "./schema/error.js";
+import { getManifestOptions } from "./schema/get-manifest.js";
 import { globPartial, optionalGlobDirectoryPartial, requiredGlobDirectoryPartial } from "./schema/glob.js";
-import { baseInjectPartial, injectManifestOptions } from "./schema/injectManifest.js";
-import { manifestEntry } from "./schema/manifestEntry.js";
-import { manifestTransform, manifestTransformResult } from "./schema/manifestTransform.js";
-import { SerwistConfigError } from "./schema/serwistConfigError.js";
-import { optionalSwDestPartial, requiredSwDestPartial } from "./schema/swDest.js";
-import { validationErrorMap } from "./schema/validationErrorMap.js";
+import { baseInjectPartial, injectManifestOptions } from "./schema/inject-manifest.js";
+import { manifestEntry } from "./schema/manifest-entry.js";
+import { manifestTransform, manifestTransformResult } from "./schema/manifest-transform.js";
+import { optionalSwDestPartial, requiredSwDestPartial } from "./schema/sw-dest.js";
+import { asyncFn, fn } from "./schema/utils.js";
 
 export {
   assertType,
+  fn,
+  asyncFn,
   basePartial,
   globPartial,
   baseInjectPartial as injectPartial,

package/src/index.ts

@@ -4,10 +4,12 @@
   Use of this source code is governed by an MIT-style
   license that can be found in the LICENSE file or at
   https://opensource.org/licenses/MIT.
-*/
+  */
+import { errors } from "@serwist/utils/node";
+
 import { getManifest } from "./get-manifest.js";
 import { injectManifest } from "./inject-manifest.js";
-import { errors } from "./lib/errors.js";
+import { DEFAULT_GLOB_PATTERNS } from "./lib/constants.js";
 import { escapeRegExp } from "./lib/escape-regexp.js";
 import { getFileManifestEntries } from "./lib/get-file-manifest-entries.js";
 import { getSourceMapURL } from "./lib/get-source-map-url.js";
@@ -17,16 +19,9 @@ import { transformManifest } from "./lib/transform-manifest.js";
 import { translateURLToSourcemapPaths } from "./lib/translate-url-to-sourcemap-paths.js";
 import { validateGetManifestOptions, validateInjectManifestOptions } from "./lib/validate-options.js";
 
-// TODO: remove in v10.
-/**
- * Use `JSON.stringify` instead.
- *
- * @deprecated
- */
-const stringify = JSON.stringify;
-
 export {
   errors,
+  DEFAULT_GLOB_PATTERNS,
   escapeRegExp,
   getFileManifestEntries,
   getManifest,
@@ -34,7 +29,6 @@ export {
   injectManifest,
   rebasePath,
   replaceAndUpdateSourceMap,
-  stringify,
   transformManifest,
   translateURLToSourcemapPaths,
   validateGetManifestOptions,

package/src/inject-manifest.ts

@@ -9,8 +9,9 @@ import assert from "node:assert";
 import fsp from "node:fs/promises";
 import path from "node:path";
 import { toUnix } from "@serwist/utils";
+import { errors } from "@serwist/utils/node";
 import type { RawSourceMap } from "source-map";
-import { errors } from "./lib/errors.js";
+
 import { escapeRegExp } from "./lib/escape-regexp.js";
 import { getFileManifestEntries } from "./lib/get-file-manifest-entries.js";
 import { getSourceMapURL } from "./lib/get-source-map-url.js";

package/src/lib/additional-precache-entries-transform.ts

@@ -5,9 +5,8 @@
   license that can be found in the LICENSE file or at
   https://opensource.org/licenses/MIT.
 */
-
+import { errors } from "@serwist/utils/node";
 import type { ManifestEntry } from "../types.js";
-import { errors } from "./errors.js";
 
 type AdditionalManifestEntriesTransform = (manifest: (ManifestEntry & { size: number })[]) => {
   manifest: (ManifestEntry & { size: number })[];

package/src/lib/constants.ts

@@ -0,0 +1 @@
+export const DEFAULT_GLOB_PATTERNS = ["**/*.{js,css,html,ico,apng,png,avif,jpg,jpeg,jfif,pjpeg,pjp,gif,svg,webp,json,webmanifest}"];

package/src/lib/get-file-details.ts

@@ -6,11 +6,10 @@
   https://opensource.org/licenses/MIT.
 */
 import path from "node:path";
+import type { FileDetails } from "@serwist/utils";
+import { errors, getFileHash, getFileSize } from "@serwist/utils/node";
 import { globSync } from "glob";
-import type { FileDetails, GlobPartial } from "../types.js";
-import { errors } from "./errors.js";
-import { getFileHash } from "./get-file-hash.js";
-import { getFileSize } from "./get-file-size.js";
+import type { GlobPartial } from "../types.js";
 
 export const getFileDetails = ({
   globDirectory,

package/src/lib/get-file-manifest-entries.ts

@@ -7,12 +7,11 @@
 */
 
 import assert from "node:assert";
+import type { FileDetails } from "@serwist/utils";
+import { errors, getCompositeDetails, getStringDetails } from "@serwist/utils/node";
 
-import type { FileDetails, GetManifestOptionsComplete, GetManifestResult } from "../types.js";
-import { errors } from "./errors.js";
-import { getCompositeDetails } from "./get-composite-details.js";
+import type { GetManifestOptionsComplete, GetManifestResult } from "../types.js";
 import { getFileDetails } from "./get-file-details.js";
-import { getStringDetails } from "./get-string-details.js";
 import { transformManifest } from "./transform-manifest.js";
 
 export const getFileManifestEntries = async ({

package/src/lib/modify-url-prefix-transform.ts

@@ -5,9 +5,9 @@
   license that can be found in the LICENSE file or at
   https://opensource.org/licenses/MIT.
 */
+import { errors } from "@serwist/utils/node";
 
 import type { ManifestTransform } from "../types.js";
-import { errors } from "./errors.js";
 import { escapeRegExp } from "./escape-regexp.js";
 
 export function modifyURLPrefixTransform(modifyURLPrefix: { [key: string]: string }): ManifestTransform {

package/src/lib/no-revision-for-urls-matching-transform.ts

@@ -5,9 +5,9 @@
   license that can be found in the LICENSE file or at
   https://opensource.org/licenses/MIT.
 */
+import { errors } from "@serwist/utils/node";
 
 import type { ManifestTransform } from "../types.js";
-import { errors } from "./errors.js";
 
 export function noRevisionForURLsMatchingTransform(regexp: RegExp): ManifestTransform {
   if (!(regexp instanceof RegExp)) {

package/src/lib/rebase-path.ts

@@ -6,8 +6,8 @@
   https://opensource.org/licenses/MIT.
 */
 
-import { toUnix } from "@serwist/utils";
 import path from "node:path";
+import { toUnix } from "@serwist/utils";
 
 export function rebasePath({ baseDirectory, file }: { baseDirectory: string; file: string }): string {
   // The initial path is relative to the current directory, so make it absolute.

package/src/lib/transform-manifest.ts

@@ -5,10 +5,11 @@
   license that can be found in the LICENSE file or at
   https://opensource.org/licenses/MIT.
 */
+import type { FileDetails } from "@serwist/utils";
+import { errors } from "@serwist/utils/node";
 
-import type { BaseResolved, FileDetails, ManifestEntry, ManifestTransform } from "../types.js";
+import type { BaseResolved, ManifestEntry, ManifestTransform } from "../types.js";
 import { additionalPrecacheEntriesTransform } from "./additional-precache-entries-transform.js";
-import { errors } from "./errors.js";
 import { maximumSizeTransform } from "./maximum-size-transform.js";
 import { modifyURLPrefixTransform } from "./modify-url-prefix-transform.js";
 import { noRevisionForURLsMatchingTransform } from "./no-revision-for-urls-matching-transform.js";
@@ -155,7 +156,6 @@ export async function transformManifest({
   let size = 0;
   for (const manifestEntry of transformedManifest as (ManifestEntry & { size?: number })[]) {
     size += manifestEntry.size || 0;
-    // biome-ignore lint/performance/noDelete: These values are no longer necessary.
     delete manifestEntry.size;
   }
 

package/src/lib/translate-url-to-sourcemap-paths.ts

@@ -8,7 +8,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { toUnix } from "@serwist/utils";
-import { errors } from "./errors.js";
+import { errors } from "@serwist/utils/node";
 
 export function translateURLToSourcemapPaths(
   url: string | null,
@@ -19,9 +19,9 @@ export function translateURLToSourcemapPaths(
   srcPath: string | undefined;
   warning: string | undefined;
 } {
-  let destPath: string | undefined = undefined;
-  let srcPath: string | undefined = undefined;
-  let warning: string | undefined = undefined;
+  let destPath: string | undefined;
+  let srcPath: string | undefined;
+  let warning: string | undefined;
 
   if (url && !url.startsWith("data:")) {
     const possibleSrcPath = path.resolve(path.dirname(swSrc), url);

package/src/lib/validate-options.ts

@@ -1,4 +1,4 @@
-import { SerwistConfigError } from "../schema/serwistConfigError.js";
+import { z } from "zod";
 /*
   Copyright 2021 Google LLC
 
@@ -6,21 +6,27 @@ import { SerwistConfigError } from "../schema/serwistConfigError.js";
   license that can be found in the LICENSE file or at
   https://opensource.org/licenses/MIT.
 */
-import { validationErrorMap } from "../schema/validationErrorMap.js";
+import { SerwistConfigError, validationErrorMap } from "../schema/error.js";
 import type { GetManifestOptionsComplete, InjectManifestOptionsComplete } from "../types.js";
 
 export const validateGetManifestOptions = async (input: unknown): Promise<GetManifestOptionsComplete> => {
-  const result = await (await import("../schema/getManifest.js")).getManifestOptions.spa(input, { errorMap: validationErrorMap });
+  const result = await (await import("../schema/get-manifest.js")).getManifestOptions.spa(input, { error: validationErrorMap });
   if (!result.success) {
-    throw new SerwistConfigError({ moduleName: "@serwist/build", message: JSON.stringify(result.error.format(), null, 2) });
+    throw new SerwistConfigError({
+      moduleName: "@serwist/build",
+      message: z.prettifyError(result.error),
+    });
   }
   return result.data;
 };
 
 export const validateInjectManifestOptions = async (input: unknown): Promise<InjectManifestOptionsComplete> => {
-  const result = await (await import("../schema/injectManifest.js")).injectManifestOptions.spa(input, { errorMap: validationErrorMap });
+  const result = await (await import("../schema/inject-manifest.js")).injectManifestOptions.spa(input, { error: validationErrorMap });
   if (!result.success) {
-    throw new SerwistConfigError({ moduleName: "@serwist/build", message: JSON.stringify(result.error.format(), null, 2) });
+    throw new SerwistConfigError({
+      moduleName: "@serwist/build",
+      message: z.prettifyError(result.error),
+    });
   }
   return result.data;
 };

package/src/schema/base.ts

@@ -1,20 +1,18 @@
 import { z } from "zod";
 
 import type { BasePartial, BaseResolved } from "../types.js";
-import { type Equals, assertType } from "./assertType.js";
-import { manifestEntry } from "./manifestEntry.js";
-import { manifestTransform } from "./manifestTransform.js";
+import { assertType, type Equals } from "./assert-type.js";
+import { manifestEntry } from "./manifest-entry.js";
+import { manifestTransform } from "./manifest-transform.js";
 
-export const basePartial = z
-  .object({
-    additionalPrecacheEntries: z.array(z.union([z.string(), manifestEntry])).optional(),
-    disablePrecacheManifest: z.boolean().default(false),
-    dontCacheBustURLsMatching: z.instanceof(RegExp).optional(),
-    manifestTransforms: z.array(manifestTransform).optional(),
-    maximumFileSizeToCacheInBytes: z.number().default(2097152),
-    modifyURLPrefix: z.record(z.string(), z.string()).optional(),
-  })
-  .strict("Do not pass invalid properties to BasePartial!");
+export const basePartial = z.strictObject({
+  additionalPrecacheEntries: z.array(z.union([z.string(), manifestEntry])).optional(),
+  disablePrecacheManifest: z.boolean().default(false),
+  dontCacheBustURLsMatching: z.instanceof(RegExp).optional(),
+  manifestTransforms: z.array(manifestTransform).optional(),
+  maximumFileSizeToCacheInBytes: z.number().default(2097152),
+  modifyURLPrefix: z.record(z.string(), z.string()).optional(),
+});
 
 assertType<Equals<BasePartial, z.input<typeof basePartial>>>();
 assertType<Equals<BaseResolved, z.output<typeof basePartial>>>();

package/src/schema/error.ts

@@ -0,0 +1,53 @@
+import type { z } from "zod";
+
+export class SerwistConfigError extends Error {
+  constructor({ moduleName, message }: { moduleName?: string; message?: string }) {
+    super(`Invalid ${moduleName ?? "Serwist"} configuration:\n${message}`);
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+const parsedType = (data: any): string => {
+  const t = typeof data;
+
+  switch (t) {
+    case "number": {
+      return Number.isNaN(data) ? "NaN" : "number";
+    }
+    case "object": {
+      if (Array.isArray(data)) {
+        return "array";
+      }
+      if (data === null) {
+        return "null";
+      }
+
+      if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
+        return data.constructor.name;
+      }
+    }
+  }
+  return t;
+};
+
+export const validationErrorMap: z.core.$ZodErrorMap = (error) => {
+  /* This is where you override the various error codes */
+  switch (error.code) {
+    case "invalid_type": {
+      return `${error.message ?? "Received invalid type"}: expected ${error.expected}, received ${parsedType(error.input)}.`;
+    }
+    case "invalid_value": {
+      return `${error.message ?? "Received invalid value"}: expected ${error.expected}, received ${parsedType(error.input)}.`;
+    }
+    case "invalid_union": {
+      return `${error.message ?? "Received invalid union"}:\n${error.errors.flatMap((err) => err.map((e) => `  → ${e.message}`)).join("\n")}`;
+    }
+    case "unrecognized_keys": {
+      return `${error.message ?? "Received unrecognized keys"}: ${error.keys.join(".")}`;
+    }
+    case "custom": {
+      return error.message ?? undefined;
+    }
+  }
+  return undefined;
+};

package/src/schema/{getManifest.ts → get-manifest.ts}

@@ -1,13 +1,14 @@
-import type { z } from "zod";
+import { z } from "zod";
 import type { GetManifestOptions, GetManifestOptionsComplete } from "../types.js";
-import { type Equals, assertType } from "./assertType.js";
+import { assertType, type Equals } from "./assert-type.js";
 import { basePartial } from "./base.js";
 import { globPartial, requiredGlobDirectoryPartial } from "./glob.js";
 
-export const getManifestOptions = basePartial
-  .merge(globPartial)
-  .merge(requiredGlobDirectoryPartial)
-  .strict("Do not pass invalid properties to GetManifestOptions!");
+export const getManifestOptions = z.strictObject({
+  ...basePartial.shape,
+  ...globPartial.shape,
+  ...requiredGlobDirectoryPartial.shape,
+});
 
 assertType<Equals<GetManifestOptions, z.input<typeof getManifestOptions>>>();
 assertType<Equals<GetManifestOptionsComplete, z.output<typeof getManifestOptions>>>();

package/src/schema/glob.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { DEFAULT_GLOB_PATTERNS } from "../lib/constants.js";
 import type {
   GlobPartial,
   GlobResolved,
@@ -7,31 +8,25 @@ import type {
   RequiredGlobDirectoryPartial,
   RequiredGlobDirectoryResolved,
 } from "../types.js";
-import { type Equals, assertType } from "./assertType.js";
+import { assertType, type Equals } from "./assert-type.js";
 
-export const globPartial = z
-  .object({
-    globFollow: z.boolean().default(true),
-    globIgnores: z.array(z.string()).default(["**/node_modules/**/*"]),
-    globPatterns: z.array(z.string()).default(["**/*.{js,css,html}"]),
-    globStrict: z.boolean().default(true),
-    templatedURLs: z.record(z.string(), z.union([z.string(), z.array(z.string())])).optional(),
-  })
-  .strict("Do not pass invalid properties to GlobPartial!");
+export const globPartial = z.strictObject({
+  globFollow: z.boolean().default(true),
+  globIgnores: z.array(z.string()).default(["**/node_modules/**/*"]),
+  globPatterns: z.array(z.string()).default(DEFAULT_GLOB_PATTERNS),
+  globStrict: z.boolean().default(true),
+  templatedURLs: z.record(z.string(), z.union([z.string(), z.array(z.string())])).optional(),
+});
 
-export const optionalGlobDirectoryPartial = z
-  .object({
-    globDirectory: z.string().optional(),
-  })
-  .strict("Do not pass invalid properties to OptionalGlobDirectoryPartial!");
+export const optionalGlobDirectoryPartial = z.strictObject({
+  globDirectory: z.string().optional(),
+});
 
 // This needs to be set when using GetManifest or InjectManifest. This is
 // enforced via runtime validation, and needs to be documented.
-export const requiredGlobDirectoryPartial = z
-  .object({
-    globDirectory: z.string(),
-  })
-  .strict("Do not pass invalid properties to RequiredGlobDirectoryPartial!");
+export const requiredGlobDirectoryPartial = z.strictObject({
+  globDirectory: z.string(),
+});
 
 assertType<Equals<GlobPartial, z.input<typeof globPartial>>>();
 assertType<Equals<GlobResolved, z.output<typeof globPartial>>>();

package/src/schema/inject-manifest.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import type { InjectManifestOptions, InjectManifestOptionsComplete, InjectPartial, InjectResolved } from "../types.js";
+import { assertType, type Equals } from "./assert-type.js";
+import { basePartial } from "./base.js";
+import { globPartial, requiredGlobDirectoryPartial } from "./glob.js";
+import { requiredSwDestPartial } from "./sw-dest.js";
+
+export const baseInjectPartial = z.strictObject({
+  injectionPoint: z.string().prefault("self.__SW_MANIFEST"),
+  swSrc: z.string(),
+});
+
+export const injectManifestOptions = z.strictObject({
+  ...basePartial.shape,
+  ...globPartial.shape,
+  ...baseInjectPartial.shape,
+  ...requiredSwDestPartial.shape,
+  ...requiredGlobDirectoryPartial.shape,
+});
+
+assertType<Equals<InjectPartial, z.input<typeof baseInjectPartial>>>();
+assertType<Equals<InjectResolved, z.output<typeof baseInjectPartial>>>();
+assertType<Equals<InjectManifestOptions, z.input<typeof injectManifestOptions>>>();
+assertType<Equals<InjectManifestOptionsComplete, z.output<typeof injectManifestOptions>>>();

package/src/schema/manifest-entry.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+
+export const manifestEntry = z.strictObject({
+  integrity: z.string().optional(),
+  revision: z.string().nullable().optional(),
+  url: z.string(),
+});

package/src/schema/manifest-transform.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+import { manifestEntry } from "./manifest-entry.js";
+import { asyncFn } from "./utils.js";
+
+const sizeObject = z.object({ size: z.number() });
+
+const manifestEntryWithSize = z.object({ ...manifestEntry.shape, ...sizeObject.shape });
+
+export const manifestTransformResult = z.strictObject({
+  manifest: z.array(manifestEntryWithSize),
+  warnings: z.array(z.string()).optional(),
+});
+
+export const manifestTransform = asyncFn({
+  input: [z.array(manifestEntryWithSize), z.unknown().optional()],
+  output: manifestTransformResult,
+});

package/src/schema/{swDest.ts → sw-dest.ts}

@@ -1,18 +1,14 @@
 import { z } from "zod";
 import type { OptionalSwDestPartial, OptionalSwDestResolved, RequiredSwDestPartial, RequiredSwDestResolved } from "../types.js";
-import { type Equals, assertType } from "./assertType.js";
+import { assertType, type Equals } from "./assert-type.js";
 
-export const optionalSwDestPartial = z
-  .object({
-    swDest: z.string().optional(),
-  })
-  .strict("Do not pass invalid properties to OptionalSwDest!");
+export const optionalSwDestPartial = z.strictObject({
+  swDest: z.string().optional(),
+});
 
-export const requiredSwDestPartial = z
-  .object({
-    swDest: z.string(),
-  })
-  .strict("Do not pass invalid properties to RequiredSwDest!");
+export const requiredSwDestPartial = z.strictObject({
+  swDest: z.string(),
+});
 
 assertType<Equals<OptionalSwDestPartial, z.input<typeof optionalSwDestPartial>>>();
 assertType<Equals<OptionalSwDestResolved, z.output<typeof optionalSwDestPartial>>>();

package/src/schema/utils.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+
+export const fn = <TInput extends [z.ZodType, ...z.ZodType[]], TOutput extends z.ZodType>({ input, output }: { input: TInput; output: TOutput }) => {
+  const schema = z.function({
+    input: z.tuple(input),
+    output,
+  });
+  return z
+    .custom<z.core.$InferInnerFunctionType<z.ZodTuple<TInput, null>, TOutput>>((arg) => typeof arg === "function")
+    .transform((arg) => schema.implement(arg));
+};
+
+export const asyncFn = <TInput extends [z.ZodType, ...z.ZodType[]], TOutput extends z.ZodType>({
+  input,
+  output,
+}: {
+  input: TInput;
+  output: TOutput;
+}) => {
+  const schema = z.function({
+    input: z.tuple(input),
+    output,
+  });
+  return z
+    .custom<z.core.$InferInnerFunctionTypeAsync<z.ZodTuple<TInput, null>, TOutput>>((arg) => typeof arg === "function")
+    .transform((arg) => schema.implementAsync(arg));
+};

package/src/types.ts

@@ -1,14 +1,20 @@
-import type { Require, Prettify } from "@serwist/utils";
+import type { MaybePromise, Prettify, Require } from "@serwist/utils";
 import type { PackageJson } from "type-fest";
 import type { z } from "zod";
-import type { manifestEntry } from "./schema/manifestEntry.js";
-import type { manifestTransform, manifestTransformResult } from "./schema/manifestTransform.js";
+import type { manifestEntry } from "./schema/manifest-entry.js";
+import type { manifestTransformResult } from "./schema/manifest-transform.js";
 
 export type ManifestEntry = z.input<typeof manifestEntry>;
 
 export type ManifestTransformResult = z.input<typeof manifestTransformResult>;
 
-export type ManifestTransform = z.input<typeof manifestTransform>;
+export type ManifestTransform = (
+  entries: (ManifestEntry & { size: number })[],
+  params?: unknown,
+) => MaybePromise<{
+  manifest: (ManifestEntry & { size: number })[];
+  warnings?: string[] | undefined;
+}>;
 
 export interface BasePartial {
   /**
@@ -116,7 +122,7 @@ export interface GlobPartial {
    * [`node-glob`'s Glob Primer](https://github.com/isaacs/node-glob#glob-primer).
    * @default
    * ```
-   * ["**\/*.{js,css,html}"]
+   * ["**\/*.{js,css,html,ico,apng,png,avif,jpg,jpeg,jfif,pjpeg,pjp,gif,svg,webp,json,webmanifest}"]
    * ```
    */
   globPatterns?: string[];
@@ -202,15 +208,6 @@ export type BuildResult = Omit<GetManifestResult, "manifestEntries"> & {
   filePaths: string[];
 };
 
-/**
- * @private
- */
-export interface FileDetails {
-  file: string;
-  hash: string | null;
-  size: number;
-}
-
 /**
  * @private
  */

package/dist/chunks/getManifest.js

@@ -1,6 +0,0 @@
-import { b as basePartial, g as globPartial, r as requiredGlobDirectoryPartial } from './glob.js';
-import 'zod';
-
-const getManifestOptions = basePartial.merge(globPartial).merge(requiredGlobDirectoryPartial).strict("Do not pass invalid properties to GetManifestOptions!");
-
-export { getManifestOptions };