tiny-essentials 1.28.19 → 1.29.0

package/dist/v1/webTemplates/multiformats/14.0/IPFSHasher/index.cjs

@@ -0,0 +1,83 @@
+'use strict';
+
+var cid = require('../../../../../node_modules/multiformats/dist/src/cid.cjs');
+var sha2 = require('../../../../../node_modules/multiformats/dist/src/hashes/sha2.cjs');
+
+/**
+ * Multicodec code for the dag-pb format.
+ * @type {number}
+ */
+const CODEC_DAG_PB = 0x70;
+
+/**
+ * Multicodec code for raw binary data.
+ * @type {number}
+ */
+const CODEC_RAW = 0x55;
+
+/**
+ * @typedef {Object} CIDGenerationResult
+ * @property {string} cidString - The string representation of the CID.
+ * @property {'v0' | 'v1'} version - The CID version that was generated.
+ * @property {'sha256'} hashAlgorithm - The algorithm used for hashing.
+ * @property {number} codec - The multicodec code of the content.
+ */
+
+/**
+ * A utility class to generate IPFS Content Identifiers (CIDs) locally.
+ */
+class IPFSHasher {
+  /** @type {'v0' | 'v1'} */
+  #version;
+
+  /**
+   * @param {'v0' | 'v1'} [version='v1'] - The CID version to generate.
+   * @throws {TypeError} If the version is not 'v0' or 'v1'.
+   */
+  constructor(version = 'v1') {
+    if (version !== 'v0' && version !== 'v1') {
+      throw new TypeError('Invalid CID version. Use "v0" or "v1".');
+    }
+    this.#version = version;
+  }
+
+  /**
+   * Generates a CID from the provided data.
+   *
+   * @param {Uint8Array} data - The raw data to be hashed.
+   * @returns {Promise<CIDGenerationResult>} A promise resolving to the CID result.
+   * @throws {TypeError} If the input data is not a Uint8Array.
+   */
+  async generate(data) {
+    if (!(data instanceof Uint8Array)) {
+      throw new TypeError(`Expected Uint8Array, but received ${typeof data}.`);
+    }
+
+    // sha256.digest is asynchronous and must be awaited.
+    const hash = await sha2.sha256.digest(data);
+
+    /** @type {CID} */
+    let cid$1;
+    /** @type {number} */
+    let codec;
+
+    if (this.#version === 'v0') {
+      // CIDv0 is locked to dag-pb + sha256. The codec is implicit.
+      codec = CODEC_DAG_PB;
+      cid$1 = cid.CID.createV0(hash);
+    } else {
+      // CIDv1 is explicit: we choose the raw codec for file bytes.
+      codec = CODEC_RAW;
+      cid$1 = cid.CID.create(1, codec, hash);
+    }
+
+    return {
+      cidString: cid$1.toString(),
+      version: this.#version,
+      hashAlgorithm: 'sha256',
+      codec,
+    };
+  }
+}
+
+module.exports = IPFSHasher;

package/dist/v1/webTemplates/multiformats/14.0/IPFSHasher/index.d.mts

@@ -0,0 +1,46 @@
+export type CIDGenerationResult = {
+    /**
+     * - The string representation of the CID.
+     */
+    cidString: string;
+    /**
+     * - The CID version that was generated.
+     */
+    version: 'v0' | 'v1';
+    /**
+     * - The algorithm used for hashing.
+     */
+    hashAlgorithm: 'sha256';
+    /**
+     * - The multicodec code of the content.
+     */
+    codec: number;
+};
+/**
+ * @typedef {Object} CIDGenerationResult
+ * @property {string} cidString - The string representation of the CID.
+ * @property {'v0' | 'v1'} version - The CID version that was generated.
+ * @property {'sha256'} hashAlgorithm - The algorithm used for hashing.
+ * @property {number} codec - The multicodec code of the content.
+ */
+/**
+ * A utility class to generate IPFS Content Identifiers (CIDs) locally.
+ */
+declare class IPFSHasher {
+    #private;
+    /**
+     * @param {'v0' | 'v1'} [version='v1'] - The CID version to generate.
+     * @throws {TypeError} If the version is not 'v0' or 'v1'.
+     */
+    constructor(version?: 'v0' | 'v1');
+    /**
+     * Generates a CID from the provided data.
+     *
+     * @param {Uint8Array} data - The raw data to be hashed.
+     * @returns {Promise<CIDGenerationResult>} A promise resolving to the CID result.
+     * @throws {TypeError} If the input data is not a Uint8Array.
+     */
+    generate(data: Uint8Array): Promise<CIDGenerationResult>;
+}
+export default IPFSHasher;
+//# sourceMappingURL=index.d.mts.map

package/dist/v1/webTemplates/multiformats/14.0/IPFSHasher/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../../../../src/v1/webTemplates/multiformats/14.0/IPFSHasher/index.mjs"],"names":[],"mappings":"AAgBG,YAAkB,mBAAmB,GACrC;;;;IAAmB,SAAS,EAAjB,MAAM,CACjB;;;;IAAwB,OAAO,EAApB,IAAI,GAAG,IAAI,CACtB;;;;IAAqB,aAAa,EAAvB,QAAQ,CACnB;;;;IAAmB,KAAK,EAAb,MAAM,CACnB;CAAA,CAAA;AAND;;;;;;GAMG;AAEH;;GAEG;AACH,cAAM,UAAU;;IAId;;;OAGG;IACH,YAAY,OAAO,AAHhB,CACA,EADQ,IAAI,GAAG,IAGQ,EAKzB;IAED;;;;;;OAMG;IACG,QAAQ,CAAC,IAAI,EAJR,UAIQ,GAHN,OAAO,CAAC,mBAAmB,CAAC,CAgCxC;CACF;eAEc,UAAU"}

package/dist/v1/webTemplates/multiformats/14.0/IPFSHasher/index.mjs

@@ -0,0 +1,71 @@
+import { CID } from 'multiformats/cid';
+import { sha256 } from 'multiformats/hashes/sha2';
+/**
+ * Multicodec code for the dag-pb format.
+ * @type {number}
+ */
+const CODEC_DAG_PB = 0x70;
+/**
+ * Multicodec code for raw binary data.
+ * @type {number}
+ */
+const CODEC_RAW = 0x55;
+/**
+ * @typedef {Object} CIDGenerationResult
+ * @property {string} cidString - The string representation of the CID.
+ * @property {'v0' | 'v1'} version - The CID version that was generated.
+ * @property {'sha256'} hashAlgorithm - The algorithm used for hashing.
+ * @property {number} codec - The multicodec code of the content.
+ */
+/**
+ * A utility class to generate IPFS Content Identifiers (CIDs) locally.
+ */
+class IPFSHasher {
+    /** @type {'v0' | 'v1'} */
+    #version;
+    /**
+     * @param {'v0' | 'v1'} [version='v1'] - The CID version to generate.
+     * @throws {TypeError} If the version is not 'v0' or 'v1'.
+     */
+    constructor(version = 'v1') {
+        if (version !== 'v0' && version !== 'v1') {
+            throw new TypeError('Invalid CID version. Use "v0" or "v1".');
+        }
+        this.#version = version;
+    }
+    /**
+     * Generates a CID from the provided data.
+     *
+     * @param {Uint8Array} data - The raw data to be hashed.
+     * @returns {Promise<CIDGenerationResult>} A promise resolving to the CID result.
+     * @throws {TypeError} If the input data is not a Uint8Array.
+     */
+    async generate(data) {
+        if (!(data instanceof Uint8Array)) {
+            throw new TypeError(`Expected Uint8Array, but received ${typeof data}.`);
+        }
+        // sha256.digest is asynchronous and must be awaited.
+        const hash = await sha256.digest(data);
+        /** @type {CID} */
+        let cid;
+        /** @type {number} */
+        let codec;
+        if (this.#version === 'v0') {
+            // CIDv0 is locked to dag-pb + sha256. The codec is implicit.
+            codec = CODEC_DAG_PB;
+            cid = CID.createV0(hash);
+        }
+        else {
+            // CIDv1 is explicit: we choose the raw codec for file bytes.
+            codec = CODEC_RAW;
+            cid = CID.create(1, codec, hash);
+        }
+        return {
+            cidString: cid.toString(),
+            version: this.#version,
+            hashAlgorithm: 'sha256',
+            codec,
+        };
+    }
+}
+export default IPFSHasher;

package/dist/v1/webTemplates/vite/7.3/plugins/TinyVitePwaPlugin.cjs

@@ -0,0 +1,493 @@
+'use strict';
+
+var path = require('path');
+var vite = require('vite');
+
+/**
+ * @typedef {Object} TinyWebWorkerConfig
+ * @property {string} entry - The source file path for the Web Worker (e.g., 'src/workers/myWorker.mjs').
+ * @property {string} filename - The output filename for the Web Worker (e.g., 'myWorker.js').
+ */
+
+/**
+ * @typedef {Object} TinyVitePwaOptions
+ * @property {Record<any, any>} manifest - The Web App Manifest object.
+ * @property {string} manifestPath - The URL path where the manifest should be served.
+ * @property {string} srcDir - The source directory containing the Service Worker.
+ * @property {string} filename - The name of the Service Worker file.
+ * @property {boolean} [injectRegister=true] - Optional. Whether to automatically inject the SW registration script into the HTML <head>.
+ * @property {boolean} [injectManifestToGlobal=true] - Optional. Whether to inject the manifest into the global scope via Vite's `define`.
+ * @property {RegistrationOptions} [swRegistrationOptions] - Optional. Registration options for the Service Worker.
+ * @property {TinyWebWorkerConfig[]} [webWorkers] - Optional. A list of Web Workers to be bundled and served alongside the PWA.
+ */
+
+// ANSI Color Codes
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+};
+
+/**
+ * Internal logger to maintain consistent plugin output formatting using ANSI colors.
+ */
+const logger = {
+  prefix: `${colors.cyan}[tiny-vite-pwa]${colors.reset}`,
+  info: (/** @type {string} */ msg) =>
+    console.log(`${logger.prefix} ${colors.blue}[INFO]${colors.reset} ${msg}`),
+  success: (/** @type {string} */ msg) =>
+    console.log(`${logger.prefix} ${colors.green}[SUCCESS]${colors.reset} ${msg}${colors.reset}`),
+  warn: (/** @type {string} */ msg) =>
+    console.warn(`${logger.prefix} ${colors.yellow}[WARN]${colors.reset} ${msg}${colors.reset}`),
+  error: (/** @type {string} */ msg, /** @type {Error} */ err) =>
+    console.error(
+      `${logger.prefix} ${colors.red}[ERROR]${colors.reset} ${msg}${colors.reset}`,
+      err || '',
+    ),
+  log: (/** @type {string} */ msg) => console.log(msg),
+  dim: (/** @type {string} */ msg) => console.log(`${colors.dim}${msg}${colors.reset}`),
+};
+
+/**
+ * Custom PWA Plugin.
+ * Resolves Manifest, Dev HMR, Service Worker, and multiple Web Workers bundling.
+ *
+ * NOTE: The Service Worker and Web Worker files are always served from the root directory of the website.
+ *
+ * TypeScript Support: To enable IntelliSense and avoid type errors when using
+ * the injected '__TINY_PWA_MANIFEST__' global variable, add the following to your `env.d.ts` file:
+ *
+ * ```typescript
+ * declare global {
+ *   interface Window {
+ *     __TINY_PWA_MANIFEST__: Record<string, any>;
+ *   }
+ * }
+ * ```
+ *
+ * @param {TinyVitePwaOptions} options - The configuration options for the plugin.
+ * @returns {import('vite').Plugin} The Vite plugin object.
+ */
+const TinyVitePwaPlugin = (options) => {
+  // --- Strict Runtime Validation ---
+  if (typeof options !== 'object' || options === null) {
+    throw new TypeError('The "options" argument must be a non-null object.');
+  }
+
+  if (typeof options.manifest !== 'object' || options.manifest === null) {
+    throw new TypeError('The "manifest" property must be an object.');
+  }
+
+  if (typeof options.manifestPath !== 'string') {
+    throw new TypeError('The "manifestPath" property must be a string.');
+  }
+
+  if (typeof options.srcDir !== 'string') {
+    throw new TypeError('The "srcDir" property must be a string.');
+  }
+
+  if (typeof options.filename !== 'string') {
+    throw new TypeError('The "filename" property must be a string.');
+  }
+
+  if (options.injectRegister !== undefined && typeof options.injectRegister !== 'boolean') {
+    throw new TypeError('The "injectRegister" property must be a boolean.');
+  }
+
+  if (
+    options.injectManifestToGlobal !== undefined &&
+    typeof options.injectManifestToGlobal !== 'boolean'
+  ) {
+    throw new TypeError('The "injectManifestToGlobal" property must be a boolean.');
+  }
+
+  if (
+    options.swRegistrationOptions !== undefined &&
+    (typeof options.swRegistrationOptions !== 'object' ||
+      options.swRegistrationOptions === null ||
+      Array.isArray(options.swRegistrationOptions))
+  ) {
+    throw new TypeError('The "swRegistrationOptions" property must be an object.');
+  }
+
+  const filenamePattern = /^[a-zA-Z0-9._-]+$/;
+  if (!filenamePattern.test(options.filename)) {
+    throw new RangeError(
+      'The "filename" property contains invalid characters. To prevent injection, only alphanumeric characters, dots (.), underscores (_), and hyphens (-) are allowed.',
+    );
+  }
+
+  // Validate Web Workers Array if provided
+  if (options.webWorkers !== undefined) {
+    if (!Array.isArray(options.webWorkers)) {
+      throw new TypeError('The "webWorkers" property must be an array.');
+    }
+    options.webWorkers.forEach((ww, index) => {
+      if (typeof ww !== 'object' || ww === null) {
+        throw new TypeError(`webWorkers[${index}] must be a non-null object.`);
+      }
+      if (typeof ww.entry !== 'string') {
+        throw new TypeError(`webWorkers[${index}].entry must be a string.`);
+      }
+      if (typeof ww.filename !== 'string') {
+        throw new TypeError(`webWorkers[${index}].filename must be a string.`);
+      }
+      if (!filenamePattern.test(ww.filename)) {
+        throw new RangeError(`webWorkers[${index}].filename contains invalid characters.`);
+      }
+    });
+  }
+
+  const {
+    manifest,
+    manifestPath,
+    srcDir,
+    filename,
+    swRegistrationOptions,
+    webWorkers = [],
+  } = options;
+  const injectRegister = options.injectRegister ?? true;
+  const injectManifestToGlobal = options.injectManifestToGlobal ?? true;
+
+  /** @type {string} */
+  let swSourcePath;
+  /** @type {Array<{ entryPath: string, filename: string }>} */
+  let resolvedWebWorkers = [];
+  /** @type {import('vite').ResolvedConfig} */
+  let viteConfig;
+
+  return {
+    name: 'tiny-vite-pwa',
+
+    // Capture Vite configuration to use during build mode
+    configResolved(config) {
+      viteConfig = config;
+      swSourcePath = path.resolve(config.root, srcDir, filename);
+
+      // Resolve absolute paths for Web Workers
+      resolvedWebWorkers = webWorkers.map((ww) => ({
+        entryPath: path.resolve(config.root, ww.entry, ww.filename),
+        filename: ww.filename,
+      }));
+    },
+
+    config(config) {
+      const define = { ...config.define };
+      if (injectManifestToGlobal) define.__TINY_PWA_MANIFEST__ = JSON.stringify(manifest);
+      return { ...config, define };
+    },
+
+    // REQUIREMENTS 1 & 4 (DEV Mode): Serve the manifest, Service Worker, and Web Workers
+    configureServer(server) {
+      // Extract server info to build a clickable URL
+      const serverConfig = server.config.server || {};
+      let host = serverConfig.host;
+      if (host === true) {
+        host = '0.0.0.0';
+      } else if (typeof host !== 'string') {
+        host = 'localhost';
+      }
+
+      const port = serverConfig.port;
+      const isHttps = serverConfig.https ? true : false;
+
+      const protocol = isHttps ? 'https' : 'http';
+
+      // If host is 0.0.0.0, use localhost so the link is clickable in the terminal
+      const displayHost = host === '0.0.0.0' ? 'localhost' : host;
+      const baseUrl = `${protocol}://${displayHost}:${port}`;
+
+      const normalizedManifestPath = manifestPath.startsWith('/')
+        ? manifestPath
+        : `/${manifestPath}`;
+      const swUrl = `/${filename}`;
+
+      server.middlewares.use(async (req, res, next) => {
+        // We parse the incoming request URL to extract only the pathname.
+        // This ensures that requests with query parameters (e.g., /sw.js?v=123)
+        // are correctly matched to the file paths.
+        const requestUrl = new URL(req.url ?? '', 'http://localhost');
+        const pathname = requestUrl.pathname;
+
+        // Serve manifest.json dynamically
+        if (pathname === normalizedManifestPath) {
+          res.setHeader('Content-Type', 'application/json');
+          res.end(JSON.stringify(manifest, null, 2));
+          return;
+        }
+
+        // Serve the Service Worker in Dev mode using Vite's transformer
+        if (pathname === swUrl) {
+          try {
+            const transformed = await server.transformRequest(swSourcePath);
+            if (transformed) {
+              res.setHeader('Content-Type', 'application/javascript');
+              res.end(transformed.code);
+              return;
+            }
+          } catch (e) {
+            logger.error(
+              'Error transforming the SW in dev:',
+              e instanceof Error ? e : new Error('Unknown Error'),
+            );
+          }
+        }
+
+        // Serve Web Workers in Dev mode
+        for (const ww of resolvedWebWorkers) {
+          if (pathname === `/${ww.filename}`) {
+            try {
+              const transformed = await server.transformRequest(ww.entryPath);
+              if (transformed) {
+                res.setHeader('Content-Type', 'application/javascript');
+                res.end(transformed.code);
+                return;
+              }
+            } catch (e) {
+              logger.error(
+                `Error transforming Web Worker (${ww.filename}) in dev:`,
+                e instanceof Error ? e : new Error('Unknown Error'),
+              );
+            }
+          }
+        }
+
+        next();
+      });
+
+      logger.success(`Manifest available at: ${baseUrl}${normalizedManifestPath}`);
+      logger.success(`Service Worker available at: ${baseUrl}${swUrl}`);
+
+      resolvedWebWorkers.forEach((ww) => {
+        logger.success(`Web Worker available at: ${baseUrl}/${ww.filename}`);
+      });
+
+      logger.warn(
+        `NOTE: If your Service Worker implements client-side routing, ensure it is configured to bypass interception for the manifest, SW, and WW files.`,
+      );
+    },
+
+    // REQUIREMENT 3: Monitor SW and WW changes and notify the frontend
+    handleHotUpdate({ file, server }) {
+      // Check for Service Worker updates
+      if (file.startsWith(path.resolve(viteConfig.root, srcDir))) {
+        logger.info('Service Worker change detected. Notifying frontend...');
+        // Send a custom event via Vite's WebSocket
+        server.ws.send({
+          type: 'custom',
+          event: 'pwa:sw-updated',
+          data: { message: 'The Service Worker file has been changed.' },
+        });
+
+        // Return an empty array so Vite does not attempt a full page reload automatically
+        return [];
+      }
+
+      // Check for Web Worker updates
+      for (const ww of resolvedWebWorkers) {
+        if (file === ww.entryPath) {
+          logger.info(`Web Worker change detected (${ww.filename}). Notifying frontend...`);
+          server.ws.send({
+            type: 'custom',
+            event: 'pwa:ww-updated',
+            data: {
+              message: `The Web Worker file ${ww.filename} has been changed.`,
+              filename: ww.filename,
+            },
+          });
+          return [];
+        }
+      }
+    },
+
+    // INJECT HTML SCRIPT: Inject the SW registration code and the Manifest link into the output HTML
+    transformIndexHtml() {
+      // In production mode, we append a timestamp to the URL to force cache busting.
+      // In development mode, we omit the timestamp to avoid generating unnecessary logs on every reload.
+      const isBuild = viteConfig && viteConfig.command === 'build';
+
+      /**
+       * Safely appends a cache-busting timestamp to a URL string.
+       * @param {string} urlStr - The base URL path.
+       * @returns {string} The URL path with the 'v' parameter appended correctly.
+       */
+      const getVersionedUrl = (urlStr) => {
+        // We use a dummy base ('http://localhost') because the URL constructor
+        // requires an absolute URL to parse relative paths correctly.
+        const url = new URL(urlStr, 'http://localhost');
+
+        // .set() is smart: it uses '?' if no params exist, or '&' if they do.
+        url.searchParams.set('v', Date.now().toString());
+
+        // We return only the pathname and search (e.g., "/sw.js?v=123")
+        // to keep the injection relative for the HTML.
+        return url.pathname + url.search;
+      };
+
+      const swUrl = getVersionedUrl(`/${filename}`);
+
+      // Prepare the manifest URL with cache busting for production
+      const normalizedManifestHref = manifestPath.startsWith('/')
+        ? manifestPath
+        : `/${manifestPath}`;
+      const manifestUrl = getVersionedUrl(normalizedManifestHref);
+
+      /** @type {import('vite').HtmlTagDescriptor[]} */
+      const insertData = [];
+
+      // Manifest
+      logger.info(`Injecting Manifest into HTML: ${manifestUrl}`);
+      insertData.push({
+        tag: 'link',
+        injectTo: 'head',
+        attrs: {
+          rel: 'manifest',
+          href: manifestUrl,
+        },
+      });
+
+      // SW
+      if (injectRegister) {
+        logger.info(`Injecting Service Worker into HTML: ${swUrl}`);
+
+        // Prepare the registration options string safely using JSON.stringify
+        // If no options are provided, swOptionsString remains an empty string.
+        const swOptionsString = swRegistrationOptions
+          ? `, ${JSON.stringify(swRegistrationOptions)}`
+          : '';
+
+        insertData.push({
+          tag: 'script',
+          injectTo: 'head',
+          children: `
+          if ('serviceWorker' in navigator) { 
+            window.addEventListener('load', () => { 
+              navigator.serviceWorker.register('${swUrl}'${swOptionsString})${!isBuild ? `.then(() => console.log('[tiny-vite-pwa] SW registered.')).catch(err => console.error('[tiny-vite-pwa] SW error:', err))` : ''}; 
+            }); 
+          };`
+            .replace(/\n/g, '')
+            .replace(/  /g, '')
+            .trim(),
+        });
+      }
+
+      return insertData;
+    },
+
+    // REQUIREMENT 1 (PROD Mode): Save the manifest to the dist directory
+    generateBundle() {
+      // Remove the leading slash from the path to prevent Rollup errors
+      const emitPath = manifestPath.replace(/^\//, '');
+      this.emitFile({
+        type: 'asset',
+        fileName: emitPath,
+        source: JSON.stringify(manifest),
+      });
+    },
+
+    // REQUIREMENT 4 (PROD Mode): Bundle the Service Worker and Web Workers separately
+    async closeBundle() {
+      // Only run this during the build command (production)
+      if (viteConfig.command === 'build') {
+        const projectRoot = viteConfig.root || process.cwd();
+
+        logger.dim('--------------------------------------------------');
+        logger.log(` Mode:       ${colors.bright}${viteConfig.mode}${colors.reset}`);
+
+        // --- Build Service Worker ---
+        const relativeSourceSW = path.relative(projectRoot, swSourcePath);
+        const relativeDestSW = path.relative(projectRoot, path.resolve(viteConfig.build.outDir, filename));
+
+        const manifestDestPath = path.resolve(viteConfig.build.outDir, manifestPath.replace(/^\//, ''));
+        const relativeDestManifest = path.relative(projectRoot, manifestDestPath);
+
+        logger.info('Initiating Service Worker bundling process...');
+
+        // Manifest Info
+        logger.log(` Manifest:   ${colors.cyan}${relativeDestManifest}${colors.reset}`);
+
+        // Service Worker Info
+        logger.log(` SW Source:  ${colors.cyan}${relativeSourceSW}${colors.reset}`);
+        logger.log(` SW Dest:    ${colors.cyan}${relativeDestSW}${colors.reset}`);
+
+        try {
+          await vite.build({
+            configFile: false, // Ignore the main vite.config.js to prevent infinite loops
+            mode: viteConfig.mode,
+            build: {
+              outDir: viteConfig.build.outDir,
+              emptyOutDir: false, // IMPORTANT: Do not delete the React build that was just completed
+              lib: {
+                entry: swSourcePath,
+                name: 'ServiceWorker',
+                formats: ['iife'], // IIFE bundles all imports into a single file (classic SW standard)
+                fileName: () => filename,
+              },
+              rollupOptions: {
+                // Ensures no hashes are added to the SW filename
+                output: { entryFileNames: filename },
+              },
+            },
+          });
+          logger.success('Service Worker bundled successfully.');
+        } catch (e) {
+          logger.error(
+            'Failed to bundle the Service Worker.',
+            e instanceof Error ? e : new Error('Unknown Error'),
+          );
+        }
+
+        // --- Build Web Workers ---
+        if (resolvedWebWorkers.length > 0) {
+          logger.dim('--------------------------------------------------');
+          logger.info('Initiating Web Workers bundling process...');
+
+          for (const ww of resolvedWebWorkers) {
+            const relativeSourceWW = path.relative(projectRoot, ww.entryPath);
+            const relativeDestWW = path.relative(
+              projectRoot,
+              path.resolve(viteConfig.build.outDir, ww.filename),
+            );
+
+            logger.log(` WW Source:  ${colors.cyan}${relativeSourceWW}${colors.reset}`);
+            logger.log(` WW Dest:    ${colors.cyan}${relativeDestWW}${colors.reset}`);
+
+            try {
+              await vite.build({
+                configFile: false,
+                mode: viteConfig.mode,
+                build: {
+                  outDir: viteConfig.build.outDir,
+                  emptyOutDir: false,
+                  lib: {
+                    entry: ww.entryPath,
+                    name: ww.filename.replace(/\.[^/.]+$/, ''),
+                    formats: ['iife'],
+                    fileName: () => ww.filename,
+                  },
+                  rollupOptions: {
+                    output: { entryFileNames: ww.filename },
+                  },
+                },
+              });
+              logger.success(`Web Worker (${ww.filename}) bundled successfully.`);
+            } catch (e) {
+              logger.error(
+                `Failed to bundle the Web Worker (${ww.filename}).`,
+                e instanceof Error ? e : new Error('Unknown Error'),
+              );
+            }
+          }
+        }
+        logger.dim('--------------------------------------------------');
+      }
+    },
+  };
+};
+
+module.exports = TinyVitePwaPlugin;