@pyreon/zero 0.24.5 → 0.24.6

package/src/adapters/index.ts

@@ -1,61 +0,0 @@
-export { bunAdapter } from './bun'
-export { cloudflareAdapter } from './cloudflare'
-export { netlifyAdapter } from './netlify'
-export { nodeAdapter } from './node'
-export { staticAdapter } from './static'
-export { vercelAdapter } from './vercel'
-
-import type { Adapter, ZeroConfig } from '../types'
-import { bunAdapter } from './bun'
-import { cloudflareAdapter } from './cloudflare'
-import { netlifyAdapter } from './netlify'
-import { nodeAdapter } from './node'
-import { staticAdapter } from './static'
-import { vercelAdapter } from './vercel'
-
-/**
- * Resolve the adapter from config.
- * Returns a built-in adapter or throws if unknown.
- *
- * Accepts BOTH forms — the `ZeroConfig.adapter` type advertises string
- * names (`'vercel'` / `'cloudflare'` / …) but the scaffolded templates
- * historically emit `adapter: vercelAdapter()` (an Adapter instance via
- * the named factory). Both work: a string goes through the switch lookup;
- * an Adapter object (duck-typed via `name` + `build` fields) passes
- * through. Pre-PR-J `resolveAdapter` was never called from production
- * code so the string-vs-object mismatch was invisible; PR J wires the
- * call into `ssgPlugin.closeBundle`, surfacing the contract divergence.
- * The passthrough preserves both shapes without a breaking type change.
- */
-export function resolveAdapter(config: ZeroConfig): Adapter {
-  const value = config.adapter ?? 'node'
-
-  // Passthrough for already-constructed Adapter instances. Scaffolded
-  // templates emit `adapter: vercelAdapter()` — detect by duck-typing
-  // the two required Adapter fields (`name: string` + `build: function`).
-  if (
-    typeof value === 'object'
-    && value !== null
-    && typeof (value as Adapter).name === 'string'
-    && typeof (value as Adapter).build === 'function'
-  ) {
-    return value as Adapter
-  }
-
-  switch (value) {
-    case 'node':
-      return nodeAdapter()
-    case 'bun':
-      return bunAdapter()
-    case 'static':
-      return staticAdapter()
-    case 'vercel':
-      return vercelAdapter()
-    case 'cloudflare':
-      return cloudflareAdapter()
-    case 'netlify':
-      return netlifyAdapter()
-    default:
-      throw new Error(`[Pyreon] Unknown adapter: "${String(value)}". Use "node", "bun", "static", "vercel", "cloudflare", or "netlify".`)
-  }
-}

package/src/adapters/netlify.ts

@@ -1,154 +0,0 @@
-import type { Adapter, AdapterBuildOptions, AdapterRevalidateResult } from '../types'
-import { validateBuildInputs } from './validate'
-import { warnMissingEnv } from './warn-missing-env'
-
-/**
- * Netlify adapter — generates output for Netlify Functions (v2).
- *
- * Produces:
- * - Client assets in `publish/` directory
- * - `netlify/functions/ssr.mjs` — Netlify Function for SSR
- * - `netlify.toml` — routing configuration
- *
- * @example
- * ```ts
- * // zero.config.ts
- * import { defineConfig } from "@pyreon/zero"
- *
- * export default defineConfig({
- *   adapter: "netlify",
- * })
- * ```
- */
-export function netlifyAdapter(): Adapter {
-  return {
-    name: 'netlify',
-    async build(options: AdapterBuildOptions) {
-      if (options.kind === 'ssg') {
-        // PR J — SSG branch. Emit `netlify.toml` with `publish = "."`
-        // (the dist root) and asset-cache headers — no functions. Tells
-        // Netlify "this dist directory IS the publishable output, serve
-        // it as a static site". Without this file, Netlify falls back
-        // to whatever the user has at the repo root (might miss the
-        // dist/ direct-upload shape).
-        //
-        // PR B's `dist/_redirects` (loader-redirect manifest) is
-        // emitted by ssgPlugin BEFORE the adapter runs, so this branch
-        // doesn't need to write it. The two files coexist cleanly —
-        // Netlify reads both.
-        const { writeFile } = await import('node:fs/promises')
-        const { join } = await import('node:path')
-        const toml = `[build]
-  publish = "."
-
-[[headers]]
-  for = "/assets/*"
-  [headers.values]
-    Cache-Control = "public, max-age=31536000, immutable"
-`
-        await writeFile(join(options.outDir, 'netlify.toml'), toml)
-        return
-      }
-      await validateBuildInputs(options)
-      const { writeFile, cp, mkdir } = await import('node:fs/promises')
-      const { join } = await import('node:path')
-
-      const outDir = options.outDir
-      const publishDir = join(outDir, 'publish')
-      const functionsDir = join(outDir, 'netlify', 'functions')
-
-      await mkdir(publishDir, { recursive: true })
-      await mkdir(functionsDir, { recursive: true })
-
-      // Copy client assets to publish/
-      await cp(options.clientOutDir, publishDir, { recursive: true })
-
-      // Copy server build to functions directory
-      await cp(join(options.serverEntry, '..'), join(functionsDir, '_server'), {
-        recursive: true,
-      })
-
-      // Generate Netlify Function (v2 format — ESM, Web-standard Request/Response).
-      const funcEntry = `
-import handler from "./_server/entry-server.js"
-
-export default async function(req, context) {
-  try {
-    return await handler(req)
-  } catch (err) {
-    // Surface the error to Netlify Function logs so production
-    // crashes give real diagnostic info — pre-fix the catch
-    // swallowed \`err\` entirely and the operator saw only a
-    // bare "Internal Server Error". \`console.error\` lands in
-    // Netlify's function runtime logs panel + \`netlify functions:log\`.
-    console.error("[Pyreon SSR] handler failed:", err)
-    return new Response("Internal Server Error", { status: 500 })
-  }
-}
-
-export const config = {
-  path: "/*",
-  preferStatic: true,
-}
-`.trimStart()
-
-      await writeFile(join(functionsDir, 'ssr.mjs'), funcEntry)
-
-      // Generate netlify.toml
-      const toml = `
-[build]
-  publish = "publish"
-  functions = "netlify/functions"
-
-[[headers]]
-  for = "/assets/*"
-  [headers.values]
-    Cache-Control = "public, max-age=31536000, immutable"
-
-[[redirects]]
-  from = "/*"
-  to = "/.netlify/functions/ssr"
-  status = 200
-  conditions = {Role = ["admin", "user", ""]}
-`.trimStart()
-
-      await writeFile(join(outDir, 'netlify.toml'), toml)
-    },
-    async revalidate(path: string): Promise<AdapterRevalidateResult> {
-      // Netlify ISR via Build Hook trigger. Reads
-      // `NETLIFY_BUILD_HOOK_URL` from env (created in Site settings →
-      // Build hooks). Posting to the hook triggers a partial rebuild
-      // — Netlify rebuilds only the pages whose source has changed
-      // since last deploy. The path arg is included as a `trigger_title`
-      // for audit traceability in the Netlify deploy log; Netlify
-      // doesn't accept per-path revalidation natively (the hook
-      // re-runs the full build).
-      //
-      // Reference: https://docs.netlify.com/configure-builds/build-hooks/
-      const hookUrl = process.env.NETLIFY_BUILD_HOOK_URL
-      if (!hookUrl) {
-        // M2.4 — warn even in production (dedupe per process). See vercel.ts
-        // for the rationale.
-        return warnMissingEnv(
-          'netlify',
-          ['NETLIFY_BUILD_HOOK_URL'],
-          'Create a build hook in Site settings → Build & deploy → Build hooks → Add build hook. Note: Netlify Build Hooks trigger a FULL site rebuild — the path arg is recorded as `trigger_title` for audit traceability but Netlify doesn\'t support per-page ISR natively.',
-        )
-      }
-      try {
-        const triggerTitle = `revalidate:${path}`
-        const res = await fetch(`${hookUrl}?trigger_title=${encodeURIComponent(triggerTitle)}`, {
-          method: 'POST',
-        })
-        return { regenerated: res.ok }
-      } catch (err) {
-        if (process.env.NODE_ENV !== 'production') {
-          console.warn(
-            `[Pyreon] netlifyAdapter.revalidate(${path}) failed: ${err instanceof Error ? err.message : String(err)}`,
-          )
-        }
-        return { regenerated: false }
-      }
-    },
-  }
-}

package/src/adapters/node.ts

@@ -1,163 +0,0 @@
-import type { Adapter, AdapterBuildOptions, AdapterRevalidateResult } from '../types'
-import { validateBuildInputs } from './validate'
-
-/**
- * Node.js adapter — generates a standalone server entry using node:http.
- *
- * **SSG mode (PR J)**: no-op. Node adapter exists for serving the SSR
- * runtime; SSG output is already complete static HTML — serve it with
- * any static-file server (`bun preview` / nginx / Caddy / `npx serve`).
- * Use `staticAdapter()` if you want explicit SSG semantics.
- */
-export function nodeAdapter(): Adapter {
-  return {
-    name: 'node',
-    async build(options: AdapterBuildOptions) {
-      if (options.kind === 'ssg') {
-        // Node runner has nothing to add for prerendered SSG dist.
-        return
-      }
-      await validateBuildInputs(options)
-      const { writeFile, cp, mkdir } = await import('node:fs/promises')
-      const { join } = await import('node:path')
-
-      const outDir = options.outDir
-      await mkdir(outDir, { recursive: true })
-
-      // Copy server and client builds
-      await cp(options.clientOutDir, join(outDir, 'client'), {
-        recursive: true,
-      })
-      await cp(join(options.serverEntry, '..'), join(outDir, 'server'), {
-        recursive: true,
-      })
-
-      // Generate standalone server entry
-      const port = options.config.port ?? 3000
-      const serverEntry = `
-import { createServer } from "node:http"
-import { readFile } from "node:fs/promises"
-import { join, extname } from "node:path"
-import { fileURLToPath } from "node:url"
-
-const __dirname = fileURLToPath(new URL(".", import.meta.url))
-const handler = (await import("./server/entry-server.js")).default
-const clientDir = join(__dirname, "client")
-
-const MIME_TYPES = {
-  ".html": "text/html",
-  ".js": "application/javascript",
-  ".css": "text/css",
-  ".json": "application/json",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".svg": "image/svg+xml",
-  ".woff2": "font/woff2",
-  ".woff": "font/woff",
-  ".ico": "image/x-icon",
-}
-
-const server = createServer(async (req, res) => {
-  const url = new URL(req.url ?? "/", "http://localhost")
-
-  // Try to serve static files first (GET only).
-  if (req.method === "GET") {
-    try {
-      const filePath = join(clientDir, url.pathname === "/" ? "index.html" : url.pathname)
-      // Prevent path traversal — ensure resolved path stays within clientDir.
-      const { resolve } = await import("node:path")
-      const resolved = resolve(filePath)
-      if (!resolved.startsWith(resolve(clientDir))) {
-        res.writeHead(403)
-        res.end("Forbidden")
-        return
-      }
-      const ext = extname(filePath)
-      // Pre-fix shape was \`if (ext && ext !== ".html")\` which made the
-      // static branch silently refuse to serve .html files — INCLUDING
-      // the root \`/\` → \`index.html\` mapping the line above explicitly
-      // sets up. Result: GET / always fell through to SSR, even when an
-      // \`index.html\` shell existed in clientDir. Matches the bun
-      // adapter's behavior (which serves index.html at /) and the
-      // standard static + dynamic deployment pattern.
-      if (ext) {
-        const data = await readFile(filePath)
-        const mime = MIME_TYPES[ext] || "application/octet-stream"
-        res.writeHead(200, {
-          "content-type": mime,
-          "cache-control": ext === ".js" || ext === ".css"
-            ? "public, max-age=31536000, immutable"
-            : "public, max-age=3600",
-        })
-        res.end(data)
-        return
-      }
-    } catch {}
-  }
-
-  // Fall through to SSR handler.
-  const headers = {}
-  for (const [key, value] of Object.entries(req.headers)) {
-    if (value) headers[key] = Array.isArray(value) ? value.join(", ") : value
-  }
-
-  const request = new Request(url.href, {
-    method: req.method,
-    headers,
-  })
-
-  const response = await handler(request)
-
-  const responseHeaders = {}
-  response.headers.forEach((v, k) => { responseHeaders[k] = v })
-
-  res.writeHead(response.status, responseHeaders)
-
-  // Pipe the Response body stream directly to res instead of buffering
-  // the whole body via response.text(). For mode: 'stream' SSR (Suspense
-  // out-of-order streaming) the pre-fix \`await response.text()\` drained
-  // every Suspense chunk server-side and arrived at the client all at
-  // once at the end — silently defeating streaming. For mode: 'string'
-  // the body is a single chunk and this loop runs once with identical
-  // observable behaviour.
-  if (response.body) {
-    const reader = response.body.getReader()
-    try {
-      while (true) {
-        const { value, done } = await reader.read()
-        if (done) break
-        res.write(value)
-      }
-    } finally {
-      res.end()
-    }
-  } else {
-    res.end()
-  }
-})
-
-server.listen(${port}, () => {
-  console.log("\\n  ⚡ Zero production server running on http://localhost:${port}\\n")
-})
-`.trimStart()
-
-      await writeFile(join(outDir, 'index.js'), serverEntry)
-      await writeFile(join(outDir, 'package.json'), JSON.stringify({ type: 'module' }, null, 2))
-    },
-    async revalidate(_path: string): Promise<AdapterRevalidateResult> {
-      // Self-hosted Node has no platform-driven ISR. Real ISR support
-      // requires a reverse-proxy cache (nginx/varnish) + your own
-      // cache-purge wiring, OR mode: 'isr' for runtime LRU caching.
-      // This no-op preserves the Adapter API contract; user code that
-      // calls `adapter.revalidate(path)` against a self-hosted Node
-      // deploy gets the same `regenerated: false` shape as the static
-      // adapter, so migrating between adapters doesn't surprise.
-      if (process.env.NODE_ENV !== 'production') {
-        console.warn(
-          '[Pyreon] nodeAdapter.revalidate() is a no-op — self-hosted Node has no platform-driven ISR. Use mode: "isr" for runtime LRU caching, or vercelAdapter / cloudflareAdapter / netlifyAdapter for platform-driven build-time ISR.',
-        )
-      }
-      return { regenerated: false }
-    },
-  }
-}

package/src/adapters/static.ts

@@ -1,42 +0,0 @@
-import type { Adapter, AdapterBuildOptions, AdapterRevalidateResult } from '../types'
-
-/**
- * Static adapter — just copies the client build output.
- * Used with SSG mode where all pages are pre-rendered at build time.
- *
- * **SSG mode (PR J)**: no-op — `outDir` already IS the dist directory
- * the SSG plugin produced. Copying it onto itself would only fail. The
- * static adapter is the canonical zero-overhead deploy target for
- * pure-static sites.
- *
- * **SSR mode**: copies clientOutDir → outDir. Calling `static` with SSR
- * mode is unusual — the static adapter doesn't support server-side
- * execution — but preserved as a "client-only output packager".
- */
-export function staticAdapter(): Adapter {
-  return {
-    name: 'static',
-    async build(options: AdapterBuildOptions) {
-      if (options.kind === 'ssg') {
-        // SSG dist is already at outDir — nothing to copy or rewrite.
-        return
-      }
-      const { cp, mkdir } = await import('node:fs/promises')
-
-      await mkdir(options.outDir, { recursive: true })
-      await cp(options.clientOutDir, options.outDir, { recursive: true })
-    },
-    async revalidate(_path: string): Promise<AdapterRevalidateResult> {
-      // Static hosts have no platform-driven ISR. Revalidation requires
-      // a full rebuild + redeploy. Returns `regenerated: false` so user
-      // code can branch on the no-op shape and degrade gracefully when
-      // migrating between adapters.
-      if (process.env.NODE_ENV !== 'production') {
-        console.warn(
-          '[Pyreon] staticAdapter.revalidate() is a no-op — static hosts require a full rebuild + redeploy to refresh prerendered pages. Use vercelAdapter / cloudflareAdapter / netlifyAdapter for platform-driven ISR.',
-        )
-      }
-      return { regenerated: false }
-    },
-  }
-}

package/src/adapters/validate.ts

@@ -1,23 +0,0 @@
-import type { AdapterBuildOptions } from '../types'
-
-/**
- * Validate that SSR-mode adapter build inputs exist before copying.
- * Throws with a clear error message if directories are missing.
- *
- * SSG-mode passes through unchanged — the SSG branch doesn't need a
- * server entry (every page is prerendered) and `outDir` IS the dist
- * directory the SSG plugin already populated. Validating it here would
- * be redundant.
- *
- * @internal
- */
-export async function validateBuildInputs(options: AdapterBuildOptions): Promise<void> {
-  if (options.kind !== 'ssr') return
-  const { existsSync } = await import('node:fs')
-  if (!existsSync(options.clientOutDir)) {
-    throw new Error(`[Pyreon] Client build output not found: ${options.clientOutDir}. Run "vite build" first.`)
-  }
-  if (!existsSync(options.serverEntry)) {
-    throw new Error(`[Pyreon] Server entry not found: ${options.serverEntry}. Run "vite build --ssr" first.`)
-  }
-}

package/src/adapters/vercel.ts

@@ -1,182 +0,0 @@
-import type { Adapter, AdapterBuildOptions, AdapterRevalidateResult } from '../types'
-import { validateBuildInputs } from './validate'
-import { warnMissingEnv } from './warn-missing-env'
-
-/**
- * Vercel adapter — generates output for Vercel's Build Output API v3.
- *
- * Produces a `.vercel/output` directory with:
- * - `static/` — client-side assets (JS, CSS, images)
- * - `functions/ssr.func/` — serverless function for SSR
- * - `config.json` — routing configuration
- *
- * @example
- * ```ts
- * // zero.config.ts
- * import { defineConfig } from "@pyreon/zero"
- *
- * export default defineConfig({
- *   adapter: "vercel",
- * })
- * ```
- */
-export function vercelAdapter(): Adapter {
-  return {
-    name: 'vercel',
-    async build(options: AdapterBuildOptions) {
-      if (options.kind === 'ssg') {
-        // PR J — SSG branch. Emit Vercel Build Output API v3 STATIC
-        // variant: `.vercel/output/config.json` listing routes config
-        // for the prerendered dist; no functions (every page is
-        // already static). Vercel's deployer reads this config + the
-        // built dist content as the static asset root — no runtime SSR.
-        //
-        // We do NOT copy files into `.vercel/output/static/` — the
-        // standard Vercel CLI deploy flow detects the dist root
-        // automatically. Adapters that move files break user-side
-        // post-build steps (sourcemap upload, perf scripts, custom
-        // asset handling). Writing config.json alone is the
-        // minimum-impact signal "this is a prerendered site".
-        const { writeFile, mkdir } = await import('node:fs/promises')
-        const { join } = await import('node:path')
-        const vercelDir = join(options.outDir, '.vercel', 'output')
-        await mkdir(vercelDir, { recursive: true })
-        const config = {
-          version: 3,
-          routes: [
-            // Long-cache hashed assets; mirrors the SSR config above.
-            {
-              src: '/assets/(.*)',
-              headers: { 'Cache-Control': 'public, max-age=31536000, immutable' },
-            },
-          ],
-        }
-        await writeFile(join(vercelDir, 'config.json'), JSON.stringify(config, null, 2))
-        return
-      }
-      await validateBuildInputs(options)
-      const { writeFile, cp, mkdir } = await import('node:fs/promises')
-      const { join } = await import('node:path')
-
-      const vercelDir = join(options.outDir, '.vercel', 'output')
-      const staticDir = join(vercelDir, 'static')
-      const funcDir = join(vercelDir, 'functions', 'ssr.func')
-
-      await mkdir(staticDir, { recursive: true })
-      await mkdir(funcDir, { recursive: true })
-
-      // Copy client assets to static/
-      await cp(options.clientOutDir, staticDir, { recursive: true })
-
-      // Copy server build to function directory
-      await cp(join(options.serverEntry, '..'), funcDir, { recursive: true })
-
-      // Generate serverless function entry.
-      //
-      // Pre-fix the handler dynamically imported \`./entry-server.js\` on
-      // EVERY invocation. Node's module cache makes calls after the
-      // first one near-free, but the FIRST request on every fresh
-      // serverless instance (i.e. every cold start) paid the full
-      // module evaluation cost inside the request budget — observable
-      // as a TTFB spike on cold starts. Hoisting the import to module
-      // scope evaluates the SSR module once at function-init time,
-      // before the first request lands.
-      //
-      // Also surface SSR errors to Vercel function logs via
-      // \`console.error\` (mirrors the cloudflare + netlify fix). Pre-fix
-      // an unhandled SSR throw propagated to Vercel's launcher (which
-      // logs it generically); adding our own prefix makes the cause
-      // trivially greppable in the dashboard log stream.
-      const funcEntry = `
-import handler from "./entry-server.js"
-
-export default async function vercelHandler(req) {
-  try {
-    return await handler(req)
-  } catch (err) {
-    console.error("[Pyreon SSR] handler failed:", err)
-    return new Response("Internal Server Error", { status: 500 })
-  }
-}
-`.trimStart()
-
-      await writeFile(join(funcDir, 'index.js'), funcEntry)
-
-      // Function config
-      await writeFile(
-        join(funcDir, '.vc-config.json'),
-        JSON.stringify(
-          {
-            runtime: 'nodejs20.x',
-            handler: 'index.js',
-            launcherType: 'Nodejs',
-          },
-          null,
-          2,
-        ),
-      )
-
-      // Vercel Build Output config
-      const config = {
-        version: 3,
-        routes: [
-          // Serve static assets directly
-          {
-            src: '/assets/(.*)',
-            headers: { 'Cache-Control': 'public, max-age=31536000, immutable' },
-          },
-          // Favicon and manifest
-          { src: '/(favicon\\..*|site\\.webmanifest|robots\\.txt|sitemap\\.xml)', dest: '/$1' },
-          // All other routes → SSR function
-          { src: '/(.*)', dest: '/ssr' },
-        ],
-      }
-
-      await writeFile(join(vercelDir, 'config.json'), JSON.stringify(config, null, 2))
-    },
-    async revalidate(path: string): Promise<AdapterRevalidateResult> {
-      // Vercel ISR API — POST to a deployment-relative
-      // revalidation endpoint with a secret token. Reads
-      // `VERCEL_DEPLOYMENT_URL` (auto-injected by Vercel runtime) and
-      // `VERCEL_REVALIDATE_TOKEN` (user-set in dashboard) from env.
-      // Mirrors Next.js's `res.revalidate()` shape — a HEAD request
-      // with the path + token, Vercel rebuilds the page in the
-      // background and serves stale-while-revalidate to subsequent
-      // visitors until the rebuild lands.
-      //
-      // No `regenerated: true` until Vercel acks 200 — partial-purge
-      // behaviour (the platform queues the regenerate but doesn't
-      // confirm it landed) is documented as a "false-positive
-      // possible" caveat in the Adapter.revalidate JSDoc.
-      const deploymentUrl = process.env.VERCEL_DEPLOYMENT_URL ?? process.env.VERCEL_URL
-      const token = process.env.VERCEL_REVALIDATE_TOKEN
-      if (!deploymentUrl || !token) {
-        // M2.4 — warn even in production (dedupe per process). Pre-fix the
-        // warn was DEV-gated, but production is exactly where missing env
-        // vars surface — CMS triggers revalidate, nothing happens, no
-        // signal. Now the FIRST call always warns; subsequent calls dedupe.
-        const missing: string[] = []
-        if (!deploymentUrl) missing.push('VERCEL_DEPLOYMENT_URL (or VERCEL_URL)')
-        if (!token) missing.push('VERCEL_REVALIDATE_TOKEN')
-        return warnMissingEnv(
-          'vercel',
-          missing,
-          'Set the token in Vercel project settings → Environment Variables. VERCEL_DEPLOYMENT_URL / VERCEL_URL is auto-injected by the Vercel runtime.',
-        )
-      }
-      const protocol = deploymentUrl.startsWith('http') ? '' : 'https://'
-      const url = `${protocol}${deploymentUrl}/api/_pyreon-revalidate?path=${encodeURIComponent(path)}&secret=${encodeURIComponent(token)}`
-      try {
-        const res = await fetch(url, { method: 'POST' })
-        return { regenerated: res.ok }
-      } catch (err) {
-        if (process.env.NODE_ENV !== 'production') {
-          console.warn(
-            `[Pyreon] vercelAdapter.revalidate(${path}) failed: ${err instanceof Error ? err.message : String(err)}`,
-          )
-        }
-        return { regenerated: false }
-      }
-    },
-  }
-}

package/src/adapters/warn-missing-env.ts

@@ -1,49 +0,0 @@
-import type { AdapterRevalidateResult } from '../types'
-
-/**
- * M2.4 — Loud first-call warning for missing adapter env vars.
- *
- * Pre-M2.4 the adapter `revalidate()` methods returned `{ regenerated: false }`
- * silently in production when required env vars were missing. The dev-mode
- * warning was gated on `process.env.NODE_ENV !== 'production'` — exactly the
- * env condition that DEPLOYED apps run under, where users would most need
- * the signal. Symptom: CMS triggers `adapter.revalidate(path)`, nothing
- * happens, no console output, no failure mode reported back to the
- * triggering webhook handler. The bug only surfaces when someone notices
- * stale content.
- *
- * Fix: warn ALWAYS (regardless of NODE_ENV) on the FIRST invocation per
- * `(adapterName + varSet)` combination. Dedupe via a module-level Set so
- * a busy revalidation handler doesn't spam logs — one warn per process
- * per missing-env-set is enough to expose the misconfiguration.
- *
- * Returns the canonical `{ regenerated: false }` so adapters can write
- * `return warnMissingEnv(...)` as a one-liner.
- *
- * @internal Exposed for unit tests via `_internal.warnMissingEnv` (not yet wired) + `_warnedKeys` reset.
- */
-const _warnedKeys = new Set<string>()
-
-export function warnMissingEnv(
-  adapterName: string,
-  missingVars: readonly string[],
-  hint: string,
-): AdapterRevalidateResult {
-  const key = `${adapterName}:${missingVars.join(',')}`
-  if (!_warnedKeys.has(key)) {
-    _warnedKeys.add(key)
-    // oxlint-disable-next-line no-console
-    console.warn(
-      `[Pyreon] ${adapterName}Adapter.revalidate() needs ${missingVars.join(' + ')} env var(s). ${hint}`,
-    )
-  }
-  return { regenerated: false }
-}
-
-/**
- * Reset the dedup Set. Test-only — production code never reaches this.
- * @internal
- */
-export function _resetWarnedKeys(): void {
-  _warnedKeys.clear()
-}