@woodsportal/hubspot-kit 1.0.41 → 1.0.42-dev.0

package/scripts/generate-cdn-bundle-breakdown.mjs

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+/**
+ * Write docs/audit/CDN-BUNDLE-BREAKDOWN.md from cdn-bundle-visualizer.json (rollup-plugin-visualizer v2).
+ */
+import { existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { findProjectRoot } from './project-root.mjs'
+
+const root = findProjectRoot()
+const jsonPath = resolve(root, 'docs/audit/cdn-bundle-visualizer.json')
+const outPath = resolve(root, 'docs/audit/CDN-BUNDLE-BREAKDOWN.md')
+
+if (!existsSync(jsonPath)) {
+  console.error(
+    `[cdn-breakdown] Missing ${jsonPath} — run: yarn audit:cdn-bundle`,
+  )
+  process.exit(1)
+}
+
+const data = JSON.parse(readFileSync(jsonPath, 'utf8'))
+const { nodeParts = {}, nodeMetas = {} } = data
+
+const leaves = Object.entries(nodeParts)
+  .map(([uid, part]) => {
+    const meta = nodeMetas[uid] ?? {}
+    return {
+      name: meta.id ?? uid,
+      gzipSize: part.gzipSize ?? 0,
+      renderedLength: part.renderedLength ?? 0,
+    }
+  })
+  .filter((n) => n.renderedLength > 0)
+  .sort((a, b) => b.gzipSize - a.gzipSize)
+
+const top = leaves.slice(0, 15)
+const generatedAt = new Date().toISOString()
+
+const lines = [
+  '# CDN app bundle breakdown',
+  '',
+  `Generated: ${generatedAt}`,
+  '',
+  'Source: `yarn audit:cdn-bundle` → `docs/audit/cdn-bundle-visualizer.json`',
+  '',
+  'Top 15 modules by gzip size (CDN app graph):',
+  '',
+  '| Rank | Module | Gzip (KiB) | Raw (KiB) |',
+  '|------|--------|------------|-----------|',
+]
+
+top.forEach((node, i) => {
+  const gzip = node.gzipSize / 1024
+  const raw = node.renderedLength / 1024
+  const name = String(node.name).replace(/\|/g, '\\|')
+  lines.push(`| ${i + 1} | \`${name}\` | ${gzip.toFixed(1)} | ${raw.toFixed(1)} |`)
+})
+
+lines.push('', 'See also: [BUNDLE-STRATEGY.md](../BUNDLE-STRATEGY.md), [artifact-sizes.json](./artifact-sizes.json).')
+
+writeFileSync(outPath, `${lines.join('\n')}\n`)
+console.log(`[cdn-breakdown] wrote ${outPath}`)

package/scripts/generate-cdn-manifest.mjs

@@ -15,7 +15,7 @@ const cdnDir = resolve(root, 'dist/cdn')
 const buildId = portalBuildId()
 
 function fileMetrics(file) {
-  const path = resolve(cdnDir, file)
+  const path = resolve(cdnDir, file.replace(/^\//, ''))
   const raw = readFileSync(path)
   return {
     file,
@@ -24,17 +24,31 @@ function fileMetrics(file) {
   }
 }
 
-const jsFiles = readdirSync(cdnDir)
-  .filter((f) => f.endsWith('.js'))
-  .map((file) => {
+function scriptEntry(file) {
+  if (file.startsWith('vendor.')) {
+    return { name: 'vendor', order: 1, preload: true }
+  }
+  if (file.startsWith('app.') && !file.includes('/')) {
+    return { name: 'app', order: 2, preload: true }
+  }
+  if (file.startsWith('chunks/')) {
+    return { name: file.replace(/^chunks\//, ''), order: 99, preload: false }
+  }
+  return { name: file, order: 99, preload: false }
+}
+
+const jsFiles = readdirSync(cdnDir, { recursive: true })
+  .filter((f) => String(f).endsWith('.js'))
+  .map((rel) => {
+    const file = String(rel)
     const metrics = fileMetrics(file)
+    const entry = scriptEntry(file)
     return {
       ...metrics,
-      name: file.startsWith('vendor.') ? 'vendor' : file.startsWith('app.') ? 'app' : file,
-      order: file.startsWith('vendor.') ? 1 : file.startsWith('app.') ? 2 : 99,
+      ...entry,
     }
   })
-  .sort((a, b) => a.order - b.order)
+  .sort((a, b) => a.order - b.order || a.file.localeCompare(b.file))
 
 const cssFiles = readdirSync(cdnDir)
   .filter((f) => f.endsWith('.css'))
@@ -64,10 +78,11 @@ const manifest = {
   buildId,
   baseUrl: resolveCdnBaseUrl(),
   publishMode: process.env.VITE_PORTAL_CDN_PUBLISH_MODE ?? 'jsdelivr',
-  scripts: jsFiles.map(({ name, file, order, rawBytes, gzipBytes }) => ({
+  scripts: jsFiles.map(({ name, file, order, preload, rawBytes, gzipBytes }) => ({
     name,
     file,
     order,
+    preload,
     rawBytes,
     gzipBytes,
     url: `${resolveCdnBaseUrl()}/${file}`,

package/scripts/portal-vite-env.mjs

@@ -1,17 +1,91 @@
 /**
- * Vite env for HubSpot/CDN builds — .env.[mode] wins over stale shell VITE_* vars.
+ * Vite env for HubSpot/CDN builds — .env.[mode] wins over stale shell / .env.local VITE_* vars.
  */
+import { existsSync, readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
 import { loadEnv } from 'vite'
 import { envWithPortalBuildId } from './resolve-portal-build-id.mjs'
 import { envWithPortalCdnConfig } from './load-portal-cdn-config.mjs'
 
+/** @param {string} content */
+export function parseEnvFile(content) {
+  const result = {}
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim()
+    if (!trimmed || trimmed.startsWith('#')) continue
+    const eq = trimmed.indexOf('=')
+    if (eq <= 0) continue
+    const key = trimmed.slice(0, eq).trim()
+    let value = trimmed.slice(eq + 1).trim()
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1)
+    }
+    result[key] = value
+  }
+  return result
+}
+
+/** @param {'local' | 'dev' | 'stg' | 'prod'} mode @param {string} root */
+export function readPortalTierEnvFile(mode, root) {
+  const path = resolve(root, `.env.${mode}`)
+  if (!existsSync(path)) return {}
+  return parseEnvFile(readFileSync(path, 'utf8'))
+}
+
+function stashViteProcessEnv() {
+  const stashed = {}
+  for (const key of Object.keys(process.env)) {
+    if (key.startsWith('VITE_')) {
+      stashed[key] = process.env[key]
+      delete process.env[key]
+    }
+  }
+  return stashed
+}
+
+/** @param {Record<string, string | undefined>} stashed */
+function restoreViteProcessEnv(stashed) {
+  for (const [key, value] of Object.entries(stashed)) {
+    if (value != null) process.env[key] = value
+  }
+}
+
+/** loadEnv without shell / .env.local VITE_* polluting tier resolution */
+/** @param {'local' | 'dev' | 'stg' | 'prod'} mode @param {string} root */
+export function loadPortalFileEnv(mode, root) {
+  const stashed = stashViteProcessEnv()
+  try {
+    return loadEnv(mode, root, '')
+  } finally {
+    restoreViteProcessEnv(stashed)
+  }
+}
+
+/**
+ * API URL baked into CDN bundles for a deploy tier — reads `.env.[mode]` only.
+ * @param {'local' | 'dev' | 'stg' | 'prod'} mode
+ * @param {string} root
+ */
+export function resolveTierApiEndpoint(mode, root) {
+  const tier = readPortalTierEnvFile(mode, root)
+  const fromTier = tier.VITE_PUBLIC_REST_API_ENDPOINT
+  if (fromTier) return fromTier.replace(/\/$/, '')
+  const fromFile = loadPortalFileEnv(mode, root).VITE_PUBLIC_REST_API_ENDPOINT
+  const fromCi =
+    process.env.WOODPORTAL_API_BASE_URL || process.env.VITE_PUBLIC_REST_API_ENDPOINT
+  return (fromFile || fromCi)?.replace(/\/$/, '')
+}
+
 /**
  * @param {'local' | 'dev' | 'stg' | 'prod'} mode
  * @param {string} root
  * @param {NodeJS.ProcessEnv} [extra]
  */
 export function envForPortalBuild(mode, root, extra = {}) {
-  const fileEnv = loadEnv(mode, root, '')
+  const fileEnv = loadPortalFileEnv(mode, root)
   const base = { ...process.env }
 
   for (const key of Object.keys(base)) {

package/scripts/publish-cdn-github.mjs

@@ -98,6 +98,9 @@ function authRemote(remote, token) {
 function copyCdnArtifacts(sourceDir, targetDir) {
   mkdirSync(targetDir, { recursive: true })
   for (const entry of readdirSync(sourceDir)) {
+    if (entry.endsWith('.map')) {
+      fail(`Refusing to publish source map: ${entry}`)
+    }
     const src = join(sourceDir, entry)
     const dest = join(targetDir, entry)
     rmSync(dest, { recursive: true, force: true })
@@ -152,22 +155,81 @@ async function assertGithubRepoPublic(github) {
   }
 }
 
-async function checkJsDelivr(config, vendorFile, appFile, appCssFile) {
-  const base = jsDelivrBaseUrl(config.github, config.cdnPathInRepo, config.defaultBranch)
-  for (const file of [appCssFile, vendorFile, appFile]) {
-    const url = `${base}/${file}`
-    log(`Checking jsDelivr (may take a minute on first publish): ${url}`)
-    try {
-      const res = await fetch(url, { method: 'HEAD' })
-      if (res.ok) {
-        log(`  OK ${res.status} ${file}`)
-      } else {
-        log(`  ${file} → HTTP ${res.status} (jsDelivr may still be propagating — wait 5–15 min)`)
+async function headJsDelivrFile(base, file, { required = false } = {}) {
+  const url = `${base}/${file}`
+  log(`Checking jsDelivr (may take a minute on first publish): ${url}`)
+  try {
+    const res = await fetch(url, { method: 'HEAD' })
+    if (res.ok) {
+      log(`  OK ${res.status} ${file}`)
+      return true
+    }
+    const msg = `${file} → HTTP ${res.status}${required ? '' : ' (jsDelivr may still be propagating — wait 5–15 min)'}`
+    if (required) {
+      fail(msg)
+    }
+    log(`  ${msg}`)
+    return false
+  } catch (err) {
+    const msg = `Could not reach jsDelivr for ${file}: ${err.message}`
+    if (required) {
+      fail(msg)
+    }
+    log(`  ${msg}`)
+    return false
+  }
+}
+
+async function headJsDelivrFiles(base, files, { required = false, concurrency = 5 } = {}) {
+  if (files.length === 0) {
+    return { ok: true, failed: [] }
+  }
+  log(`Checking ${files.length} lazy chunk(s) on jsDelivr`)
+  const failed = []
+  for (let i = 0; i < files.length; i += concurrency) {
+    const batch = files.slice(i, i + concurrency)
+    const results = await Promise.all(
+      batch.map(async (file) => {
+        const ok = await headJsDelivrFile(base, file, { required: false })
+        return { file, ok }
+      }),
+    )
+    for (const result of results) {
+      if (!result.ok) {
+        failed.push(result.file)
       }
-    } catch (err) {
-      log(`  Could not reach jsDelivr for ${file}: ${err.message}`)
     }
   }
+  if (failed.length > 0) {
+    const msg = `jsDelivr lazy chunk(s) not reachable: ${failed.join(', ')}`
+    if (required) {
+      fail(msg)
+    }
+    log(`  ${msg}`)
+  }
+  return { ok: failed.length === 0, failed }
+}
+
+async function checkJsDelivr(config, vendorFile, appFile, appCssFile, lazyChunkFiles = []) {
+  const base = jsDelivrBaseUrl(config.github, config.cdnPathInRepo, config.defaultBranch)
+  for (const file of [appCssFile, vendorFile, appFile]) {
+    await headJsDelivrFile(base, file)
+  }
+  if (lazyChunkFiles.length > 0) {
+    await headJsDelivrFiles(base, lazyChunkFiles, { required: true })
+  } else {
+    log('  No lazy chunks/ in manifest — skipping lazy chunk HEAD check')
+  }
+}
+
+function readLazyChunkFilesFromManifest(manifestPath) {
+  if (!existsSync(manifestPath)) {
+    return []
+  }
+  const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'))
+  return (manifest.scripts ?? [])
+    .map((entry) => entry?.file)
+    .filter((file) => typeof file === 'string' && file.startsWith('chunks/'))
 }
 
 const config = loadPortalCdnConfig()
@@ -331,6 +393,9 @@ log('     yarn build:hubspot:prod   # prod API')
 log('  3. yarn upload:hubspot')
 log('  Or: yarn deploy:dev  |  yarn deploy:prod')
 
+const manifestPath = join(sourceCdn, 'manifest.json')
+const lazyChunkFiles = readLazyChunkFilesFromManifest(manifestPath)
+
 if (!skipJsDelivrCheck) {
-  await checkJsDelivr(config, vendorFile, appFile, appCssFile)
+  await checkJsDelivr(config, vendorFile, appFile, appCssFile, lazyChunkFiles)
 }

package/scripts/refresh-artifact-sizes.mjs

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+/**
+ * Refresh docs/audit/artifact-sizes.json from dist/cdn + HubSpot module output.
+ */
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs'
+import { resolve, join } from 'node:path'
+import { gzipSync } from 'node:zlib'
+import { findProjectRoot } from './project-root.mjs'
+import { moduleOutDir, readWoodsportalConfig } from './read-woodsportal-config.mjs'
+
+const root = findProjectRoot()
+const { config } = readWoodsportalConfig(root)
+
+function metrics(path) {
+  const raw = readFileSync(path)
+  const gzip = gzipSync(raw)
+  return {
+    rawBytes: raw.length,
+    gzipBytes: gzip.length,
+    rawMiB: Number((raw.length / (1024 * 1024)).toFixed(3)),
+    gzipKiB: Number((gzip.length / 1024).toFixed(1)),
+    overValidationLimit: raw.length > 1.5 * 1024 * 1024,
+  }
+}
+
+function walkJs(dir, prefix = '') {
+  const out = []
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const rel = prefix ? `${prefix}/${entry.name}` : entry.name
+    const full = join(dir, entry.name)
+    if (entry.isDirectory()) {
+      out.push(...walkJs(full, rel))
+    } else if (entry.name.endsWith('.js')) {
+      out.push(rel)
+    }
+  }
+  return out
+}
+
+const moduleDir = moduleOutDir(root)
+const cdnDir = resolve(root, 'dist/cdn')
+const artifacts = {}
+
+for (const name of ['module.js', 'module.css', 'module.html', 'fields.json']) {
+  const p = resolve(moduleDir, name)
+  if (existsSync(p)) {
+    artifacts[name] = metrics(p)
+  }
+}
+
+const cdn = {}
+if (existsSync(cdnDir)) {
+  let manifest = null
+  const manifestPath = resolve(cdnDir, 'manifest.json')
+  if (existsSync(manifestPath)) {
+    manifest = JSON.parse(readFileSync(manifestPath, 'utf8'))
+    cdn['manifest.json'] = { generatedAt: manifest.generatedAt, buildId: manifest.buildId }
+  }
+  for (const file of walkJs(cdnDir)) {
+    cdn[file] = metrics(resolve(cdnDir, file))
+  }
+  for (const file of readdirSync(cdnDir).filter((f) => f.endsWith('.css'))) {
+    cdn[file] = metrics(resolve(cdnDir, file))
+  }
+}
+
+const doc = {
+  generatedAt: new Date().toISOString(),
+  embedMode: 'cdn',
+  hubspotLimits: { validationMiB: 1.5, bufferMiB: 2 },
+  artifacts,
+  cdn,
+}
+
+const outPath = resolve(root, 'docs/audit/artifact-sizes.json')
+writeFileSync(outPath, JSON.stringify(doc, null, 2))
+console.log(`[artifact-sizes] wrote ${outPath}`)

package/scripts/regenerate-route-tree.mjs

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+/**
+ * Regenerate src/routeTree.gen.ts using the consumer project's @tanstack/router-generator.
+ */
+import { fileURLToPath } from 'node:url'
+import { existsSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+import { findProjectRoot } from './project-root.mjs'
+import { importConsumerDep } from './resolve-consumer-dep.mjs'
+
+/**
+ * @param {string} [projectRoot]
+ * @returns {Promise<{ ok: boolean; warning?: string }>}
+ */
+export async function regenerateRouteTree(projectRoot = findProjectRoot()) {
+  const routesDir = resolve(projectRoot, 'src/routes')
+  const generatedRouteTree = resolve(projectRoot, 'src/routeTree.gen.ts')
+
+  if (!existsSync(routesDir)) {
+    return { ok: false, warning: 'No src/routes directory — skipping route tree regeneration.' }
+  }
+
+  try {
+    const mod = await importConsumerDep('@tanstack/router-generator', projectRoot)
+    const Generator = mod.Generator ?? mod.default?.Generator
+    if (!Generator) {
+      throw new Error('@tanstack/router-generator does not export Generator')
+    }
+
+    const generator = new Generator({
+      routesDirectory: routesDir,
+      generatedRouteTree,
+      target: 'react',
+    })
+
+    if (typeof generator.build === 'function') {
+      await generator.build()
+    } else if (typeof generator.run === 'function') {
+      await generator.run()
+    } else if (typeof generator.generate === 'function') {
+      await generator.generate()
+    } else {
+      throw new Error('Unsupported @tanstack/router-generator API')
+    }
+
+    if (!existsSync(generatedRouteTree)) {
+      throw new Error('Generator finished but routeTree.gen.ts was not written')
+    }
+
+    return { ok: true }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    return {
+      ok: false,
+      warning: `Could not regenerate routeTree.gen.ts (${message}). Restart wp dev to refresh the route tree.`,
+    }
+  }
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  const root = process.argv[2] ?? findProjectRoot()
+  regenerateRouteTree(root).then((result) => {
+    if (result.ok) {
+      process.stdout.write('routeTree.gen.ts regenerated\n')
+      process.exit(0)
+    }
+    process.stderr.write(`${result.warning ?? 'Route tree regeneration failed'}\n`)
+    process.exit(1)
+  })
+}

package/scripts/sync-auth-scaffold-from-client.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+/**
+ * Copy curated auth files from woodsportal-client-frontend into templates/scaffold/auth/.
+ * Usage: node scripts/sync-auth-scaffold-from-client.mjs [--dry-run]
+ */
+import { copyFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const kitRoot = resolve(__dirname, '..')
+const manifestPath = resolve(kitRoot, 'templates/scaffold/auth/sync-manifest.json')
+const dryRun = process.argv.includes('--dry-run')
+
+const manifest = JSON.parse(readFileSync(manifestPath, 'utf8')) as {
+  clientFrontendRoot: string
+  mappings: Array<{ from: string; to: string }>
+}
+
+const clientRoot = resolve(kitRoot, manifest.clientFrontendRoot)
+
+let copied = 0
+for (const { from, to } of manifest.mappings) {
+  const source = resolve(clientRoot, from)
+  const target = resolve(kitRoot, 'templates/scaffold/auth', to)
+  if (!existsSync(source)) {
+    console.warn(`skip missing source: ${from}`)
+    continue
+  }
+  if (dryRun) {
+    console.log(`[dry-run] ${from} -> templates/scaffold/auth/${to}`)
+    copied += 1
+    continue
+  }
+  mkdirSync(dirname(target), { recursive: true })
+  copyFileSync(source, target)
+  console.log(`copied ${to}`)
+  copied += 1
+}
+
+console.log(`${dryRun ? 'would copy' : 'copied'} ${copied} file(s)`)

package/scripts/verify-cdn-api-endpoint.mjs

@@ -13,6 +13,7 @@ import { resolve } from 'node:path'
 import { findProjectRoot } from './project-root.mjs'
 import { resolvePortalBuildId } from './resolve-portal-build-id.mjs'
 import { resolvePortalViteMode } from './portal-env-mode.mjs'
+import { resolveTierApiEndpoint } from './portal-vite-env.mjs'
 
 const root = findProjectRoot()
 
@@ -29,15 +30,11 @@ if (tierFlags.length !== 1) {
 }
 
 const mode = resolvePortalViteMode()
-const { loadEnv } = await import('vite')
-const fromFile = loadEnv(mode, root, '').VITE_PUBLIC_REST_API_ENDPOINT
-const fromEnv =
-  process.env.VITE_PUBLIC_REST_API_ENDPOINT || process.env.WOODPORTAL_API_BASE_URL
-const expected = (fromFile || fromEnv)?.replace(/\/$/, '')
+const expected = resolveTierApiEndpoint(mode, root)
 
 if (!expected) {
   console.error(
-    `[verify-cdn-api] Missing VITE_PUBLIC_REST_API_ENDPOINT in .env.${mode} (or VITE_PUBLIC_REST_API_ENDPOINT / WOODPORTAL_API_BASE_URL env)`,
+    `[verify-cdn-api] Missing VITE_PUBLIC_REST_API_ENDPOINT in .env.${mode} (or WOODPORTAL_API_BASE_URL for CI)`,
   )
   process.exit(1)
 }
@@ -59,13 +56,23 @@ if (!appFile) {
 }
 
 const source = readFileSync(resolve(cdnDir, appFile), 'utf8')
-const found = [...source.matchAll(/https:\/\/api(?:\.dev)?\.woodsportal\.com/g)].map((m) => m[0])
-const unique = [...new Set(found)]
+const bakedUrls = [
+  ...source.matchAll(/https:\/\/api(?:\.dev)?\.woodsportal\.com/g),
+  ...source.matchAll(/http:\/\/localhost:\d+/g),
+].map((m) => m[0])
+const unique = [...new Set(bakedUrls)]
 
-if (!unique.includes(expected)) {
+if (!source.includes(expected)) {
   console.error('[verify-cdn-api] API URL mismatch in dist/cdn — refusing to publish.')
-  console.error(`  expected (${mode}): ${expected}`)
+  console.error(`  expected from .env.${mode}: ${expected}`)
   console.error(`  found in ${appFile}: ${unique.join(', ') || '(none)'}`)
+  const shellApi = process.env.VITE_PUBLIC_REST_API_ENDPOINT
+  if (shellApi && shellApi.replace(/\/$/, '') !== expected) {
+    console.error('')
+    console.error(
+      `  Note: shell/.env.local has VITE_PUBLIC_REST_API_ENDPOINT=${shellApi} — ignored for deploy; CDN uses .env.${mode} only.`,
+    )
+  }
   console.error('')
   console.error('  Dev API on HubSpot:  yarn deploy:dev')
   console.error('  Prod API on HubSpot: yarn deploy:prod')

package/scripts/vite/create-dev-server-config.mjs

@@ -67,7 +67,13 @@ export async function createDevServerViteConfig(options = {}) {
         ...prefixPlugins,
       ],
       resolve: {
-        dedupe: ['react', 'react-dom'],
+        dedupe: [
+          'react',
+          'react-dom',
+          'woodsportal-client-sdk',
+          'woodsportal-client-sdk/auth',
+          'woodsportal-client-sdk/crm',
+        ],
         alias: {
           ...consumerReactAliases(projectRoot),
           '@/dev/module-config': moduleConfigRoot,

package/scripts/vite/portal-build-shared.js

@@ -38,7 +38,7 @@ function prodDevModuleConfigRouteStub(mode) {
   if (!isPrefix(mode)) {
     return null
   }
-  const stub = resolve(root, 'src/routes/dev.module-config.prod-stub.tsx')
+  const stub = resolve(root, 'src/stubs/dev.module-config.cdn-route-stub.tsx')
   return {
     name: 'woodsportal-prod-dev-route-stub',
     enforce: 'pre',
@@ -55,6 +55,62 @@ function prodDevModuleConfigRouteStub(mode) {
   }
 }
 
+function prodResolveIdStub(mode, { name, matchers, stub }) {
+  if (!isPrefix(mode)) {
+    return null
+  }
+  return {
+    name,
+    enforce: 'pre',
+    resolveId(source) {
+      for (const match of matchers) {
+        if (typeof match === 'string' ? source === match || source.endsWith(match) : match.test(source)) {
+          return stub
+        }
+      }
+      return null
+    },
+  }
+}
+
+function prodDevHubSpotLiveStub(mode) {
+  if (!isPrefix(mode)) {
+    return null
+  }
+  const liveStub = resolve(root, 'src/integrations/dev-hubspot-live-provider.prod-stub.tsx')
+  const syncStub = resolve(root, 'src/data/dev-hubspot-sync.prod-stub.ts')
+  return {
+    name: 'woodsportal-prod-dev-hubspot-live-stub',
+    enforce: 'pre',
+    resolveId(source) {
+      if (
+        source === '@/integrations/dev-hubspot-live-provider' ||
+        /\/integrations\/dev-hubspot-live-provider(\.tsx)?$/.test(source)
+      ) {
+        return liveStub
+      }
+      if (
+        source === '@/data/dev-hubspot-sync' ||
+        /\/data\/dev-hubspot-sync(\.ts)?$/.test(source)
+      ) {
+        return syncStub
+      }
+      return null
+    },
+  }
+}
+
+function prodSdkTerminalLogSinksStub(mode) {
+  return prodResolveIdStub(mode, {
+    name: 'woodsportal-prod-sdk-log-sinks-stub',
+    matchers: [
+      '@/integrations/sdk-terminal-log-sinks',
+      /\/integrations\/sdk-terminal-log-sinks(\.ts)?$/,
+    ],
+    stub: resolve(root, 'src/integrations/sdk-terminal-log-sinks.prod-stub.ts'),
+  })
+}
+
 /** Ship CDN builds must not bundle localhost fixture menus from src/fixtures/demo-menu.ts */
 function prodDefaultDataStub(mode) {
   if (!isPrefix(mode)) {
@@ -81,6 +137,8 @@ export function portalPlugins(mode, { codeSplitting = false, routeFileIgnorePatt
   const routeIgnore = routeFileIgnorePattern ?? (isPrefix(mode) ? 'dev\\.' : undefined)
   return [
     prodDevModuleConfigRouteStub(mode),
+    prodDevHubSpotLiveStub(mode),
+    prodSdkTerminalLogSinksStub(mode),
     prodDefaultDataStub(mode),
     TanStackRouterVite({
       autoCodeSplitting: codeSplitting,
@@ -129,7 +187,9 @@ export function portalResolve(mode) {
     })
   }
 
-  return { alias }
+  const dedupe = ['axios', 'pako', 'js-cookie']
+
+  return { alias, dedupe }
 }
 
 export { root, __dirname }