@ultimat3/pwa 5.0.1 → 7.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ultimat3/pwa",
-  "version": "5.0.1",
+  "version": "7.0.0",
   "description": "Generated service worker, web manifest, icons, push and version-skew handling.",
   "license": "MIT",
   "type": "module",
@@ -31,7 +31,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@ultimat3/core": "5.0.1",
-    "@ultimat3/seo": "5.0.1"
+    "@ultimat3/core": "7.0.0",
+    "@ultimat3/seo": "7.0.0"
   }
 }

package/src/capabilities.ts

@@ -43,15 +43,14 @@ export function enabledCapabilities(capabilities: ResolvedCapabilities): readonl
 }
 
 /** Manifest members a capability owns. Absent capability → absent member. */
-export const CAPABILITY_MANIFEST_KEYS: Readonly<Record<Capability, readonly string[]>> =
-  Object.freeze({
-    push: [],
-    backgroundSync: [],
-    badging: [],
-    shareTarget: ['share_target'],
-    fileHandlers: ['file_handlers'],
-    protocolHandlers: ['protocol_handlers'],
-  });
+export const CAPABILITY_MANIFEST_KEYS = Object.freeze<Record<Capability, readonly string[]>>({
+  push: [],
+  backgroundSync: [],
+  badging: [],
+  shareTarget: ['share_target'],
+  fileHandlers: ['file_handlers'],
+  protocolHandlers: ['protocol_handlers'],
+});
 
 /**
  * The service-worker code each capability emits — its listener, and anything that listener alone
@@ -64,13 +63,11 @@ export const CAPABILITY_MANIFEST_KEYS: Readonly<Record<Capability, readonly stri
  * already serves, so the member is the whole feature and the worker has no branch to add.
  * `shareTarget` named `/_x/share-target` here for two releases and no block ever emitted it.
  */
-export const CAPABILITY_SW_MARKERS: Readonly<Record<Capability, readonly string[]>> = Object.freeze(
-  {
-    push: ["addEventListener('push'", "addEventListener('notificationclick'"],
-    backgroundSync: ["addEventListener('sync'", 'class PwaSyncError'],
-    badging: ['navigator.setAppBadge'],
-    shareTarget: [],
-    fileHandlers: [],
-    protocolHandlers: [],
-  },
-);
+export const CAPABILITY_SW_MARKERS = Object.freeze<Record<Capability, readonly string[]>>({
+  push: ["addEventListener('push'", "addEventListener('notificationclick'"],
+  backgroundSync: ["addEventListener('sync'", 'class PwaSyncError'],
+  badging: ['navigator.setAppBadge'],
+  shareTarget: [],
+  fileHandlers: [],
+  protocolHandlers: [],
+});

package/src/icons.ts

@@ -87,12 +87,13 @@ export interface ImagePipeline {
  * Always square PNG: `toManifestIcon` declares `type: 'image/png'`, so any other format
  * would make the manifest lie about bytes the browser then refuses.
  *
- * `async` on purpose. A `Promise`-typed method that throws synchronously skips every
- * `.catch()` a caller wrote; an undecodable source or a named colour must reject instead.
+ * `await` inside, not a returned promise: core's own refusals (a named colour, a padding out of
+ * range) are thrown before the first `await` in it, and re-raising them here is what keeps every
+ * failure of this method a rejection rather than a synchronous throw past a caller's `.catch()`.
  */
 export class BuiltinImagePipeline implements ImagePipeline {
   async resize(source: Uint8Array, transform: ImageTransform): Promise<Uint8Array> {
-    return transformImageBytes(source, {
+    return await transformImageBytes(source, {
       width: transform.size,
       height: transform.size,
       fit: 'contain',

package/src/index.ts

@@ -1,5 +1,11 @@
 /** Public API of `@ultimat3/pwa`. You never open `sw.js`; you call these. */
 
+/**
+ * `PwaRenderMode` and `PwaOfflineStrategy` were this package's own NAMES for tier 0's vocabulary —
+ * the alias was the copy. `PwaRoute` takes both in its signature, so the canonical names are
+ * re-exported here; a consumer still needs one import, and now it names the real type.
+ */
+export type { OfflineStrategy, RenderMode } from '@ultimat3/core';
 export type { BackgroundSyncOptions, RetryPolicy } from './background-sync';
 export {
   backgroundSyncSource,
@@ -111,8 +117,6 @@ export {
 export type { RouteRule, ServiceWorkerConfig, ServiceWorkerOutput } from './service-worker';
 export { assertScope, generateServiceWorker, routeRules } from './service-worker';
 export type {
-  PwaOfflineStrategy,
-  PwaRenderMode,
   PwaRoute,
   StrategyCache,
   StrategyEnv,

package/src/strategies.ts

@@ -4,6 +4,7 @@
  * its bytes have to be, so the mapping is derived and the override is the exception.
  */
 
+import type { OfflineStrategy, RenderMode } from '@ultimat3/core';
 import { PwaStrategyExhaustedError } from './errors';
 
 export type StrategyName =
@@ -19,9 +20,6 @@ export const STRATEGY_NAMES: readonly StrategyName[] = [
   'network-only',
 ];
 
-export type PwaRenderMode = 'static' | 'isr' | 'ssr' | 'stream' | 'spa';
-export type PwaOfflineStrategy = 'precache' | 'runtime' | 'network-only';
-
 /**
  * Structural view of `@ultimat3/render`'s `RouteDescriptor`. Tier-4 packages must not
  * import each other, so route data arrives as data and this is the shape it must have.
@@ -29,8 +27,8 @@ export type PwaOfflineStrategy = 'precache' | 'runtime' | 'network-only';
 export interface PwaRoute {
   readonly path: string;
   readonly surface: 'site' | 'app' | 'api';
-  readonly mode: PwaRenderMode;
-  readonly offline: PwaOfflineStrategy;
+  readonly mode: RenderMode;
+  readonly offline: OfflineStrategy;
   readonly dynamic?: boolean;
   /** Explicit per-route override; wins over the derived strategy. */
   readonly strategy?: StrategyName;
@@ -41,13 +39,24 @@ export interface PwaRoute {
   readonly dataUrl?: string;
 }
 
-/** Render mode → runtime strategy. The whole reason `sw.js` is generated, not written. */
-export const MODE_STRATEGY: Readonly<Record<PwaRenderMode, StrategyName>> = Object.freeze({
+/**
+ * Render mode → runtime strategy. The whole reason `sw.js` is generated, not written.
+ *
+ * Two separate things make the closed set hold, and the table needed both. `Record<RenderMode, …>`
+ * over the TIER-0 union is the exhaustiveness check — this was keyed on a hand-copy, which is how
+ * `spa` went on mapping to `cache-first` after `spa` was deleted from the vocabulary: the one
+ * strategy that gives an `app/` route a SHARED cache entry, i.e. one member's authed HTML served
+ * to the next. And `Object.freeze<T>({…})` with an EXPLICIT type argument, never
+ * `const X: T = Object.freeze({…})` — the second form infers `T` from the literal and the
+ * annotation only checks assignability afterwards, so the literal's freshness is already gone and
+ * an EXTRA key compiles in silence. Named, the literal is contextually typed and a missing key
+ * AND an extra key are both build errors.
+ */
+export const MODE_STRATEGY = Object.freeze<Record<RenderMode, StrategyName>>({
   static: 'cache-first',
   isr: 'stale-while-revalidate',
   ssr: 'network-first',
   stream: 'stale-while-revalidate',
-  spa: 'cache-first',
 });
 
 export function strategyFor(route: PwaRoute): StrategyName {
@@ -139,12 +148,12 @@ export async function networkOnly(
   }
 }
 
-export const STRATEGY_FNS: Readonly<
+export const STRATEGY_FNS = Object.freeze<
   Record<
     StrategyName,
     (request: Request, env: StrategyEnv, options: StrategyOptions) => Promise<Response>
   >
-> = Object.freeze({
+>({
   'cache-first': cacheFirst,
   'network-first': networkFirst,
   'stale-while-revalidate': staleWhileRevalidate,
@@ -177,7 +186,7 @@ async function fallbackOrThrow(options: StrategyOptions): Promise<Response> {
  * service worker is a generated artifact with no bundler in the loop — the shapes are
  * identical on purpose and `strategies.test.ts` asserts both halves stay in step.
  */
-export const STRATEGY_SOURCE: Readonly<Record<StrategyName, string>> = Object.freeze({
+export const STRATEGY_SOURCE = Object.freeze<Record<StrategyName, string>>({
   'cache-first': `async function cacheFirst(req,cn,fb){
   const c=await caches.open(cn);const hit=await c.match(req);if(hit)return hit;
   try{const r=await fetch(req);if(r.ok)await c.put(req,r.clone());return r}catch(e){if(fb)return fb();throw e}
@@ -199,7 +208,7 @@ export const STRATEGY_SOURCE: Readonly<Record<StrategyName, string>> = Object.fr
 }`,
 });
 
-export const STRATEGY_FN_NAMES: Readonly<Record<StrategyName, string>> = Object.freeze({
+export const STRATEGY_FN_NAMES = Object.freeze<Record<StrategyName, string>>({
   'cache-first': 'cacheFirst',
   'network-first': 'networkFirst',
   'stale-while-revalidate': 'staleWhileRevalidate',