jamdesk 1.1.221 → 1.1.222

package/vendored/hooks/useChat.ts

@@ -332,6 +332,8 @@ export function useChat(endpoint = '/_chat'): {
           let errorMessage = 'Something went wrong. Please try again.';
           if (response.status === 429) {
             errorMessage = 'Too many requests. Please wait a moment and try again.';
+          } else if (response.status === 401) {
+            errorMessage = 'Your session has expired. Reload the page to sign in again.';
           } else if (response.status === 503) {
             errorMessage = 'AI chat is temporarily unavailable. Please try again later.';
           }

package/vendored/hooks/useChatPanel.tsx

@@ -1,6 +1,7 @@
 'use client';
 
 import { createContext, useContext, useState, useEffect, useCallback, type ReactNode } from 'react';
+import type { ChatIconSpec } from '@/lib/docs-types';
 import { useDevOnlyNotice, DEV_FEATURE } from '@/components/ui/DevOnlyNotice';
 
 const MIN_WIDTH = 350;
@@ -16,6 +17,10 @@ interface ChatPanelContextValue {
   chatEnabled: boolean;
   chatEndpoint: string;
   starterQuestions?: string[];
+  /** Raw `chat.label` from docs.json; resolve with a per-site fallback via useChatLabel. */
+  chatLabel?: string;
+  /** Resolved `chat.icon`; absent means the default sparkles icon. */
+  chatIcon?: ChatIconSpec;
   /** Question queued by an external trigger (e.g. search "Ask AI"). Consumed once by ChatPanel. */
   pendingQuestion: string | null;
   /** Open the chat panel and queue `question` to be sent as the next message (append). */
@@ -31,13 +36,15 @@ interface ChatPanelProviderProps {
   chatEnabled: boolean;
   chatEndpoint: string;
   starterQuestions?: string[];
+  chatLabel?: string;
+  chatIcon?: ChatIconSpec;
 }
 
 function clampWidth(width: number): number {
   return Math.min(MAX_WIDTH, Math.max(MIN_WIDTH, width));
 }
 
-export function ChatPanelProvider({ children, chatEnabled, chatEndpoint, starterQuestions }: ChatPanelProviderProps) {
+export function ChatPanelProvider({ children, chatEnabled, chatEndpoint, starterQuestions, chatLabel, chatIcon }: ChatPanelProviderProps) {
   const [isChatOpen, setIsChatOpen] = useState(false);
   const [chatWidth, setChatWidthRaw] = useState(DEFAULT_WIDTH);
   const [pendingQuestion, setPendingQuestion] = useState<string | null>(null);
@@ -102,7 +109,7 @@ export function ChatPanelProvider({ children, chatEnabled, chatEndpoint, starter
   }, [chatEnabled, isChatOpen, isDevMode]);
 
   return (
-    <ChatPanelContext.Provider value={{ isChatOpen, setIsChatOpen, chatWidth, setChatWidth, chatEnabled, chatEndpoint, starterQuestions, pendingQuestion, askChat, consumePendingQuestion }}>
+    <ChatPanelContext.Provider value={{ isChatOpen, setIsChatOpen, chatWidth, setChatWidth, chatEnabled, chatEndpoint, starterQuestions, chatLabel, chatIcon, pendingQuestion, askChat, consumePendingQuestion }}>
       {children}
     </ChatPanelContext.Provider>
   );

package/vendored/lib/anthropic-client.ts

@@ -7,6 +7,13 @@
  */
 import Anthropic from '@anthropic-ai/sdk';
 
+/**
+ * The one Haiku model ID for docs chat, the query rewriter and starter
+ * questions. Change it here, then run the live eval
+ * (__tests__/lib/chat-prompt.eval.test.ts) before deploying.
+ */
+export const HAIKU_MODEL = 'claude-haiku-5-5';
+
 let client: Anthropic | null = null;
 
 /** Get or create the shared Anthropic client. Returns null if API key is not configured. */

package/vendored/lib/build/error-parser.ts

@@ -1,6 +1,7 @@
 import type { ErrorDetails } from '../../shared/types.js';
 import { DEPRECATED_COMPONENTS } from '../deprecated-components.js';
 import { MIGRATION_DOCS_URL } from '../validate-config.js';
+import { SYMLINK_ESCAPE_ERROR } from './validate-no-symlink-escape.js';
 
 /** Format: ERR-XXXXXXXX (first 8 chars of buildId, uppercase) */
 export function generateErrorRef(buildId: string): string {
@@ -246,6 +247,22 @@ export function parseErrorDetails(
     };
   }
 
+  // A CLI-uploaded tree with a symlink pointing outside it
+  // (validate-no-symlink-escape.ts, `source` phase). The git clone path
+  // removes such links and warns instead of throwing. Kept ahead of the clone
+  // fallback below so a throw from either source never reads as "check
+  // GitHub App access".
+  if (message.includes(SYMLINK_ESCAPE_ERROR)) {
+    return {
+      type: 'config_error',
+      message: 'Repository contains a symlink pointing outside it',
+      details: message,
+      suggestion:
+        'For security, builds only follow symlinks whose target is inside the repository.\n\n' +
+        'Fix: replace the symlink with a copy of the file, or point it at a file inside the repository, then rebuild.',
+    };
+  }
+
   // Configuration validation errors (from validate phase)
   if (message.includes('Missing docs.json') || message.includes('Invalid docs.json')) {
     const monorepoMatch = message.match(/Missing docs.json at '([^']+)'/);

package/vendored/lib/build/extract-tarball.ts

@@ -16,6 +16,7 @@ import os from 'os';
 import { GetObjectCommand, DeleteObjectCommand } from '@aws-sdk/client-s3';
 import { getR2S3Client, getR2Config } from '../r2.js';
 import { logger } from '../../shared/logger.js';
+import { validateNoSymlinkEscape } from './validate-no-symlink-escape.js';
 
 const MAX_DECOMPRESSED_SIZE_BYTES = 500 * 1024 * 1024; // 500MB
 
@@ -94,35 +95,6 @@ export async function extractTarball(tarballKey: string, repoDir: string): Promi
   });
 }
 
-/**
- * Walk repoDir recursively and verify no symlinks point outside it.
- */
-function validateNoSymlinkEscape(repoDir: string): void {
-  const realRepoDir = fs.realpathSync(repoDir);
-
-  function walk(dir: string): void {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-
-      if (entry.isSymbolicLink()) {
-        const target = fs.realpathSync(fullPath);
-        if (!target.startsWith(realRepoDir + path.sep) && target !== realRepoDir) {
-          // Remove the offending symlink and throw
-          fs.unlinkSync(fullPath);
-          throw new Error(
-            `Symlink escape detected: ${path.relative(repoDir, fullPath)} -> ${target} (outside ${realRepoDir})`
-          );
-        }
-      } else if (entry.isDirectory()) {
-        walk(fullPath);
-      }
-    }
-  }
-
-  walk(repoDir);
-}
-
 /**
  * Check total decompressed size doesn't exceed limit.
  */

package/vendored/lib/build/validate-no-symlink-escape.ts

@@ -0,0 +1,100 @@
+/**
+ * Symlink containment for a customer source tree (git clone or CLI tarball).
+ *
+ * Customer repos are untrusted, git and tar both keep symlinks, and the
+ * build's collectors (fast-glob, followSymbolicLinks on) read through them.
+ * Without this check `page.mdx -> /proc/self/environ` publishes the build
+ * machine's file to R2 as the site's content.
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Stable prefix of the error thrown below. error-parser.ts matches on it so
+ * the dashboard says what is wrong instead of a generic build failure.
+ */
+export const SYMLINK_ESCAPE_ERROR = 'Symlink escape detected';
+
+/**
+ * A link is allowed only if it resolves inside the repo and not into its
+ * `.git` directory: a clone keeps its credentials in `.git/config`, and an
+ * in-repo `page.mdx -> .git/config` would publish them like any outside file.
+ */
+function isAllowedTarget(realRepoDir: string, target: string): boolean {
+  if (target !== realRepoDir && !target.startsWith(realRepoDir + path.sep)) return false;
+  return !path.relative(realRepoDir, target).split(path.sep).some((s) => s.toLowerCase() === '.git');
+}
+
+/**
+ * Where a symlink points. A dangling link has no realpath, so its target is
+ * resolved lexically from the link's real parent directory: nothing can be
+ * read through it now, but an outside target could be created later in the
+ * build (a temp file, another clone), so it must still be judged.
+ */
+function symlinkTarget(fullPath: string): string {
+  try {
+    return fs.realpathSync(fullPath);
+  } catch {
+    return path.resolve(fs.realpathSync(path.dirname(fullPath)), fs.readlinkSync(fullPath));
+  }
+}
+
+/**
+ * Walk repoDir recursively and call `onEscape` for every symlink whose target
+ * is not allowed (see isAllowedTarget). `onEscape` must remove the link or
+ * throw; the walk does not descend through symlinks.
+ */
+function forEachEscapingSymlink(
+  repoDir: string,
+  onEscape: (fullPath: string) => void,
+): void {
+  const realRepoDir = fs.realpathSync(repoDir);
+
+  function walk(dir: string): void {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isSymbolicLink()) {
+        const target = symlinkTarget(fullPath);
+        if (!isAllowedTarget(realRepoDir, target)) onEscape(fullPath);
+      } else if (entry.isDirectory()) {
+        walk(fullPath);
+      }
+    }
+  }
+
+  walk(repoDir);
+}
+
+/**
+ * CLI tarball path: on the first escaping link, remove it and throw. The
+ * tarball comes straight from the author's machine, so failing the deploy
+ * tells them immediately.
+ */
+export function validateNoSymlinkEscape(repoDir: string): void {
+  forEachEscapingSymlink(repoDir, (fullPath) => {
+    fs.unlinkSync(fullPath);
+    // Repo-relative link path only: error-parser passes this message to the
+    // dashboard as `details`, so neither the target nor the build machine's
+    // directory layout may appear in it.
+    throw new Error(
+      `${SYMLINK_ESCAPE_ERROR}: ${path.relative(repoDir, fullPath)} points outside the repository or into .git`
+    );
+  });
+}
+
+/**
+ * Git clone path: remove every escaping link and return their repo-relative
+ * paths. Never throws for a bad link, so a stray absolute link committed by
+ * accident (`/Users/dev/...`) cannot break a live site's builds or its
+ * translation runs. The exfiltration is still closed: the link is gone
+ * before anything reads the tree.
+ */
+export function removeEscapingSymlinks(repoDir: string): string[] {
+  const removed: string[] = [];
+  forEachEscapingSymlink(repoDir, (fullPath) => {
+    fs.unlinkSync(fullPath);
+    removed.push(path.relative(repoDir, fullPath));
+  });
+  return removed;
+}

package/vendored/lib/chat-branding.ts

@@ -0,0 +1,26 @@
+import { transformConfigImagePath, type ChatIconSpec } from './docs-types';
+import { getIconClass } from './icon-utils';
+
+export const DEFAULT_CHAT_ICON = 'sparkles';
+
+const IMAGE_PREFIX = /^(https?:\/\/|\/\/|\/|\.\/|data:)/i;
+const IMAGE_EXT = /\.(svg|png|jpe?g|webp|gif)$/i;
+
+/**
+ * Resolve `chat.icon` to either a Font Awesome class or an image source.
+ * Bare relative paths like `images/a.svg` count as images by extension, since
+ * a Font Awesome name never contains a dot.
+ */
+export function resolveChatIcon(icon: string | undefined, assetVersion?: string): ChatIconSpec {
+  const value = icon?.trim() || DEFAULT_CHAT_ICON;
+  if (IMAGE_PREFIX.test(value) || IMAGE_EXT.test(value)) {
+    // Remote URLs pass through unchanged; local paths get the same asset
+    // handling as the logo (/_jd/ prefix for hostAtDocs, cache-busting version).
+    return { kind: 'img', src: transformConfigImagePath(value, assetVersion)! };
+  }
+  return { kind: 'fa', className: getIconClass(value) };
+}
+
+export function resolveChatLabel(label: string | undefined, fallback: string): string {
+  return label?.trim() || fallback;
+}

package/vendored/lib/chat-prompt.ts

@@ -1,7 +1,7 @@
 /**
  * Chat System Prompt Builder
  *
- * Builds the system prompt for Claude Haiku 4.5, incorporating RAG context
+ * Builds the system prompt for Claude Haiku 5.5, incorporating RAG context
  * from Upstash Vector search results. The prompt instructs Claude to only
  * answer from provided documentation and cite sources with links.
  */
@@ -32,7 +32,7 @@ export function buildCannedIdentityReply(projectName: string): string {
 /**
  * Detects whether Claude's markdown output is the canned identity reply.
  *
- * Haiku at temperature 0.3 drifts the exact string in small ways: curly vs
+ * Haiku drifts the exact string in small ways: curly vs
  * straight apostrophes, trailing period variants, surrounding markdown
  * emphasis (`*...*`), or extra whitespace. An exact === compare against
  * buildCannedIdentityReply would miss those and let the "top 2 by score"

package/vendored/lib/docs-types.ts

@@ -187,6 +187,9 @@ export interface GroupConfig {
  */
 export type TabsPosition = 'top' | 'left';
 
+/** Horizontal alignment of the header tab row when tabsPosition is 'top' */
+export type TabsAlignment = 'start' | 'center' | 'end';
+
 /**
  * External link anchor - appears at top of sidebar on all pages
  * These are simple external navigation links, NOT content sections
@@ -721,8 +724,21 @@ export interface ChatConfig {
   enabled?: boolean;
   /** Starter questions shown in empty state (max 4). Auto-generated by Haiku during builds when omitted. Set to [] to disable. */
   starterQuestions?: string[];
+  /** Name shown on the chat button, panel header and search shortcut in place of "Ask AI" (max 40 characters). Applies to every language. */
+  label?: string;
+  /** Icon for the chat button and panel: a Font Awesome icon name (optionally "style/name"), an image URL, or a path to an image in the project. */
+  icon?: string;
 }
 
+/**
+ * Resolved chat icon: a Font Awesome class string or an image source.
+ * Lives here, not in lib/chat-branding.ts, because hooks/useChatPanel.tsx is
+ * vendored into the dashboard and docs-types.ts is already in its vendored lib set.
+ */
+export type ChatIconSpec =
+  | { kind: 'fa'; className: string }
+  | { kind: 'img'; src: string };
+
 /**
  * Options for the generated social sharing card (og:image).
  */
@@ -945,6 +961,10 @@ export interface DocsConfig {
   // 'left': Tabs at top of sidebar (default for every theme)
   tabsPosition?: TabsPosition;
 
+  // Tab row alignment when tabsPosition is 'top' (default 'start').
+  // No effect in Pulsar, which places top tabs on the right of the header.
+  tabsAlignment?: TabsAlignment;
+
   // External link anchors - appear at top of sidebar on all pages
   anchors?: ExternalAnchorConfig[];
 

package/vendored/lib/generate-starter-questions.ts

@@ -5,10 +5,13 @@
  * 4 contextually relevant questions new users would likely ask.
  * Non-fatal: returns empty array on any error so builds aren't blocked.
  *
- * Uses temperature 0 for deterministic output — same docs produce the
- * same questions, avoiding unnecessary cache invalidation between builds.
+ * Haiku 5.5 rejects temperature, so the same docs can produce different
+ * questions on each call. The questions land in docs.json, and any docs.json
+ * change revalidates every page, so build.ts reuses the previous build's
+ * questions (stored in the R2 manifest) while starterQuestionsKey is unchanged.
  */
-import { getAnthropicClient } from './anthropic-client.js';
+import crypto from 'node:crypto';
+import { getAnthropicClient, HAIKU_MODEL } from './anthropic-client.js';
 
 const MAX_QUESTIONS = 4;
 /** Cap summary lines to avoid excessive prompt size with large doc sets */
@@ -43,6 +46,18 @@ export function buildDocSummary(pages: PageInfo[]): string {
   }).join('\n');
 }
 
+/**
+ * Cache key for generated questions: the prompt input plus the model, so a
+ * page rename or a model change regenerates and anything else reuses.
+ */
+export function starterQuestionsKey(pages: PageInfo[]): string {
+  return crypto
+    .createHash('sha256')
+    .update(`${HAIKU_MODEL}\n${buildDocSummary(pages)}`)
+    .digest('hex')
+    .slice(0, 16);
+}
+
 /**
  * Generate starter questions for the chat empty state using Haiku.
  * Returns up to 4 questions, or empty array if generation fails.
@@ -58,9 +73,11 @@ export async function generateStarterQuestions(pages: PageInfo[]): Promise<strin
   try {
     const response = await anthropic.messages.create(
       {
-        model: 'claude-haiku-4-5-20251001',
+        model: HAIKU_MODEL,
         max_tokens: 256,
-        temperature: 0,
+        // Haiku 5.5 thinks by default, which would eat the 256-token cap.
+        thinking: { type: 'disabled' },
+        output_config: { effort: 'low' },
         messages: [{
           role: 'user',
           content: `You are generating starter questions for a documentation chatbot. Given this documentation structure, generate exactly ${MAX_QUESTIONS} questions that a new user would likely ask first.
@@ -79,7 +96,8 @@ ${summary}`,
       { signal: controller.signal },
     );
 
-    let text = response.content[0]?.type === 'text' ? response.content[0].text : '';
+    const textBlock = response.content.find((b) => b.type === 'text');
+    let text = textBlock?.type === 'text' ? textBlock.text : '';
     // Strip markdown code fences — Haiku sometimes wraps JSON in ```json ... ```
     text = text.replace(/^```(?:json)?\s*\n?/i, '').replace(/\n?```\s*$/, '').trim();
     const parsed = JSON.parse(text);

package/vendored/lib/github-git-auth.ts

@@ -0,0 +1,47 @@
+/**
+ * One-shot GitHub credentials for git subprocesses.
+ *
+ * A token in the remote URL (`https://x-access-token:TOKEN@github.com/...`)
+ * is written by `git clone` into `.git/config` and the reflog. When a project
+ * has no docs subdirectory, `.git/` sits inside the project the build reads
+ * and publishes from, so the token could reach a public file.
+ *
+ * Instead the token goes to git as an `http.extraHeader`, scoped to
+ * https://github.com/, through the GIT_CONFIG_COUNT/KEY/VALUE environment
+ * variables. Git treats those as command-line config for that one process
+ * and never writes them to disk.
+ * The environment is used rather than `git -c`, because argv shows up in
+ * execFileSync's "Command failed: ..." error message and in process
+ * listings. (`git clone -c` would be worse: clone saves those values into the
+ * new repo's config.)
+ *
+ * page-timestamps.ts imports this extension-less (`./github-git-auth`)
+ * because it is also pulled into the Next.js/ISR bundle, where Next prod
+ * rejects `.js` specifiers in TS source. Keep it free of imports that would
+ * break that bundle; `Buffer` is fine on the Node runtime.
+ */
+
+/** base64("x-access-token:<token>"), the Basic credential GitHub accepts. */
+export function githubBasicAuth(token: string): string {
+  return Buffer.from(`x-access-token:${token}`).toString('base64');
+}
+
+/**
+ * Environment additions that authenticate one git command to GitHub.
+ * Spread over `process.env` so git still sees PATH and HOME.
+ */
+export function githubGitAuthEnv(token: string): Record<string, string> {
+  return {
+    GIT_CONFIG_COUNT: '1',
+    // URL-scoped so git sends the header only to https://github.com/. A bare
+    // http.extraHeader goes with every HTTP request, including ones to hosts a
+    // customer repo names (a submodule URL, or a git-lfs endpoint in
+    // .lfsconfig if lfs is ever installed in the image).
+    GIT_CONFIG_KEY_0: 'http.https://github.com/.extraHeader',
+    GIT_CONFIG_VALUE_0: `Authorization: Basic ${githubBasicAuth(token)}`,
+    // With no credential in the URL, git may fall back to asking for a
+    // username. Fail at once with an auth error (classified as auth_failed)
+    // instead of waiting on a prompt nobody can answer.
+    GIT_TERMINAL_PROMPT: '0',
+  };
+}

package/vendored/lib/hedge-strip.ts

@@ -2,7 +2,7 @@
  * Detects and truncates Claude's canned no-answer sentence
  * ("I don't have information about that in the documentation.") when followed
  * by a self-contradicting "However..." — a prompt-adherence failure mode of
- * Haiku 4.5. Tolerates curly-vs-straight apostrophes and surrounding markdown
+ * Haiku 4.5 (kept on 5.5 as a guard). Tolerates curly-vs-straight apostrophes and surrounding markdown
  * emphasis.
  *
  * ASSUMPTION: the sentence is reserved for the no-answer reply. A docs page

package/vendored/lib/isr-build-executor.ts

@@ -292,10 +292,10 @@ export async function collectOpenApiFiles(
  *  warned (we can't validate what we won't load). */
 const MAX_VALIDATED_SPEC_BYTES = 5_000_000;
 
-/** Per-spec wall-clock bound. `SwaggerParser.validate` follows external `$ref`
- *  HTTP URLs (json-schema-ref-parser enables the HTTP resolver by default), so
- *  a slow/dead external host could otherwise stall the build. On timeout we
- *  skip the spec (no warning) — a momentarily-down host must not false-warn. */
+/** Per-spec wall-clock bound. `SwaggerParser.validate` follows external
+ *  https `$ref`s (via openapi/safe-ref-resolvers.ts, 10s per ref), and a spec
+ *  with many slow refs could otherwise stall the build. On timeout we skip the
+ *  spec (no warning) — a momentarily-down host must not false-warn. */
 const VALIDATE_SPEC_TIMEOUT_MS = 30_000;
 
 /** SwaggerParser validation errors can be multi-line schema dumps. Keep the
@@ -370,7 +370,9 @@ export async function validateCollectedOpenApiSpecs(
   projectDir: string,
   openApiFiles: readonly OpenApiFileRef[],
   referencedKeys: ReadonlySet<string>,
-  opts: { maxBytes?: number; timeoutMs?: number } = {}
+  // specBoundaryDir: repo root on hosted builds, so a spec's file $refs may
+  // reach a monorepo's shared schemas; see validateOpenApiSpec.
+  opts: { maxBytes?: number; timeoutMs?: number; specBoundaryDir?: string } = {}
 ): Promise<BuildWarning[]> {
   const maxBytes = opts.maxBytes ?? MAX_VALIDATED_SPEC_BYTES;
   const timeoutMs = opts.timeoutMs ?? VALIDATE_SPEC_TIMEOUT_MS;
@@ -409,7 +411,7 @@ export async function validateCollectedOpenApiSpecs(
     try {
       // Bound external-$ref fetches: a tie returns null → skip (no warning).
       const result = await Promise.race([
-        validateOpenApiSpec(relPath, projectDir),
+        validateOpenApiSpec(relPath, projectDir, opts.specBoundaryDir),
         new Promise<null>((resolve) => {
           timeoutHandle = setTimeout(() => resolve(null), timeoutMs);
         }),
@@ -579,22 +581,53 @@ export const ISR_PHASES = {
 
 export type IsrPhase = keyof typeof ISR_PHASES;
 
+/**
+ * Whether `target` (a real path) is strictly inside `dir` (a real path).
+ * Callers must pass realpaths so a symlink cannot hop out of the project.
+ */
+function isRealPathInside(dir: string, target: string): boolean {
+  const rel = path.relative(dir, target);
+  return rel !== '' && rel !== '..' && !rel.startsWith(`..${path.sep}`) && !path.isAbsolute(rel);
+}
+
+/**
+ * Whether `target` (a real path inside `dir`) has a `.git` segment. When the
+ * project is the repo root, .git is inside it and its files (config, logs,
+ * FETCH_HEAD) can hold credentials, so custom JS never reads from there.
+ * Case-insensitive because macOS opens `.GIT/config` as `.git/config`.
+ */
+function isRealPathInGitDir(dir: string, target: string): boolean {
+  return path.relative(dir, target).split(path.sep).some(seg => seg.toLowerCase() === '.git');
+}
+
 /**
  * Collect custom JavaScript content from project directory.
  * Priority: styling.js config > auto-detect .js files in project root.
  * Returns concatenated JS content or null if none found.
+ *
+ * docs.json and the repo are untrusted, and the result is published as the
+ * site's public custom.js. A file is read only when its real path is inside
+ * the project's real path, so neither a `/../` styling.js entry nor a
+ * committed symlink can pull in files from elsewhere on the build machine,
+ * and never from under .git. Symlinks that stay inside the project are
+ * allowed. Mirrors copy-files.cjs and the CLI's custom-assets.ts.
+ *
+ * `boundaryDir` is the directory files must stay in. Hosted builds pass the
+ * cloned repo root so a monorepo's shared script (outside docsDir, inside the
+ * repo) is not silently dropped, matching the OpenAPI spec boundary. The
+ * CLI and copy-files.cjs know no repo root and keep docsDir.
  */
 export function collectCustomJs(
   projectDir: string,
-  config: DocsConfig
+  config: DocsConfig,
+  boundaryDir: string = projectDir
 ): string | null {
   let jsPaths: string[] = [];
 
   if (config.styling?.js) {
-    const configured = Array.isArray(config.styling.js)
+    jsPaths = Array.isArray(config.styling.js)
       ? config.styling.js
       : [config.styling.js];
-    jsPaths = configured.map(p => p.replace(/^\//, ''));
   } else {
     try {
       jsPaths = (fs.readdirSync(projectDir) as string[])
@@ -607,12 +640,30 @@ export function collectCustomJs(
 
   if (jsPaths.length === 0) return null;
 
+  let realBoundaryDir: string;
+  try {
+    realBoundaryDir = fs.realpathSync(boundaryDir);
+  } catch {
+    return null;
+  }
+
   const contents: string[] = [];
   for (const jsPath of jsPaths) {
-    const fullPath = path.join(projectDir, jsPath);
-    if (fs.existsSync(fullPath)) {
-      contents.push(fs.readFileSync(fullPath, 'utf-8'));
+    const fullPath = path.join(projectDir, jsPath.replace(/^\//, ''));
+    if (!fs.existsSync(fullPath)) continue;
+    const realPath = fs.realpathSync(fullPath);
+    if (!isRealPathInside(realBoundaryDir, realPath)) {
+      logger.warn(`Skipping custom JS outside the project: ${jsPath}`);
+      continue;
+    }
+    if (isRealPathInGitDir(realBoundaryDir, realPath)) {
+      logger.warn(`Skipping custom JS inside .git: ${jsPath}`);
+      continue;
     }
+    // A directory named `widgets.js` would throw EISDIR and fail the build;
+    // the CLI preview already skips it.
+    if (!fs.statSync(realPath).isFile()) continue;
+    contents.push(fs.readFileSync(realPath, 'utf-8'));
   }
 
   return contents.length > 0 ? contents.join('\n') : null;

package/vendored/lib/layout-helpers.tsx

@@ -822,10 +822,13 @@ export async function DocsChrome({
           <HtmlLangSync defaultLanguage={projectDefaultLang} />
         </ThemeProvider>
         {/*
-          Inline scripts gated to production — avoids React 19's "scripts
-          inside React components are never executed when rendering on the
-          client" warning in `jamdesk dev`. Same pattern as the
-          project-subdomain hydration suppressor in <head>.
+          Analytics and Crisp stay production-only: they are no-ops on localhost,
+          and the analytics IIFE caused React 19's "scripts inside React
+          components are never executed when rendering on the client" warning in
+          `jamdesk dev` (1.1.68). Custom JS runs in dev so customers can preview
+          it; window.__JAMDESK_DEV__ lets it skip production-only code. With
+          consent gating on, custom JS runs only through ConsentGate, which is
+          production-only.
         */}
         {!consentGating && process.env.NODE_ENV === 'production' && config.integrations?.crisp?.websiteId &&
           /^[a-f0-9-]{36}$/.test(config.integrations.crisp.websiteId) && (
@@ -835,8 +838,12 @@ export async function DocsChrome({
             }}
           />
         )}
-        {!consentGating && process.env.NODE_ENV === 'production' && customJs && (
-          <script dangerouslySetInnerHTML={{ __html: customJs }} />
+        {!consentGating && customJs && (
+          <script
+            dangerouslySetInnerHTML={{
+              __html: process.env.NODE_ENV === 'production' ? customJs : `window.__JAMDESK_DEV__=true;${customJs}`,
+            }}
+          />
         )}
         {!consentGating && process.env.NODE_ENV === 'production' && analyticsScript && (
           <script dangerouslySetInnerHTML={{ __html: analyticsScript }} />

package/vendored/lib/link-rewriter.ts

@@ -6,7 +6,7 @@
  * 1. Bare-slug:    `[Anchor](api-reference/foo)`     → `[Anchor](https://x/docs/api-reference/foo)`
  * 2. Absolute URL: `[Anchor](https://anything/.../api-reference/foo)` → canonical absolute URL
  *
- * Both forms are needed because Haiku at temp 0.3 produces a mix:
+ * Both forms are needed because Haiku produces a mix:
  * - Sometimes copies the `URL:` line from chunk context verbatim (form 2, correct host)
  * - Sometimes emits the pageSlug (form 1)
  * - Sometimes hallucinates a host (form 2, wrong host) — the slug suffix still resolves