camelmind 0.2.1 → 0.2.3

package/template/components/Nav/TopNav.tsx

@@ -132,7 +132,7 @@ export function TopNav({ nav, userRoles, userName, authEnabled = false, versions
               currentVersionId={currentVersionId}
               currentSlug={currentSlug}
               versionSlugs={versionSlugs}
-              isLoggedIn={!!userName}
+              isLoggedIn={!!userName || !authEnabled}
             />
             {authEnabled && (
               userName ? (

package/template/components/Nav/VersionSelector.tsx

@@ -21,6 +21,14 @@ export function VersionSelector({ versions, currentVersionId, currentSlug, versi
 
   function navigateToVersion(targetId: string) {
     setOpen(false)
+
+    // API reference pages use a different URL scheme (/api-reference/[version]/...)
+    // so navigate directly to the target version's API reference overview
+    if (currentSlug.startsWith("/api-reference")) {
+      router.push(`/api-reference/${targetId}`)
+      return
+    }
+
     const bare = currentVersionId
       ? currentSlug.replace(new RegExp(`^/${currentVersionId}`), "") || "/"
       : currentSlug

package/template/components/mdx/Callout.tsx

@@ -23,10 +23,12 @@ const defaultIcons: Record<CalloutType, string> = {
 export function Callout({
   type = "note",
   icon,
+  title,
   children,
 }: {
   type?: CalloutType
   icon?: string
+  title?: string
   children: React.ReactNode
 }) {
   const iconName = icon ?? defaultIcons[type]
@@ -35,7 +37,7 @@ export function Callout({
     <div className={`callout ${type} my-4`}>
       <div className="callout-header flex items-center gap-1.5">
         <Icon name={iconName} size={13} />
-        {labels[type]}
+        {title ?? labels[type]}
       </div>
       <div className="callout-body">{children}</div>
     </div>

package/template/components/mdx/LLMIgnore.tsx

@@ -0,0 +1,4 @@
+// Renders normally for humans — stripped from .md responses served to LLMs.
+export function LLMIgnore({ children }: { children?: React.ReactNode }) {
+  return <>{children}</>
+}

package/template/components/mdx/LLMOnly.tsx

@@ -0,0 +1,4 @@
+// Hidden from the rendered page — visible only in .md responses served to LLMs.
+export function LLMOnly({ children }: { children?: React.ReactNode }) {
+  return null
+}

package/template/components/mdx/index.tsx

@@ -3,6 +3,8 @@ import { Steps, Step } from "./Steps"
 import { Tabs, Tab } from "./Tabs"
 import { Icon } from "./Icon"
 import { Details } from "./Details"
+import { LLMOnly } from "./LLMOnly"
+import { LLMIgnore } from "./LLMIgnore"
 import { CodeBlock } from "@/components/Code/CodeBlock"
 
 export const mdxComponents = {
@@ -13,6 +15,8 @@ export const mdxComponents = {
   Tab,
   Icon,
   Details,
+  LLMOnly,
+  LLMIgnore,
   pre: ({ children }: { children: React.ReactNode }) => {
     // If the child code block has a language class, let CodeBlock handle it
     const child = children as React.ReactElement<{ className?: string }>

package/template/lib/api-reference.ts

@@ -15,22 +15,21 @@ import type {
   HttpMethod,
 } from "./api-types"
 
-let _cache: ParsedSpec | null = null
-let _cachedLanguages: string | null = null
+const _specCache = new Map<string, ParsedSpec>()
 
 export function loadApiSpec(specPath: string, languages?: string[]): ParsedSpec {
-  const langKey = JSON.stringify(languages ?? null)
-  if (_cache && _cachedLanguages === langKey) return _cache
+  const cacheKey = `${specPath}|${JSON.stringify(languages ?? null)}`
+  const cached = _specCache.get(cacheKey)
+  if (cached) return cached
   const raw = fs.readFileSync(path.join(process.cwd(), specPath), "utf-8")
   const doc = yaml.load(raw) as Record<string, unknown>
-  _cache = parseOpenApi(doc, languages)
-  _cachedLanguages = langKey
-  return _cache
+  const parsed = parseOpenApi(doc, languages)
+  _specCache.set(cacheKey, parsed)
+  return parsed
 }
 
 export function clearApiCache() {
-  _cache = null
-  _cachedLanguages = null
+  _specCache.clear()
 }
 
 function slugify(str: string): string {

package/template/lib/config-types.ts

@@ -22,14 +22,24 @@ export type SiteFeatures = {
   showFeedbackWidget?: boolean
 }
 
+export type ApiSpecEntry = {
+  label: string
+  file: string
+}
+
 export type ApiReferenceConfig = {
   enabled: boolean
-  spec: string
+  specs: Record<string, ApiSpecEntry>
   navLabel?: string
   languages?: string[]
   roles?: string[]
 }
 
+export type LlmsConfig = {
+  enabled?: boolean
+  directive?: string
+}
+
 export type CamelMindConfig = {
   title: string
   tagline: string
@@ -43,4 +53,5 @@ export type CamelMindConfig = {
   }
   site?: SiteFeatures
   apiReference?: ApiReferenceConfig
+  llms?: LlmsConfig
 }

package/template/lib/config.ts

@@ -1,7 +1,7 @@
 import siteConfig from "@/camelmind.config"
 import type { AuthConfig, CamelMindConfig } from "./config-types"
 
-export type { AuthConfig, AuthProvider, CamelMindConfig, OidcConfig } from "./config-types"
+export type { AuthConfig, AuthProvider, CamelMindConfig, LlmsConfig, OidcConfig } from "./config-types"
 
 let _config: CamelMindConfig | null = null
 

package/template/lib/mdx.ts

@@ -44,6 +44,19 @@ function extractToc(source: string): TocEntry[] {
   return entries
 }
 
+export function processForLLM(source: string): string {
+  let result = source.replace(/<LLMIgnore>[\s\S]*?<\/LLMIgnore>/g, "")
+  result = result.replace(/<LLMOnly>([\s\S]*?)<\/LLMOnly>/g, "$1")
+  return result.replace(/\n{3,}/g, "\n\n").trim()
+}
+
+export function loadFrontmatterOnly(filePath: string): FrontMatter {
+  const fullPath = path.join(process.cwd(), filePath)
+  const raw = fs.readFileSync(fullPath, "utf-8")
+  const { data } = matter(raw)
+  return data as FrontMatter
+}
+
 export function loadMdxFile(filePath: string): DocContent {
   const fullPath = path.join(process.cwd(), filePath)
   const raw = fs.readFileSync(fullPath, "utf-8")

package/template/lib/nav.ts

@@ -8,11 +8,59 @@ export { isNavGroup } from "./nav-types"
 
 let _navCache: NavConfig | null = null
 
+function stripPrefix(slug: string, prefix: string): string {
+  if (slug.startsWith(prefix + "/")) return slug.slice(prefix.length)
+  if (slug === prefix) return "/"
+  return slug
+}
+
+function stripNavPrefix(nav: NavConfig, prefix: string): NavConfig {
+  const s = (slug: string) => stripPrefix(slug, prefix)
+
+  const walkChildren = (children: NavChild[]): NavChild[] =>
+    children.map((c) => ({
+      ...c,
+      slug: s(c.slug),
+      children: c.children ? walkChildren(c.children) : undefined,
+    }))
+
+  const walkEntries = (entries: NavEntry[]): NavEntry[] =>
+    entries.map((e) => ({
+      ...e,
+      slug: s(e.slug),
+      section: e.section ? walkChildren(e.section) : undefined,
+    }))
+
+  return {
+    nav: nav.nav.map((item) => {
+      if ("dropdown" in item) {
+        const group = item as NavGroup
+        return {
+          ...group,
+          ...(group.slug ? { slug: s(group.slug) } : {}),
+          items: group.items ? walkEntries(group.items) : undefined,
+        }
+      }
+      const entry = item as NavEntry
+      return { ...entry, slug: s(entry.slug) }
+    }),
+  } as NavConfig
+}
+
 export function loadNav(): NavConfig {
   if (process.env.NODE_ENV !== "development" && _navCache) return _navCache
-  const navPath = path.join(process.cwd(), "nav", "nav.yml")
-  const raw = fs.readFileSync(navPath, "utf-8")
-  _navCache = yaml.load(raw) as NavConfig
+
+  // Derive the unversioned nav from the first stable version in versions.yml,
+  // stripping the version prefix from all slugs so /v2/foo becomes /foo.
+  const versionsPath = path.join(process.cwd(), "versions.yml")
+  const { versions } = yaml.load(fs.readFileSync(versionsPath, "utf-8")) as {
+    versions: { id: string; stable: boolean; nav: string }[]
+  }
+  const latest = versions.find((v) => v.stable) ?? versions[0]
+  const navPath = path.join(process.cwd(), latest.nav)
+  const nav = yaml.load(fs.readFileSync(navPath, "utf-8")) as NavConfig
+
+  _navCache = stripNavPrefix(nav, `/${latest.id}`)
   return _navCache
 }
 
@@ -123,3 +171,24 @@ export function getSectionForSlugFromConfig(nav: NavConfig, slug: string): NavEn
 export function getSectionForSlug(slug: string): NavEntry | null {
   return getSectionForSlugFromConfig(loadNav(), slug)
 }
+
+export function getAllPublicEntries(nav: NavConfig): (NavEntry | NavChild)[] {
+  const entries: (NavEntry | NavChild)[] = []
+  for (const item of nav.nav) {
+    if ("dropdown" in item) {
+      const group = item as NavGroup
+      for (const entry of (group.items ?? [])) {
+        if (entry.roles.length === 0) entries.push(entry)
+        if (entry.section) {
+          for (const child of flattenChildren(entry.section)) {
+            if (child.roles.length === 0) entries.push(child)
+          }
+        }
+      }
+    } else if ("slug" in item) {
+      const entry = item as NavEntry
+      if (entry.roles.length === 0) entries.push(entry)
+    }
+  }
+  return entries
+}

package/template/lib/versions.ts

@@ -3,20 +3,24 @@ import path from "path"
 import yaml from "js-yaml"
 import { loadNav } from "./nav"
 import type { NavConfig } from "./nav-types"
+import type { ApiReferenceConfig } from "./config-types"
 
-export type VersionApiReference = {
-  spec: string
-  nav_label?: string
-  languages?: string[]
+export type VersionApiReferenceTab = {
+  id: string
+  spec: string  // key into camelmind.config.ts apiReference.specs
 }
 
+export type VersionApiReference =
+  | { spec: string }                       // single named spec
+  | { tabs: VersionApiReferenceTab[] }     // multi-spec tabs
+
 export type Version = {
   id: string
   label: string
   stable: boolean
   badge?: string
   nav: string
-  // true/omitted = use site-level spec, false = hide, object = version-specific spec
+  // false = disabled, omitted/true = use first spec in registry, object = explicit config
   api_reference?: boolean | VersionApiReference
 }
 
@@ -24,6 +28,18 @@ export type VersionsConfig = {
   versions: Version[]
 }
 
+// Resolved output types
+export type ResolvedTab = {
+  id: string
+  label: string
+  file: string
+  languages?: string[]
+}
+
+export type ResolvedApiReference =
+  | { mode: "single"; label: string; file: string; languages?: string[] }
+  | { mode: "tabs"; tabs: ResolvedTab[] }
+
 let _versionsCache: VersionsConfig | null = null
 
 export function loadVersions(): VersionsConfig {
@@ -33,12 +49,52 @@ export function loadVersions(): VersionsConfig {
   return _versionsCache
 }
 
+// Resolve which spec(s) to show for a given version.
+// Resolution: versions.yml api_reference → apiReference.specs registry → first spec in registry
+// Returns null if api_reference is explicitly disabled for this version.
+export function getApiReferenceForVersion(
+  versionId: string | null,
+  config: ApiReferenceConfig
+): ResolvedApiReference | null {
+  const { versions } = loadVersions()
+
+  let versionAr: boolean | VersionApiReference | undefined
+  if (versionId) {
+    const v = versions.find((v) => v.id === versionId)
+    versionAr = v?.api_reference
+  }
+
+  if (versionAr === false) return null
+
+  // Default: use first spec in registry
+  if (!versionAr || versionAr === true) {
+    const firstEntry = Object.entries(config.specs)[0]
+    if (!firstEntry) return null
+    const [, entry] = firstEntry
+    return { mode: "single", label: entry.label, file: entry.file, languages: config.languages }
+  }
+
+  // Tabs mode
+  if ("tabs" in versionAr) {
+    const tabs: ResolvedTab[] = versionAr.tabs.flatMap((tab) => {
+      const entry = config.specs[tab.spec]
+      if (!entry) return []
+      return [{ id: tab.id, label: entry.label, file: entry.file, languages: config.languages }]
+    })
+    return tabs.length ? { mode: "tabs", tabs } : null
+  }
+
+  // Single named spec
+  const entry = config.specs[versionAr.spec]
+  if (!entry) return null
+  return { mode: "single", label: entry.label, file: entry.file, languages: config.languages }
+}
+
 export function getVersionFromSlug(slug: string): string | null {
   const { versions } = loadVersions()
   for (const v of versions) {
     if (slug.startsWith(`/${v.id}/`) || slug === `/${v.id}`) return v.id
   }
-  // no version prefix = default (latest)
   return null
 }
 
@@ -57,30 +113,10 @@ export function getLatestVersion(): Version {
   return versions[0]
 }
 
-// Resolve which OpenAPI spec to use for a given version, with site-level fallback.
-// Returns null if api_reference is explicitly disabled for this version.
-export function getApiSpecForVersion(
-  versionId: string | null,
-  siteSpec: string,
-  siteLanguages?: string[]
-): { spec: string; languages?: string[] } | null {
-  if (!versionId) return { spec: siteSpec, languages: siteLanguages }
-  const { versions } = loadVersions()
-  const v = versions.find((v) => v.id === versionId)
-  if (!v) return { spec: siteSpec, languages: siteLanguages }
-
-  const ar = v.api_reference
-  if (ar === false) return null
-  if (!ar || ar === true) return { spec: siteSpec, languages: siteLanguages }
-  return { spec: ar.spec, languages: ar.languages ?? siteLanguages }
-}
-
-// Given a slug like /v1.9/getting-started/overview, return /getting-started/overview
 export function stripVersionPrefix(slug: string, versionId: string): string {
   return slug.replace(new RegExp(`^/${versionId}`), "") || "/"
 }
 
-// Given /getting-started/overview and a target version, return /v1.9/getting-started/overview
 export function swapVersion(slug: string, currentVersionId: string | null, targetVersionId: string): string {
   const bare = currentVersionId ? stripVersionPrefix(slug, currentVersionId) : slug
   return `/${targetVersionId}${bare}`

package/template/proxy.ts

@@ -6,6 +6,14 @@ import { isAuthEnabled, isPrivateSite, isPublicPath } from "@/lib/config"
 export async function proxy(req: NextRequest) {
   const { pathname } = req.nextUrl
 
+  // Rewrite /<slug>.md to /api/llms/<slug> before auth runs.
+  // /api/llms is in publicPaths so the handler is always reachable.
+  if (pathname.endsWith(".md") && !pathname.startsWith("/api/")) {
+    const url = req.nextUrl.clone()
+    url.pathname = `/api/llms${pathname.slice(0, -3)}`
+    return NextResponse.rewrite(url)
+  }
+
   // Auth disabled — all traffic passes through
   if (!isAuthEnabled()) {
     return NextResponse.next()
@@ -46,5 +54,6 @@ export async function proxy(req: NextRequest) {
 }
 
 export const config = {
-  matcher: ["/((?!_next/static|_next/image|favicon.ico|public/).*)"],
+  // Exclude Next.js internals and common static asset extensions served from public/
+  matcher: ["/((?!_next/static|_next/image|favicon\\.ico|.*\\.(?:png|jpg|jpeg|gif|svg|ico|webp|woff2?|ttf|eot|otf)).*)"],
 }

package/template/scripts/build-offline.sh

@@ -10,7 +10,7 @@
 
 set -euo pipefail
 
-VERSION=${1:-v2.0}
+VERSION=${1:-latest}
 ROOT="$(cd "$(dirname "$0")/.." && pwd)"
 OUT_DIR="$ROOT/out"
 BUILDS_DIR="$ROOT/offline-builds"
@@ -21,6 +21,8 @@ SERVER_ROUTES=(
   "app/api/raw/route.ts"
   "app/api/download/route.ts"
   "app/api/search/route.ts"
+  "app/api/feedback/route.ts"
+  "app/api/llms"
   "app/api/auth"
 )
 
@@ -48,7 +50,17 @@ restore_routes() {
 }
 
 # Always restore on exit (even on error)
-trap restore_routes EXIT
+PAGES_DIR="$ROOT/.pdf-pages"
+
+cleanup() {
+  restore_routes
+  rm -rf "$PAGES_DIR"
+  # Kill the static server if still running
+  if [[ -n "${STATIC_PID:-}" ]]; then
+    kill "$STATIC_PID" 2>/dev/null || true
+  fi
+}
+trap cleanup EXIT
 
 echo "▶ Building offline package for version: $VERSION"
 
@@ -69,10 +81,14 @@ OFFLINE_MODE=true TARGET_VERSION="$VERSION" npx next build
 
 cat > "$OUT_DIR/launch.sh" <<'LAUNCHER'
 #!/usr/bin/env bash
-# Game Warden Help Center — offline launcher (Mac / Linux)
+# CamelMind offline launcher (Mac / Linux)
+cd "$(dirname "$0")"
 PORT=8765
 URL="http://localhost:$PORT/home/"
 
+# Free the port if a previous server is still running
+lsof -ti:$PORT 2>/dev/null | xargs kill 2>/dev/null || true
+
 # Try Python 3 first (available on most systems without internet)
 if command -v python3 &>/dev/null; then
   echo "Starting local server on $URL"
@@ -113,7 +129,8 @@ chmod +x "$OUT_DIR/launch.sh"
 
 cat > "$OUT_DIR/launch.bat" <<'LAUNCHER'
 @echo off
-REM Game Warden Help Center — offline launcher (Windows)
+REM CamelMind offline launcher (Windows)
+cd /D "%~dp0"
 set PORT=8765
 set URL=http://localhost:%PORT%/home/
 
@@ -180,7 +197,28 @@ NOTES
   Do not redistribute without authorization.
 EOF
 
-# 4. Zip the output
+# 4. Generate PDF from the static export
+echo "  → Generating PDF..."
+STATIC_PORT=8766
+
+# Serve the static output on a temporary port
+python3 -m http.server "$STATIC_PORT" --directory "$OUT_DIR" >/dev/null 2>&1 &
+STATIC_PID=$!
+
+# Wait up to 10s for the server to be ready
+for i in $(seq 1 20); do
+  if curl -s -o /dev/null "http://localhost:$STATIC_PORT/home/"; then break; fi
+  sleep 0.5
+done
+
+npx tsx scripts/generate-pdfs.ts --port="$STATIC_PORT" --out="$PAGES_DIR" --no-auth
+npx tsx scripts/generate-master-pdf.ts --version="$VERSION" --pages="$PAGES_DIR" --out="$BUILDS_DIR"
+
+kill "$STATIC_PID" 2>/dev/null || true
+unset STATIC_PID
+rm -rf "$PAGES_DIR"
+
+# 5. Zip the output
 echo "  → Packaging..."
 mkdir -p "$BUILDS_DIR"
 cd "$OUT_DIR"

package/template/scripts/build-pdf.sh

@@ -9,7 +9,7 @@
 
 set -euo pipefail
 
-VERSION=${1:-v2.0}
+VERSION=${1:-latest}
 ROOT="$(cd "$(dirname "$0")/.." && pwd)"
 PAGES_DIR="$ROOT/.pdf-pages"
 PORT=3000
@@ -37,5 +37,5 @@ npx tsx scripts/generate-pdfs.ts --port="$PORT" --out="$PAGES_DIR"
 echo "  → Assembling master PDF..."
 npx tsx scripts/generate-master-pdf.ts --version="$VERSION" --pages="$PAGES_DIR" --out="$ROOT/offline-builds"
 
-SIZE=$(du -sh "$ROOT/offline-builds/Game-Warden-Help-Center-${VERSION}.pdf" | cut -f1)
-echo "✓ Done: offline-builds/Game-Warden-Help-Center-${VERSION}.pdf ($SIZE)"
+SIZE=$(du -sh "$ROOT/offline-builds/camelmind-${VERSION}.pdf" | cut -f1)
+echo "✓ Done: offline-builds/camelmind-${VERSION}.pdf ($SIZE)"

package/template/scripts/build-search-index.ts

@@ -10,9 +10,15 @@ import path from "path"
 import matter from "gray-matter"
 
 const ROOT = path.resolve(process.cwd())
-const NAV_FILE = path.join(ROOT, "nav", "nav.yml")
 const OUT_FILE = path.join(ROOT, "public", "search-index.json")
 
+// Resolve the latest stable version's nav file from versions.yml
+const { versions } = yaml.load(fs.readFileSync(path.join(ROOT, "versions.yml"), "utf-8")) as {
+  versions: { id: string; stable: boolean; nav: string }[]
+}
+const latestVersion = versions.find((v) => v.stable) ?? versions[0]
+const NAV_FILE = path.join(ROOT, latestVersion.nav)
+
 // Minimal YAML parser for our nav structure (avoids pulling in the full Next.js lib graph)
 import yaml from "js-yaml"
 

package/template/scripts/generate-master-pdf.ts

@@ -12,6 +12,9 @@
 import { PDFDocument, StandardFonts, rgb, PDFPage } from "pdf-lib"
 import fs from "fs"
 import path from "path"
+import config from "../camelmind.config"
+
+const SITE_TITLE = config.title
 
 const ROOT = path.resolve(process.cwd())
 
@@ -49,25 +52,15 @@ async function buildCoverPage(doc: PDFDocument): Promise<PDFPage> {
   // Thin accent line
   page.drawRectangle({ x: MARGIN, y: PH * 0.45 - 2, width: PW - MARGIN * 2, height: 2, color: rgb(0.3, 0.35, 0.45) })
 
-  // "SECOND FRONT SYSTEMS" label
-  page.drawText("SECOND FRONT SYSTEMS", {
-    x: MARGIN,
-    y: PH * 0.45 + 180,
-    size: 9,
-    font: regularFont,
-    color: rgb(0.6, 0.65, 0.75),
-    characterSpacing: 2,
-  })
-
   // Main title
-  page.drawText("Game Warden", {
+  page.drawText(SITE_TITLE, {
     x: MARGIN,
     y: PH * 0.45 + 130,
     size: 42,
     font: boldFont,
     color: WHITE,
   })
-  page.drawText("Help Center", {
+  page.drawText("Documentation", {
     x: MARGIN,
     y: PH * 0.45 + 78,
     size: 42,
@@ -94,13 +87,12 @@ async function buildCoverPage(doc: PDFDocument): Promise<PDFPage> {
 
   // Footer bar
   page.drawRectangle({ x: 0, y: 0, width: PW, height: 36, color: LIGHT })
-  page.drawText("game warden help center · secondfront.com", {
+  page.drawText(`${SITE_TITLE.toLowerCase()} documentation`, {
     x: MARGIN,
     y: 12,
     size: 8,
     font: regularFont,
     color: MID,
-    characterSpacing: 0.5,
   })
   page.drawText("CONFIDENTIAL — FOR AUTHORIZED USERS ONLY", {
     x: PW - MARGIN - 220,
@@ -126,7 +118,7 @@ async function buildTocPage(
 
   const drawPageHeader = (p: PDFPage) => {
     p.drawText("TABLE OF CONTENTS", {
-      x: MARGIN, y: PH - MARGIN + 10, size: 8, font: regularFont, color: MID, characterSpacing: 1.5
+      x: MARGIN, y: PH - MARGIN + 10, size: 8, font: regularFont, color: MID,
     })
     p.drawLine({ start: { x: MARGIN, y: PH - MARGIN - 4 }, end: { x: PW - MARGIN, y: PH - MARGIN - 4 }, thickness: 0.5, color: rgb(0.85, 0.85, 0.85) })
   }
@@ -152,7 +144,7 @@ async function buildTocPage(
     if (entry.group !== lastGroup) {
       if (lastGroup !== "") y -= 6
       page.drawText(entry.group.toUpperCase(), {
-        x: MARGIN, y, size: 7.5, font: boldFont, color: MID, characterSpacing: 1,
+        x: MARGIN, y, size: 7.5, font: boldFont, color: MID,
       })
       y -= 18
       lastGroup = entry.group
@@ -249,7 +241,7 @@ async function main() {
 
   // ── Write output ───────────────────────────────────────────────────────────
   fs.mkdirSync(OUT_DIR, { recursive: true })
-  const outFile = path.join(OUT_DIR, `Game-Warden-Help-Center-${VERSION}.pdf`)
+  const outFile = path.join(OUT_DIR, `camelmind-${VERSION}.pdf`)
   const pdfBytes = await masterDoc.save()
   fs.writeFileSync(outFile, pdfBytes)