@decocms/start 0.19.0

package/.cursor/skills/deco-start-architecture/cms-resolution.md

@@ -0,0 +1,201 @@
+# CMS Block Resolution
+
+The CMS layer handles loading content blocks from the decofile, resolving `__resolveType` references, and rendering pages.
+
+## Block Loading (`cms/loader.ts`)
+
+### Core Functions
+
+```typescript
+loadBlocks(): Record<string, any>           // Reads .deco/blocks/*.json
+setBlocks(blocks: Record<string, any>): void // Updates in-memory state + revision + notifies listeners
+findPageByPath(path: string, blocks): Page   // Matches URL path to CMS page
+getAllPages(blocks): Page[]                   // Returns all page blocks
+withBlocksOverride(blocks, fn): T            // AsyncLocalStorage override for preview
+getRevision(): string                        // Returns content-hash revision of current blocks
+onChange(listener: () => void): () => void   // Register callback for block changes (returns unsubscribe)
+```
+
+### Revision Tracking
+
+`setBlocks()` now computes a content-based hash (DJB2) of all block keys/types, stored as the current revision. This revision is:
+- Returned by `getRevision()` for use as ETags
+- Included in `GET /.decofile` responses
+- Used by `handleMeta()` to auto-invalidate cached schema when content changes
+
+### onChange Listeners
+
+Register callbacks that fire whenever `setBlocks()` is called:
+
+```typescript
+const unsubscribe = onChange(() => {
+  console.log("Blocks updated, new revision:", getRevision());
+});
+```
+
+Used internally by `handleMeta()` to invalidate its cached ETag when blocks change.
+
+## Section Registry (`cms/registry.ts`)
+
+Registers React section components by key:
+
+```typescript
+registerSection(key: string, component: React.ComponentType, schema?: any): void
+getSection(key: string): SectionEntry | undefined
+getSectionOptions(): string[]
+getSectionRegistry(): Map<string, SectionEntry>
+```
+
+Site's `setup.ts` registers all sections at startup:
+
+```typescript
+import Hero from "./sections/Hero.tsx";
+registerSection("site/sections/Hero.tsx", Hero);
+```
+
+## Resolution (`cms/resolve.ts`)
+
+### resolveDecoPage
+
+Main resolver that walks the page tree, resolving all `__resolveType` references:
+
+```typescript
+resolveDecoPage(page: Page, request: Request, options?: { select?: string }): Promise<ResolvedPage>
+```
+
+Pipeline:
+1. Get page sections from the decofile
+2. Evaluate multivariate flags (A/B testing)
+3. For each section, walk props recursively via `internalResolve()`
+4. When `__resolveType` is found, resolve recursively (generic resolver, not just commerce loaders)
+5. Per-request memoization prevents duplicate calls to the same resolver
+6. Depth protection (max 10 levels) prevents infinite recursion
+7. DanglingReference handler for unresolvable `__resolveType` (configurable fallback)
+8. Apply `select` filtering if specified
+9. Return resolved sections ready for rendering
+
+### Generic Recursive Resolver (`internalResolve`)
+
+The resolution engine now handles any `__resolveType`, not just registered commerce loaders:
+
+```typescript
+// ResolveContext tracks per-request state
+interface ResolveContext {
+  memo: Map<string, unknown>;  // memoization cache
+  depth: number;               // current recursion depth (max: 10)
+}
+```
+
+Resolution order:
+1. Check commerce loaders registry (`commerceLoaders`)
+2. Check decofile blocks (for CMS-defined references)
+3. If neither matches → call `onDanglingReference` handler (configurable)
+
+### Error & Fallback Handlers
+
+```typescript
+setResolveErrorHandler(handler: (error: Error, key: string) => void): void
+setDanglingReferenceHandler(handler: (key: string, props: any) => unknown): void
+addSkipResolveType(type: string): void  // Dynamically add types to skip during resolution
+```
+
+### registerCommerceLoader
+
+```typescript
+registerCommerceLoader(key: string, loader: CommerceLoader): void
+```
+
+Site's `setup.ts`:
+
+```typescript
+import { productList } from "@decocms/apps/vtex/inline-loaders";
+registerCommerceLoader("vtex/loaders/productList.ts", productList);
+```
+
+### Select / Field Filtering
+
+Resolved values can be filtered using `applySelect`:
+
+```typescript
+// Only return specific fields from resolved data
+resolveValue(blocks, request, { select: "name,price,images" });
+```
+
+### registerMatcher
+
+```typescript
+registerMatcher(key: string, matcher: MatcherFn): void
+```
+
+### Built-in Matchers
+
+Registered via `registerBuiltinMatchers()` from `matchers/builtins.ts`:
+
+| Matcher | Key | Purpose |
+|---------|-----|---------|
+| always | website/matchers/always.ts | Always true (also resolves `$live/matchers/MatchAlways.ts`) |
+| never | website/matchers/never.ts | Always false |
+| device | website/matchers/device.ts | Mobile/desktop/tablet |
+| random | website/matchers/random.ts | Traffic percentage |
+| utm | website/matchers/utm.ts | UTM parameter matching |
+| cookie | website/matchers/cookie.ts | Cookie value matching |
+| cron | website/matchers/cron.ts | Time/date range |
+| host | website/matchers/host.ts | Hostname matching |
+| pathname | website/matchers/pathname.ts | URL pattern matching |
+| queryString | website/matchers/queryString.ts | Query param matching |
+
+Matcher context now includes enhanced properties:
+
+```typescript
+interface MatcherContext {
+  request: Request;
+  headers: Headers;
+  siteId: number;
+  site: string;
+}
+```
+
+### Multivariate Flags
+
+The resolver handles `website/flags/multivariate.ts` blocks:
+
+```json
+{
+  "__resolveType": "website/flags/multivariate.ts",
+  "variants": [
+    {
+      "rule": { "__resolveType": "website/matchers/device.ts", "mobile": true },
+      "value": { "sections": ["...mobile sections..."] }
+    },
+    {
+      "rule": { "__resolveType": "website/matchers/always.ts" },
+      "value": { "sections": ["...default sections..."] }
+    }
+  ]
+}
+```
+
+### SKIP_RESOLVE_TYPES
+
+Types intentionally skipped during resolution (handled differently in TanStack).
+Default list includes:
+- `website/loaders/redirects.ts`
+- `commerce/sections/Seo/SeoPDPV2.tsx`
+- `commerce/sections/Seo/SeoPLPV2.tsx`
+
+Additional types can be added dynamically at runtime:
+
+```typescript
+import { addSkipResolveType } from "@decocms/start/cms";
+addSkipResolveType("custom/loaders/myCustomLoader.ts");
+```
+
+### PostHog Matchers (`matchers/posthog.ts`)
+
+Server-side PostHog feature flag evaluation:
+
+```typescript
+createPostHogMatcher(config): MatcherFn
+configurePostHogMatcher(apiKey, personalApiKey): void
+createServerPostHogAdapter(): PostHogAdapter
+```

package/.cursor/skills/deco-start-architecture/code-quality.md

@@ -0,0 +1,158 @@
+# Code Quality
+
+Current state and recommendations for code quality tooling in `@decocms/start`.
+
+## Current State
+
+| Tool | Status |
+|------|--------|
+| TypeScript | Present (`tsc --noEmit` via `typecheck`) |
+| `strictNullChecks` | Enabled |
+| `strict` mode | NOT enabled (only `strictNullChecks`) |
+| ESLint | ABSENT |
+| Prettier | ABSENT |
+| Knip | ABSENT |
+| Vitest/Jest | ABSENT |
+| Husky/lint-staged | ABSENT |
+| Biome | ABSENT |
+
+## Current Scripts
+
+```json
+{
+  "build": "tsc",
+  "typecheck": "tsc --noEmit"
+}
+```
+
+## CI/CD
+
+Only `release.yml` exists - runs `npm install` then `npx semantic-release`. No build, typecheck, lint, or test step before release.
+
+## Recommendations
+
+### 1. TypeScript Strict Mode
+
+Enable full strict mode in `tsconfig.json`:
+
+```json
+{
+  "compilerOptions": {
+    "strict": true
+  }
+}
+```
+
+This enables: `strictNullChecks` (already on), `strictFunctionTypes`, `strictBindCallApply`, `strictPropertyInitialization`, `noImplicitAny`, `noImplicitThis`, `alwaysStrict`, `useUnknownInCatchVariables`.
+
+### 2. Knip (Dead Code Detection)
+
+```json
+// knip.json
+{
+  "entry": ["src/index.ts", "scripts/*.ts"],
+  "project": ["src/**/*.{ts,tsx}", "scripts/**/*.ts"],
+  "ignoreBinaries": ["semantic-release"]
+}
+```
+
+Script: `"lint:unused": "knip"`
+
+### 3. Biome (Lint + Format)
+
+Biome is faster than ESLint + Prettier combined and works well for pure TypeScript projects:
+
+```json
+// biome.json
+{
+  "$schema": "https://biomejs.dev/schemas/2.0/schema.json",
+  "organizeImports": { "enabled": true },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true,
+      "correctness": {
+        "noUnusedVariables": "warn",
+        "noUnusedImports": "warn"
+      }
+    }
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space",
+    "indentWidth": 2
+  },
+  "files": {
+    "include": ["src/**", "scripts/**"]
+  }
+}
+```
+
+Scripts:
+```json
+{
+  "lint": "biome check src/ scripts/",
+  "lint:fix": "biome check --write src/ scripts/",
+  "format": "biome format src/ scripts/",
+  "format:fix": "biome format --write src/ scripts/"
+}
+```
+
+### 4. CI Pipeline
+
+Add build + quality checks before release:
+
+```yaml
+# .github/workflows/ci.yml
+name: CI
+on: [push, pull_request]
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+      - run: npm install
+      - run: npm run typecheck
+      - run: npm run lint
+      - run: npm run lint:unused
+```
+
+Update `release.yml` to run checks before release:
+
+```yaml
+- run: npm install
+- run: npm run typecheck
+- run: npm run lint
+- run: npm run lint:unused
+- name: Release
+  run: npx semantic-release
+```
+
+### 5. Recommended package.json Scripts
+
+```json
+{
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check src/ scripts/",
+    "lint:fix": "biome check --write src/ scripts/",
+    "lint:unused": "knip",
+    "format": "biome format --check src/ scripts/",
+    "format:fix": "biome format --write src/ scripts/",
+    "check": "npm run typecheck && npm run lint && npm run lint:unused && npm run format"
+  }
+}
+```
+
+### 6. Priority Order
+
+1. **Knip** (immediate) - find and remove dead code
+2. **Biome** (immediate) - consistent lint + format
+3. **CI pipeline** (immediate) - prevent regressions
+4. **TypeScript strict** (next) - may require fixes
+5. **Vitest** (later) - when test coverage becomes a priority

package/.cursor/skills/deco-start-architecture/gap-analysis.md

@@ -0,0 +1,129 @@
+# Gap Analysis: deco-cx/deco vs @decocms/start
+
+Feature-by-feature comparison with implementation status and roadmap.
+
+## Status Summary
+
+| Status | Count | Meaning |
+|--------|-------|---------|
+| PORTED | 24 | Fully implemented and working |
+| PARTIAL | 5 | Exists but incomplete |
+| MISSING | 4 | Not yet ported |
+| NOT NEEDED | 4 | Architectural difference |
+
+## Feature Comparison Table
+
+| # | Feature | Status |
+|---|---------|--------|
+| 1 | Resolution engine | PORTED (generic resolver with memoization, depth protection, DanglingReference handler, select support) |
+| 2 | Sections | PORTED (registry + DecoPageRenderer) |
+| 3 | Loaders | PORTED (registerCommerceLoader) |
+| 4 | Actions | PORTED (via invoke handler) |
+| 5 | Handlers | NOT NEEDED (TanStack Router) |
+| 6 | Flags | PORTED (multivariate in resolve.ts) |
+| 7 | Matchers | PORTED (12 matchers registered) |
+| 8 | Apps | NOT NEEDED (npm packages) |
+| 9 | Workflows | MISSING |
+| 10 | /live/invoke | PORTED |
+| 11 | /deco/render | NOT NEEDED (TanStack Query) |
+| 12 | /live/_meta | PORTED |
+| 13 | /live/release | MISSING |
+| 14 | /.decofile | PORTED |
+| 15 | /live/inspect | MISSING |
+| 16 | /live/previews | PORTED |
+| 17 | /styles.css | NOT NEEDED (Vite) |
+| 18 | /deco/_liveness + /deco/_health | PORTED (liveness + detailed health with uptime, memory, request counts, cache stats) |
+| 19 | CORS middleware | PORTED |
+| 20 | Cache-control | PORTED |
+| 21 | Segment | PORTED |
+| 22 | Observability | PORTED (TracerAdapter + MeterAdapter, named metrics, context propagation, request/cache recording) |
+| 23 | useSection | PARTIAL (stub) |
+| 24 | usePartialSection | PARTIAL (stub) |
+| 25 | useScript | PORTED (with lightweight minification + LRU cache) |
+| 26 | useDevice | PORTED (server-side via User-Agent + RequestContext, detectDevice, checkMobile/Tablet/Desktop) |
+| 27 | useSetEarlyHints | MISSING |
+| 28 | LiveControls | PORTED |
+| 29 | SectionContext | MISSING |
+| 30 | ErrorBoundary | PORTED |
+| 31 | LazySection | PORTED |
+| 32 | Schema generation | PORTED (dynamic registries for loaders + matchers, runtime composition) |
+| 33 | Client invoke | PARTIAL (no withManifest, no SSE) |
+| 34 | DecofileProvider | PORTED (revision tracking, onChange callbacks, hot-reload with cache invalidation) |
+| 35 | Caching | PARTIAL (no LRU/Redis/tiered) |
+| 36 | Edge caching | PORTED (unique to deco-start) |
+| 37 | Manifest generation | PARTIAL (generate-blocks.ts) |
+
+## Implemented Roadmap
+
+### Tier 0 -- Production Blocking: ALL DONE
+1. VTEX proxy routes
+2. VTEX middleware (segment + login-aware cache)
+3. Redirect system
+4. Sitemap generation
+5. SEO JSON-LD components
+
+### Tier 1 -- Quality: ALL DONE
+6. Segment-aware cache keys
+7. Priority matchers (cookie, pathname, cron, host, queryString)
+8. Top searches + search validator
+9. Product extension pipeline
+10. LazySection component
+11. UTM param stripping + canonical URLs
+12. wrapCaughtErrors
+13. CSP headers
+14. Cache-Control merge
+
+### Tier 2 -- DX and Completeness: ALL DONE
+15. Schema gen improvements
+16. Client-side hooks (useCart, useUser, useWishlist) in apps-start
+17. Image/Picture components in apps-start
+18. RequestContext (AsyncLocalStorage)
+19. Commerce loader request context
+20. Remaining VTEX loaders in apps-start
+21. Admin schema composition (composeMeta)
+
+### Tier 2.5 -- Framework Improvements (PR #3): ALL DONE
+22. Dynamic schema registries (loaders + matchers) — no more hardcoded KNOWN_LOADERS
+23. Generic recursive resolver with memoization, depth protection, DanglingReference
+24. useDevice server-side (User-Agent + RequestContext)
+25. Health probe `/deco/_health` with uptime, memory, cache stats, request metrics
+26. Enhanced observability: MeterAdapter, MetricNames, context propagation
+27. Enhanced invoke: FormData/URLEncoded parsing, `?select=`, actions, nested `__resolveType`
+28. Decofile revision tracking + onChange listeners + meta auto-invalidation
+29. useScript minification + LRU cache
+
+### Tier 3 -- Future / Deferred
+30. Admin live preview (WebSocket)
+31. Hot reload authenticated endpoint
+32. SSE streaming reader
+33. sectionMiddleware / transformProps
+34. Shopify draft order, proxy routes
+35. Geo/location matchers
+
+## Intentional Divergences
+
+| deco-cx/deco | @decocms/start | Reason |
+|-------------|----------------|--------|
+| Section loader/action exports | Pure React components | Idiomatic React |
+| HTMX partials | TanStack Query + Router | React reconciliation |
+| Fresh islands | Full React SPA + SSR | TanStack Start model |
+| Deno runtime | Node.js / CF Workers | Deployment target |
+| Import maps | npm packages | Standard resolution |
+| Global fetch monkey-patch | Explicit instrumented fetch | Predictable |
+| Per-loader Vary | Segment cache keys | Simpler, CF Cache API |
+
+## Unique to @decocms/start
+
+| Feature | Description |
+|---------|-------------|
+| Cloudflare Workers | createDecoWorkerEntry with Cache API |
+| Edge caching profiles | detectCacheProfile, URL-based TTL rules |
+| invokeQueryOptions | TanStack Query integration |
+| LazySection (IntersectionObserver) | Client-side lazy loading |
+| PostHog matchers | Server-side feature flags |
+| Sitemap/Redirects SDK | Built-in utilities |
+| Dynamic schema registries | Runtime loader/matcher registration (no hardcoded lists) |
+| Health metrics endpoint | `/deco/_health` with uptime, memory, cache stats |
+| Pluggable MeterAdapter | Counter/gauge/histogram abstraction for any metrics backend |
+| useScript minification | Lightweight JS minification with LRU cache |
+| Decofile revision tracking | Content-hash based revisions with onChange callbacks |

package/.cursor/skills/deco-start-architecture/sdk-utilities.md

@@ -0,0 +1,197 @@
+# SDK Utilities
+
+All utilities exported from `@decocms/start/sdk/*`.
+
+## useScript (`sdk/useScript.ts`)
+
+Serialize functions as inline scripts for SSR with lightweight minification:
+
+```typescript
+function useScript<T extends (...args: any[]) => void>(fn: T, ...args: Parameters<T>): string
+function useScriptAsDataURI<T extends (...args: any[]) => void>(fn: T, ...args: Parameters<T>): string
+```
+
+Features:
+- **Minification**: `minifyJs()` removes comments (single-line + multi-line), collapses whitespace, trims lines
+- **LRU Cache**: Minified function bodies are cached (128 entries) to avoid redundant work across renders
+- Properly typed with generic constraints on function parameters
+
+Also exports stubs for partial section support:
+
+```typescript
+function usePartialSection<T>(options: { props?: Partial<T> }): Record<string, string>
+function useSection<T>(options: { props?: Partial<T> }): string
+```
+
+Note: These are stubs. Use TanStack Query + Router navigation instead.
+
+## useDevice (`sdk/useDevice.ts`)
+
+Server-side device detection based on User-Agent via RequestContext:
+
+```typescript
+type Device = "mobile" | "tablet" | "desktop";
+
+function detectDevice(userAgent: string | null): Device     // Pure function, no context needed
+function useDevice(): Device                                  // Hook using RequestContext
+function checkMobile(): boolean                               // Direct context access
+function checkTablet(): boolean                               // Direct context access
+function checkDesktop(): boolean                              // Direct context access
+```
+
+- `detectDevice` is a standalone pure function (usable in middleware, workers, etc.)
+- `useDevice` reads from `RequestContext.current` (server-side via AsyncLocalStorage)
+- `checkMobile`/`checkTablet`/`checkDesktop` access `RequestContext` directly (not hooks)
+
+Export path: `@decocms/start/sdk/useDevice`
+
+## Signal (`sdk/signal.ts`)
+
+Reactive signal replacing `@preact/signals`, backed by `@tanstack/store`:
+
+```typescript
+function signal<T>(initialValue: T): ReactiveSignal<T>
+```
+
+## Analytics (`sdk/analytics.ts`)
+
+Client-side event tracking via `data-event` attributes:
+
+```typescript
+function useSendEvent(events: AnalyticsEvent[]): string
+const ANALYTICS_SCRIPT: string
+function gtmScript(containerId: string): string
+```
+
+## Cookie (`sdk/cookie.ts`)
+
+Universal cookie utilities:
+
+```typescript
+function getCookie(name: string): string | undefined        // client
+function setCookie(name: string, value: string, opts?): void // client
+function deleteCookie(name: string): void                    // client
+function getServerSideCookie(header: string, name: string): string | undefined
+function decodeCookie(value: string): string
+```
+
+## Invoke (`sdk/invoke.ts`)
+
+Client-side RPC proxy for calling server loaders:
+
+```typescript
+function createInvokeProxy<T>(baseUrl?: string): InvokeProxy<T>
+function batchInvoke(calls: InvokeCall[]): Promise<any[]>
+function invokeQueryOptions(key: string, props?: any): UseQueryOptions
+```
+
+Integrates with TanStack Query: `useQuery(invokeQueryOptions("vtex/loaders/productList.ts", { query }))`.
+
+## Redirects (`sdk/redirects.ts`)
+
+CMS-managed redirect system supporting CMS blocks and CSV import:
+
+```typescript
+function loadRedirects(blocks: Record<string, any>): Map<string, Redirect>
+function matchRedirect(path: string, redirects: Map): Redirect | null
+function parseRedirectsCsv(csv: string): Redirect[]
+function addRedirects(redirects: Redirect[]): void
+```
+
+## Sitemap (`sdk/sitemap.ts`)
+
+XML sitemap generation:
+
+```typescript
+function getCMSSitemapEntries(blocks: Record<string, any>): SitemapEntry[]
+function generateSitemapXml(entries: SitemapEntry[]): string
+function generateSitemapIndexXml(sitemaps: string[]): string
+```
+
+## RequestContext (`sdk/requestContext.ts`)
+
+AsyncLocalStorage-based per-request context:
+
+```typescript
+const RequestContext: {
+  bind<T>(data: RequestContextData, fn: () => T): T;
+  get(): RequestContextData | undefined;
+}
+```
+
+## Server Timings (`sdk/serverTimings.ts`)
+
+HTTP Server-Timing header utility.
+
+## Instrumented Fetch (`sdk/instrumentedFetch.ts`)
+
+Fetch wrapper with logging and tracing:
+
+```typescript
+function createInstrumentedFetch(options?: { tracer?: Tracer }): typeof fetch
+function instrumentFetch(tracer?: Tracer): void
+```
+
+## Observability (`middleware/observability.ts`)
+
+Pluggable tracing and metrics infrastructure:
+
+```typescript
+// Tracer (existing)
+interface TracerAdapter { startSpan(name, fn): T; activeSpan(): Span | undefined }
+function configureTracer(tracer: TracerAdapter): void
+function withTracing<T>(name: string, fn: () => T): T
+
+// Meter (new)
+interface MeterAdapter {
+  counterInc(name: string, value?: number, labels?: Record<string, string>): void
+  gaugeSet(name: string, value: number, labels?: Record<string, string>): void
+  histogramRecord(name: string, value: number, labels?: Record<string, string>): void
+}
+function configureMeter(meter: MeterAdapter): void
+function getMeter(): MeterAdapter | undefined
+
+// Standardized metric names
+const MetricNames = {
+  HTTP_REQUESTS_TOTAL, HTTP_REQUEST_DURATION, HTTP_INFLIGHT,
+  CACHE_HITS_TOTAL, CACHE_MISSES_TOTAL,
+  RESOLVE_DURATION, RESOLVE_ERRORS, INVOKE_DURATION
+}
+
+// Convenience recorders
+function recordRequestMetric(method, path, status, duration): void
+function recordCacheMetric(hit: boolean, source: string): void
+
+// Enhanced logging
+function logRequest(method, url, status, duration): void  // Includes trace ID if available
+```
+
+## Health Metrics (`middleware/healthMetrics.ts`)
+
+Request tracking and health probe endpoint:
+
+```typescript
+function trackRequest(): { start(): void; end(status: number): void }
+function getHealthMetrics(): HealthMetrics
+function handleHealthCheck(request: Request): Response
+```
+
+`/deco/_health` returns JSON with:
+- `uptime`: seconds since process start
+- `requests`: total, inflight, errors, statusCodes breakdown
+- `cache`: stats from `getLoaderCacheStats()` (hits, misses, size, hitRate)
+- `memory`: RSS, heap total/used (if `process.memoryUsage` available)
+
+Export path: `@decocms/start/middleware/healthMetrics`
+
+## Other Utilities
+
+| Utility | File | Purpose |
+|---------|------|---------|
+| `clx` | `sdk/clx.ts` | CSS class combiner (like `clsx`) |
+| `useId` | `sdk/useId.ts` | React `useId` wrapper |
+| `wrapCaughtErrors` | `sdk/wrapCaughtErrors.ts` | Deferred error proxy for resilient rendering |
+| `setCSPHeaders` | `sdk/csp.ts` | CSP frame-ancestors for admin iframe |
+| `stripTrackingParams` | `sdk/urlUtils.ts` | Remove UTM/tracking params from URLs |
+| `mergeCacheControl` | `sdk/mergeCacheControl.ts` | Merge Cache-Control headers (most restrictive wins) |
+| `createCachedLoader` | `sdk/cachedLoader.ts` | In-memory SWR cache for loaders (with `getLoaderCacheStats()` and `clearLoaderCache()`) |