@caperjs/core 0.1.2 → 0.2.1

package/build/plugins/lists.mjs

@@ -0,0 +1,286 @@
+/**
+ * The five list plugins and the virtual modules they feed the runtime:
+ * `virtual:caper-scenes`, `-plugins`, `-popups`, `-entities`, `-uis`.
+ *
+ * Each asks `internal/discovery.mjs` what exists, then emits a module the runtime
+ * imports — statically for entities and UI (so `this.add.entity(id)` can construct
+ * synchronously) and dynamically for scenes and popups (so they code-split).
+ */
+import path from 'node:path';
+import {
+  discoverEntities,
+  discoverLocaleKeys,
+  discoverPlugins,
+  discoverPopups,
+  discoverScenes,
+  discoverUIs,
+} from '../internal/discovery.mjs';
+import { logger } from '../internal/util.mjs';
+import { loadManifestBundleNames } from '../internal/manifest.mjs';
+
+export function createClassListPlugin({ virtualModuleId, discoverFn, exportName, pluginName }) {
+  // vite's resolved project root, captured for the discovery pass. See
+  // internal/discovery.mjs for why this is not process.cwd().
+  let root;
+  const resolvedVirtualModuleId = '\0' + virtualModuleId;
+  let server;
+
+  const extractClassName = (item) => {
+    const basename = path.basename(item.module);
+    return basename.replace(/\.ts$/, '');
+  };
+
+  const generate = (items) => {
+    const staticItems = items.filter((i) => i.module && !i.module.isFunction);
+    const imports = staticItems.map((i) => `import ${extractClassName(i)} from '${i.module}';`);
+
+    return `
+    ${imports.join('\n')}
+    export const ${exportName} = [
+      ${items
+        .map((item) => {
+          const moduleExpr =
+            item.module && !item.module.isFunction
+              ? extractClassName(item)
+              : (item.module?.toString?.() ?? `() => import('${item.importPath}')`);
+          return `{
+        id: '${item.id}',
+        name: '${item.name}',
+        active: ${item.active},
+        module: ${moduleExpr}
+      }`;
+        })
+        .join(',\n')}
+    ];
+  `;
+  };
+
+  return {
+    name: pluginName,
+    configResolved(config) {
+      root = config.root;
+    },
+    configureServer(s) {
+      server = s;
+    },
+    resolveId(id) {
+      if (id === virtualModuleId) return resolvedVirtualModuleId;
+    },
+    async load(id) {
+      if (id === resolvedVirtualModuleId) {
+        const items = await discoverFn(server, root);
+        return generate(items);
+      }
+    },
+  };
+}
+
+export function popupListPlugin(isProject = true) {
+  if (!isProject) {
+    const virtualModuleId = 'virtual:caper-popups';
+    const resolvedVirtualModuleId = '\0' + virtualModuleId;
+    return {
+      name: 'vite-plugin-popups',
+      resolveId: (id) => (id === virtualModuleId ? resolvedVirtualModuleId : undefined),
+      load: (id) => (id === resolvedVirtualModuleId ? 'export const popupList = [];' : undefined),
+    };
+  }
+  return createClassListPlugin({
+    virtualModuleId: 'virtual:caper-popups',
+    discoverFn: discoverPopups,
+    exportName: 'popupList',
+    pluginName: 'vite-plugin-popups',
+  });
+}
+
+export function entityListPlugin(isProject = true) {
+  if (!isProject) {
+    const virtualModuleId = 'virtual:caper-entities';
+    const resolvedVirtualModuleId = '\0' + virtualModuleId;
+    return {
+      name: 'vite-plugin-entities',
+      resolveId: (id) => (id === virtualModuleId ? resolvedVirtualModuleId : undefined),
+      load: (id) => (id === resolvedVirtualModuleId ? 'export const entityList = [];' : undefined),
+    };
+  }
+  return createClassListPlugin({
+    virtualModuleId: 'virtual:caper-entities',
+    discoverFn: discoverEntities,
+    exportName: 'entityList',
+    pluginName: 'vite-plugin-entities',
+  });
+}
+
+export function uiListPlugin(isProject = true) {
+  if (!isProject) {
+    const virtualModuleId = 'virtual:caper-uis';
+    const resolvedVirtualModuleId = '\0' + virtualModuleId;
+    return {
+      name: 'vite-plugin-uis',
+      resolveId: (id) => (id === virtualModuleId ? resolvedVirtualModuleId : undefined),
+      load: (id) => (id === resolvedVirtualModuleId ? 'export const uiList = [];' : undefined),
+    };
+  }
+  return createClassListPlugin({
+    virtualModuleId: 'virtual:caper-uis',
+    discoverFn: discoverUIs,
+    exportName: 'uiList',
+    pluginName: 'vite-plugin-uis',
+  });
+}
+
+/**
+ * Walks `src/locales/`, picks a reference locale file (prefers `en.ts`,
+ * falls back alphabetically), AST-parses its default-exported object, and
+ * flattens every leaf path into a dot-notation key.
+ *
+ * Given:
+ *   export default { foo: 'bar', obj: { nested: 'baz' }, replace: { x: '...' } };
+ * Returns:
+ *   ['foo', 'obj.nested', 'replace.x']
+ *
+ * Only string literal leaves are emitted. Arrays, function calls, and other
+ * non-object/non-literal expressions are ignored (they can't be typed
+ * meaningfully at this layer).
+ */
+
+export function pluginListPlugin(isProject = true) {
+  function extractClassName(plugin) {
+    // For static (non-function) imports, the module value is the raw import path.
+    const basename = path.basename(plugin.module);
+    return basename.replace(/\.ts$/, '');
+  }
+
+  function generatePluginListModule(plugins) {
+    const staticPlugins = plugins.filter((p) => p.module && !p.module.isFunction && p.isLocal);
+
+    // npm static imports would collide on class-name derivation from the pkg
+    // path, so only local plugins support `dynamic = false`. npm packages are
+    // always dynamic.
+    const imports = staticPlugins.map((p) => `import ${extractClassName(p)} from '${p.module}';`);
+
+    return `
+    ${imports.join('\n')}
+    export const pluginsList = [
+      ${plugins
+        .map((plugin) => {
+          const moduleExpr =
+            plugin.module && !plugin.module.isFunction && plugin.isLocal
+              ? extractClassName(plugin)
+              : (plugin.module?.toString?.() ?? `() => import('${plugin.importPath}')`);
+          return `{
+        name: '${plugin.name}',
+        id: '${plugin.id}',
+        isLocal: ${plugin.isLocal},
+        active: ${plugin.active},
+        requires: ${JSON.stringify(plugin.requires || [])},
+        module: ${moduleExpr}
+      }`;
+        })
+        .join(',\n')}
+    ];
+  `;
+  }
+
+  const virtualModuleId = 'virtual:caper-plugins';
+  const resolvedVirtualModuleId = '\0' + virtualModuleId;
+
+  let root;
+  let server;
+
+  return {
+    name: 'vite-plugin-plugins',
+    configResolved(config) {
+      root = config.root;
+    },
+    configureServer(s) {
+      server = s;
+    },
+    resolveId(id) {
+      if (id === virtualModuleId) {
+        return resolvedVirtualModuleId;
+      }
+    },
+    async load(id) {
+      if (id === resolvedVirtualModuleId) {
+        const plugins = isProject ? await discoverPlugins(server, root) : [];
+        return generatePluginListModule(plugins);
+      }
+    },
+  };
+}
+
+// scene list plugin
+
+export function sceneListPlugin(isProject = true) {
+  function extractClassName(scene) {
+    const basename = path.basename(scene.module);
+    // remove .ts
+    return basename.replace('.ts', '');
+  }
+
+  function generateSceneListModule(scenes) {
+    // extract non function scenes from the list
+    const nonFunctionScenes = scenes.filter((scene) => !scene.module.isFunction);
+
+    const imports = nonFunctionScenes.map((scene) => `import ${extractClassName(scene)} from '${scene.module}';`);
+
+    const result = `
+    ${imports.join('\n')}
+    export const sceneList = [
+      ${scenes
+        .map(
+          (scene) => `{
+        id: '${scene.id}',
+        active: ${scene.active},
+        module: ${scene.module.isFunction ? scene.module.toString() : extractClassName(scene)},
+        debugLabel: ${JSON.stringify(scene.debugLabel)},
+        debugGroup: ${JSON.stringify(scene.debugGroup)},
+        debugOrder: ${scene.debugOrder},
+        assets: ${JSON.stringify(scene.assets)},
+        plugins: ${JSON.stringify(scene.plugins)},
+        autoUnloadAssets: ${scene.autoUnloadAssets}
+      }`,
+        )
+        .join(',\n')}
+    ];
+  `;
+    return result;
+  }
+
+  const virtualModuleId = 'virtual:caper-scenes';
+  const resolvedVirtualModuleId = '\0' + virtualModuleId;
+
+  let root;
+  let server;
+
+  return {
+    name: 'vite-plugin-scenes',
+    configResolved(config) {
+      root = config.root;
+    },
+    configureServer(s) {
+      server = s;
+    },
+    resolveId(id) {
+      if (id === virtualModuleId) {
+        return resolvedVirtualModuleId;
+      }
+    },
+    async load(id) {
+      if (id === resolvedVirtualModuleId) {
+        let scenes = [];
+        if (isProject) {
+          scenes = await discoverScenes(server, root);
+        }
+        return generateSceneListModule(scenes);
+      }
+    },
+  };
+}
+
+/**
+ * @param {{ pwa?: object }} [options] When `pwa` is set, the runtime module also
+ *   installs `Caper.pwa` and (unless `autoRegister: false`) registers the
+ *   service worker. See `../build/plugins/pwa.mjs`.
+ */

package/build/plugins/pruneFallbacks.mjs

@@ -0,0 +1,150 @@
+/**
+ * Webp-only production builds.
+ *
+ * AssetPack emits every image twice, `.webp` and `.png`, and lists webp first in
+ * `assets.json` — so pixi's resolver takes webp on every browser shipped since
+ * 2020 and the png half is dead weight. In a caper game that's megabytes: 5.8MB
+ * of a 43MB build, in bankshot's case.
+ *
+ * Dev keeps both on purpose: the png is passed through uncompressed there, which
+ * is the cheapest thing the pipeline can do, and nothing downloads it anyway.
+ * Production drops it. Opt back in with `caper({ assets: { pngFallback: true } })`
+ * if you need to serve a browser without webp support.
+ *
+ * Why prune rather than not emit: AssetPack's `compression.png: false` doesn't
+ * drop the file, it passes the *uncompressed original* through — bigger than the
+ * compressed one — and that combination crashes the texture-packer cache-buster
+ * before the manifest is written.
+ *
+ * `assets.json` drives the prune rather than filenames, because production
+ * cache-busts each format with its own hash (`sheet-u_QUSQ@2x.png` next to
+ * `sheet-Ui99Xw@2x.webp`), so pairing them on disk is guesswork. A png `src` is
+ * only dropped when a non-png `src` survives it, so a `{nc}`-tagged (uncompressed
+ * on purpose) image is never deleted out from under the game.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+
+/** A png image, a texture-packer descriptor, or a spine atlas for one. */
+const isPngSrc = (src) => /\.png(\.json|\.atlas)?$/.test(src);
+
+/**
+ * Works out what to delete without touching the filesystem, so the decision is
+ * testable on its own.
+ *
+ * @param {{ bundles: { assets: { src: string[] }[] }[] }} manifest Parsed asset manifest; rewritten in place.
+ * @param {(rel: string) => string | null} readText Returns a descriptor's contents, or null if absent.
+ * @returns {string[]} Manifest-relative paths to delete.
+ */
+export function planPngPrune(manifest, readText) {
+  const doomed = [];
+  const seen = new Set();
+
+  /**
+   * A descriptor, the image(s) it names, and any further pages it chains to.
+   *
+   * Two formats reference images by name rather than being manifest entries
+   * themselves: a texture-packer `*.png.json` (`meta.image`, plus
+   * `related_multi_packs` for pages past the first, which are never manifest
+   * entries) and a spine `*.png.atlas` (page names on their own lines). `seen` is
+   * load-bearing for the first: sibling pages list each other, so following the
+   * chain without it never terminates.
+   */
+  const addDescriptor = (rel) => {
+    if (seen.has(rel)) return;
+    seen.add(rel);
+
+    const text = readText(rel);
+    if (text) {
+      if (rel.endsWith('.atlas')) {
+        for (const line of text.split(/\r?\n/)) {
+          const name = line.trim();
+          if (name.endsWith('.png')) doomed.push(path.join(path.dirname(rel), name));
+        }
+      } else {
+        let sheet;
+        try {
+          sheet = JSON.parse(text);
+        } catch {
+          sheet = null;
+        }
+        if (sheet?.meta?.image) doomed.push(path.join(path.dirname(rel), sheet.meta.image));
+        for (const pack of sheet?.meta?.related_multi_packs ?? []) {
+          addDescriptor(path.join(path.dirname(rel), pack));
+        }
+      }
+    }
+    doomed.push(rel);
+  };
+
+  for (const bundle of manifest.bundles ?? []) {
+    for (const asset of bundle.assets ?? []) {
+      const png = (asset.src ?? []).filter(isPngSrc);
+      const kept = (asset.src ?? []).filter((src) => !isPngSrc(src));
+      if (!png.length || !kept.length) continue;
+
+      for (const rel of png) {
+        if (rel.endsWith('.png.json') || rel.endsWith('.png.atlas')) addDescriptor(rel);
+        else doomed.push(rel);
+      }
+      // Keep the manifest honest: a src the resolver could still pick but the
+      // build no longer ships would 404 on whoever got that far.
+      asset.src = kept;
+    }
+  }
+
+  return doomed;
+}
+
+/**
+ * @param {{ manifestUrl?: string }} [options]
+ * @returns {import('vite').Plugin}
+ */
+export function pngFallbackPrunePlugin({ manifestUrl = 'assets.json' } = {}) {
+  let assetsDir;
+  let enabled = false;
+
+  return {
+    name: 'caper:prune-png-fallbacks',
+    apply: 'build',
+    configResolved(config) {
+      // Dev builds keep the fallback; so does a `vite build --mode development`.
+      enabled = config.isProduction;
+      assetsDir = path.join(config.build.outDir, 'assets');
+      if (!path.isAbsolute(assetsDir)) assetsDir = path.resolve(config.root, assetsDir);
+    },
+    closeBundle: {
+      // Ahead of vite-plugin-pwa, which globs `dist` to build its precache list.
+      order: 'pre',
+      sequential: true,
+      handler() {
+        if (!enabled) return;
+
+        const manifestPath = path.join(assetsDir, manifestUrl);
+        if (!fs.existsSync(manifestPath)) return;
+
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+        const doomed = planPngPrune(manifest, (rel) => {
+          const file = path.join(assetsDir, rel);
+          return fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : null;
+        });
+
+        let removed = 0;
+        let bytes = 0;
+        for (const rel of doomed) {
+          const file = path.join(assetsDir, rel);
+          if (!fs.existsSync(file)) continue;
+          bytes += fs.statSync(file).size;
+          fs.rmSync(file);
+          removed += 1;
+        }
+
+        fs.writeFileSync(manifestPath, JSON.stringify(manifest));
+
+        if (removed) {
+          this.info?.(`pruned ${removed} png fallbacks (${(bytes / 1e6).toFixed(1)}MB) — set assets.pngFallback to keep them`);
+        }
+      },
+    },
+  };
+}

package/build/plugins/pwa.mjs

@@ -0,0 +1,240 @@
+/**
+ * PWA support for the `caper()` preset: `caper({ pwa: {} })` should be enough to
+ * ship an installable game. Anything a project does set wins over the defaults
+ * below.
+ *
+ * Three halves, really. `caperPwaPlugins()` adds vite-plugin-pwa with caper's
+ * defaults merged under the project's options, plus a small companion plugin that
+ * fills in the parts only knowable once vite has resolved its config (icons found
+ * in `publicDir`, and the precache globs). `pwaRuntimeSnippet()` returns the code
+ * that installs `Caper.pwa` — appended to the `caper-runtime` virtual module,
+ * which `index.html` already loads.
+ *
+ * That last part is the fix for the old arrangement: `withPWA()` added a virtual
+ * `caper-pwa` rollup input that defined `Caper.pwa.register()`, but nothing ever
+ * imported it, so registration never ran and the API was dead. Registering from
+ * the runtime also means `injectRegister` defaults to `false` — exactly one thing
+ * registers the worker.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { VitePWA } from 'vite-plugin-pwa';
+import { readAppIdentity } from '../defaults.mjs';
+
+const isPlainObject = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+
+/** Deep-merge `overrides` over `base`; arrays and scalars replace. */
+function deepMerge(base, overrides) {
+  if (!isPlainObject(overrides)) return overrides === undefined ? base : overrides;
+  const out = { ...base };
+  for (const [key, value] of Object.entries(overrides)) {
+    out[key] = isPlainObject(value) && isPlainObject(base?.[key]) ? deepMerge(base[key], value) : value;
+  }
+  return out;
+}
+
+/**
+ * Icon files a project is likely to already have, in the names the usual
+ * favicon generators produce. A web manifest needs a 192 and a 512 to be
+ * installable, so finding them automatically is the difference between
+ * `pwa: {}` working and quietly producing an uninstallable app.
+ */
+const ICON_CANDIDATES = [
+  { file: 'android-chrome-192x192.png', sizes: '192x192' },
+  { file: 'pwa-192x192.png', sizes: '192x192' },
+  { file: 'icon-192.png', sizes: '192x192' },
+  { file: 'android-chrome-512x512.png', sizes: '512x512' },
+  { file: 'pwa-512x512.png', sizes: '512x512' },
+  { file: 'icon-512.png', sizes: '512x512' },
+];
+
+/**
+ * Manifest icon entries for whatever conventional icons exist in `publicDir`.
+ * The largest one is repeated as `maskable` so Android doesn't letterbox it.
+ */
+export function discoverIcons(publicDir) {
+  if (!publicDir || !fs.existsSync(publicDir)) return [];
+
+  const icons = [];
+  const seen = new Set();
+  for (const { file, sizes } of ICON_CANDIDATES) {
+    if (seen.has(sizes)) continue;
+    if (!fs.existsSync(path.join(publicDir, file))) continue;
+    seen.add(sizes);
+    icons.push({ src: `/${file}`, sizes, type: 'image/png' });
+  }
+
+  const largest = icons.find((icon) => icon.sizes === '512x512');
+  if (largest) icons.push({ ...largest, purpose: 'maskable' });
+
+  return icons;
+}
+
+/**
+ * Precache the shell, runtime-cache the art.
+ *
+ * A caper game's `public/assets` is usually tens of megabytes, so precaching it
+ * would turn "install" into a full download — and workbox would silently skip
+ * whatever exceeded its 2MB default anyway. So: precache what's needed to boot
+ * (code, icons, fonts, the asset manifest, the `required` bundle, level data) and
+ * let everything else land in the cache the first time it's fetched.
+ */
+function defaultWorkbox() {
+  return {
+    globPatterns: [
+      'index.html',
+      'manifest.webmanifest',
+      'assets/*.{js,css}',
+      'assets/assets.json',
+      'assets/caper/**/*',
+      'assets/required/**/*.{webp,png,json,woff2,ttf}',
+      'assets/splash/**/*.{webp,png}',
+      'levels/**/*.json',
+      '*.{ico,svg,png}',
+    ],
+    // A pixi + game bundle clears the 2MiB default on its own.
+    maximumFileSizeToCacheInBytes: 5 * 1024 * 1024,
+    cleanupOutdatedCaches: true,
+    navigateFallback: 'index.html',
+    runtimeCaching: [
+      {
+        // Cache-busted filenames make these immutable: first fetch wins, and a
+        // new build simply asks for new names.
+        urlPattern: /^\/assets\/.*\.(?:webp|png|jpg|json|mp3|ogg|woff2|ttf|atlas|skel|fnt)$/,
+        handler: 'CacheFirst',
+        options: {
+          cacheName: 'caper-assets',
+          expiration: { maxEntries: 500, maxAgeSeconds: 60 * 60 * 24 * 60 },
+          cacheableResponse: { statuses: [0, 200] },
+          // Safari streams audio with Range requests, which a plain CacheFirst
+          // match would answer with a 200 and break playback.
+          rangeRequests: true,
+        },
+      },
+    ],
+  };
+}
+
+/** Caper's vite-plugin-pwa defaults. */
+export function defaultPwaOptions() {
+  const app = readAppIdentity();
+
+  return {
+    // Root-absolute so the worker's scope and the manifest link don't depend on
+    // vite's relative production `base`.
+    base: '/',
+    registerType: 'autoUpdate',
+    // The caper runtime registers the worker (see pwaRuntimeSnippet), so the
+    // plugin must not also inject a script for it.
+    injectRegister: false,
+    selfDestroying: process.env.SW_DESTROY === 'true',
+    devOptions: {
+      // A service worker in dev serves stale assets from cache, which is a bad
+      // time in a project whose assets rebuild on save. Opt in with SW_DEV=true.
+      enabled: process.env.SW_DEV === 'true',
+      navigateFallback: 'index.html',
+      suppressWarnings: true,
+    },
+    manifest: {
+      id: '/',
+      name: app.name,
+      short_name: app.name,
+      description: app.description,
+      start_url: '/',
+      scope: '/',
+      theme_color: '#000000',
+      background_color: '#000000',
+      display: 'fullscreen',
+      display_override: ['fullscreen', 'standalone', 'minimal-ui'],
+      orientation: 'any',
+      categories: ['games', 'entertainment'],
+    },
+    workbox: defaultWorkbox(),
+  };
+}
+
+/**
+ * Fills the defaults that need vite's resolved config. Mutates the same options
+ * object handed to `VitePWA` above, which reads it later (at build time) — doing
+ * this here rather than at construction means it follows `publicDir` and
+ * `--root`, instead of guessing from `process.cwd()`.
+ */
+function caperPwaDefaultsPlugin(options, projectSetIcons) {
+  return {
+    name: 'caper:pwa-defaults',
+    configResolved: {
+      // Must beat vite-plugin-pwa, which snapshots its options in its own
+      // configResolved — mutating after that has no effect on the manifest.
+      order: 'pre',
+      handler(config) {
+        if (projectSetIcons) return;
+
+        const icons = discoverIcons(config.publicDir);
+        if (icons.length) {
+          options.manifest.icons = icons;
+        } else {
+          config.logger.warn(
+            '[caper] pwa: no icons found in publicDir — the app will not be installable. ' +
+              'Add android-chrome-192x192.png and android-chrome-512x512.png, or set pwa.manifest.icons.',
+          );
+        }
+      },
+    },
+  };
+}
+
+/**
+ * @param {object} pwa Project options, merged over `defaultPwaOptions()`.
+ * @returns {import('vite').PluginOption[]}
+ */
+export function caperPwaPlugins(pwa) {
+  const { autoRegister: _autoRegister, ...projectOptions } = pwa;
+  const options = deepMerge(defaultPwaOptions(), projectOptions);
+  const projectSetIcons = Boolean(projectOptions.manifest?.icons?.length);
+
+  return [caperPwaDefaultsPlugin(options, projectSetIcons), VitePWA(options)];
+}
+
+/**
+ * Code appended to the `caper-runtime` virtual module when PWA is enabled.
+ * Installs `Caper.pwa` (the interface declared in `src/core/create.ts`) and, by
+ * default, registers the worker.
+ *
+ * The handlers are read off `Caper.pwa` at call time rather than captured, so an
+ * app can assign `Caper.pwa.onNeedRefresh` after boot and still have it fire.
+ */
+export function pwaRuntimeSnippet({ autoRegister = true } = {}) {
+  return `
+          import { pwaInfo } from 'virtual:pwa-info';
+          import { registerSW } from 'virtual:pwa-register';
+
+          (globalThis).Caper.pwa = {
+            info: pwaInfo,
+            onRegisteredSW(swScriptUrl) {
+              console.log('Caper PWA: service worker registered:', swScriptUrl);
+            },
+            offlineReady() {
+              console.log('Caper PWA: ready to work offline');
+            },
+            register() {
+              registerSW({
+                immediate: true,
+                onRegisteredSW(swScriptUrl) {
+                  (globalThis).Caper.pwa.onRegisteredSW?.(swScriptUrl);
+                },
+                onOfflineReady() {
+                  (globalThis).Caper.pwa.offlineReady?.();
+                },
+                onNeedRefresh() {
+                  (globalThis).Caper.pwa.onNeedRefresh?.();
+                },
+                onRegisterError(error) {
+                  (globalThis).Caper.pwa.onRegisterError?.(error);
+                },
+              });
+            },
+          };
+
+          ${autoRegister ? '(globalThis).Caper.pwa.register();' : '// autoRegister: false — the app calls Caper.pwa.register()'}
+  `;
+}