vite/src/mdx-exports.ts
/**
* Public re-exports of all MDX components available in Holocron.
*
* Users can import these in their own `.tsx`...
chat-widget-example/vite.config.ts
...vitejs/plugin-react'
import { defineConfig } from 'vite'
import spiceflow from 'spiceflow/vite'
export default defineConfig({
clearScreen: false,
plugins: [spiceflow({ entry: './src/main.tsx'...
cli/src/api-client.ts
... return ''
}
/** Create a client authenticated with a session token (from `holocron login`). */
export function createSessionClient(baseUrl: string, sessionToken: string) {
const safeFetch =...
cli/src/cli.ts
...{ domainCli } from './domains.ts'
import { diagramsCli } from './diagram-fix.ts'
export const cli = goke('holocron')
.option('--api-url [url]', 'Holocron API URL (default:...
cli/src/config.ts
... return path.join(getConfigDir(), 'config.json')
}
const DEFAULT_URL = 'https://holocron.so'
export interface CliConfig {
/** Auth credentials keyed by normalized base URL */
servers?:...
cli/src/create.ts
...")|(\/\/.*)|(\/\*[^]*?\*\/)/g
const stringOrTrailingCommaRe = /("(?:\\?[^])*?")|(,\s*)(?=]|})/g
export const createCli = goke()
createCli
.command('create [dir]', 'Scaffold a new Holocron docs...
cli/src/deploy.ts
...client.ts'
import { logger, colors as c, formatBytes, printActionableError } from './logger.ts'
export const deployCli = goke()
deployCli
.command('deploy', 'Build and deploy your docs site to...
cli/src/device-flow.ts
... store the token.
import * as clack from '@clack/prompts'
import { openInBrowser } from 'goke'
export const CLI_CLIENT_ID = 'holocron-cli'
async function readJson(response: Response):...
cli/src/diagram-fix.test.ts
... ' │',
' React Export Plugin (select Section components)',
' │',
' ...
cli/src/diagram-fix.ts
...return true
}
return false
}
/** Check if a character has ambiguous East Asian width. */
export function isAmbiguousWidth(char: string): boolean {
const cp = char.codePointAt(0)!
return...
cli/src/domains.ts
...{ getManagementClient } from './api-client.ts'
import { logger, colors } from './logger.ts'
export const domainCli = goke()
/** Resolve projectId from --project flag or interactive prompt....
cli/src/keys.ts
...{ getApiClient } from './api-client.ts'
import { logger, colors } from './logger.ts'
export const keysCli = goke()
keysCli
.command('keys create', 'Create a new API key')
...
cli/src/logger.ts
...(vendored picocolors) so no extra dependency is needed.
import { colors } from 'goke'
export { colors }
/** Formatted log helpers — each returns a string, does not print. */
export const...
cli/src/login.ts
...{ getApiClient } from './api-client.ts'
import { logger, colors } from './logger.ts'
export const loginCli = goke()
loginCli
.command('login', 'Authenticate with Holocron via browser...
cli/src/maintain-discovery.test.ts
...'src/api'), { recursive: true })
fs.writeFileSync(path.join(repoRoot, 'src/api/users.ts'), 'export const users = []\n')
fs.writeFileSync(path.join(repoRoot, 'src/config.ts'), 'export const...
cli/src/maintain-discovery.ts
...path from 'node:path'
import childProcess from 'node:child_process'
import YAML from 'yaml'
export type LocalPromptReference = {
kind: 'file' | 'directory'
path: string
}
export type...
cli/src/maintain-events.ts
... Event) => void
}
// Pure event → lines formatter. Keeps only "print once" bookkeeping, no I/O.
export function createEventPrinter({
repoRoot,
rootSessionID,
write,
}: {
repoRoot: string
...
cli/src/maintain-github.ts
...from 'node:child_process'
import { Octokit } from '@octokit/rest'
import { goke } from 'goke'
export type GithubMaintainRelease = {
tagName?: string
name?: string
body?: string
htmlUrl?:...
cli/src/maintain.ts
...PROVIDER_MODEL_MESSAGE = `Use provider/model, for example ${BYOK_MODEL_EXAMPLE}.`
export type MaintainModelChoice =
| { kind: 'hosted'; modelId?: string }
| { kind: 'byok';...
cli/src/projects.ts
...{ getApiClient } from './api-client.ts'
import { logger, colors } from './logger.ts'
export const projectsCli = goke()
projectsCli
.command('projects list', 'List all projects')
...
cli/src/subscribe.ts
...getManagementClient } from './api-client.ts'
import { logger, colors } from './logger.ts'
export const subscribeCli = goke()
/** Prompt for a project selection or fail with usage hint in...
cli/src/website-ambient.d.ts
... class DurableObject {
ctx: any
env: E
constructor(ctx: any, env: E)
}
export { env, waitUntil, DurableObject }
}
declare module '*.css' {}
// Cloudflare Workers globals...
db/drizzle.config.ts
import { defineConfig } from 'drizzle-kit'
export default defineConfig({
out: './drizzle',
schema: './src/schema.ts',
dialect: 'sqlite',
})
db/src/cloudflare.d.ts
...'cloudflare:workers' {
const env: {
DB: D1Database
[key: string]: unknown
}
export { env }
}
db/src/node.ts
...{ drizzle } from 'drizzle-orm/sqlite-proxy'
import * as schema from './schema.ts'
export { schema }
async function queryD1(sql: string, params: any[], method: string) {
//...
db/src/schema.ts
...params
// don't crash D1's .bind() which only accepts string | number | null | ArrayBuffer.
export const epochMs = s.customType<{ data: number; driverParam: number }>({
dataType() { return...
db/src/workerd.ts
...{ drizzle } from 'drizzle-orm/sqlite-proxy'
import * as schema from './schema.ts'
export { schema }
// Convert D1 object rows to positional arrays for sqlite-proxy.
// Same logic as...
example-cloudflare/vite.config.ts
...e/vite-plugin'
import { holocron } from '@holocron.so/vite'
import { defineConfig } from 'vite'
export default defineConfig({
clearScreen: false,
plugins: [
holocron({ pagesDir: './src',...
example/providers/mock-guides.ts
... '```ts',
'import { definePlugin } from "my-package/plugins"',
'',
'export default definePlugin({',
' name: "my-plugin",',
' setup(app) {',
' ...
example/vite.config.ts
...} from 'rollup-plugin-visualizer'
const analyzeBundle = process.env.ANALYZE_BUNDLE === '1'
export default defineConfig({
clearScreen: false,
build: analyzeBundle ? { sourcemap: true } :...
hosting/src/lib/memoize.ts
...CACHE_VERSION = 'v1'
interface CacheEnvelope {
value: T
createdAt: number
}
export interface MemoizeOptions {
namespace: string
fn: (...args: Args)...
hosting/src/worker.ts
...string> = {
'preview.holocron.so': 'holocron-website-preview.remorses.workers.dev',
}
export default {
async fetch(request: Request, env: Env): Promise {
try {
const...
integration-tests/e2e/changelog/changelog.test.ts
... inlined into the virtual changelog page.
expect(html).not.toContain("Could not parse import/exports with acorn");
expect(html).toContain("changelog-hero");
expect(html).toContain("Changel...
integration-tests/e2e/deploy-preview/deploy-preview.test.ts
...} from 'vite'`,
`import { holocron } from '@holocron.so/vite/vite'`,
``,
`export default defineConfig({`,
` clearScreen: false,`,
` plugins: [holocron()],`,
...
integration-tests/e2e/helpers/runtime-debug.ts
...playwright/test";
type ConsoleEntry = {
location: string;
text: string;
type: string;
};
export type RuntimeDebug = {
consoleEntries: ConsoleEntry[];
pageErrors: string[];
...
integration-tests/e2e/helpers/test.ts
...s.kill(-child.pid, "SIGTERM");
await new Promise((resolve) => child.once("exit", resolve));
}
export const test = base.extend({
fixtureServer: [async ({}, use,...
integration-tests/fixtures/base-path/vite.config.ts
...from "../../scripts/e2e-vite-config.ts";
cleanupFixtureRunPaths(resolveFixtureRunPaths());
export default defineConfig(createE2EViteConfig({
base: "/docs",
plugins: [holocron({ pageCache:...
integration-tests/fixtures/changelog/mock-github-server.ts
...so the changelog
* provider's fetch (which runs right after config load) can reach it. */
export async function startMockGitHubServer(): Promise {
if (process.env.HOLOCRON_CHANGELOG_A...
integration-tests/fixtures/changelog/vite.config.ts
...} from "./mock-github-server.ts";
cleanupFixtureRunPaths(resolveFixtureRunPaths());
export default defineConfig(async () => {
await startMockGitHubServer();
return createE2EViteConfig...
integration-tests/fixtures/chat-widget/mock-chat-server.ts
...=> chunk.type === "text-delta")
.map((chunk) => chunk.delta ?? "")
.join("");
}
export type MockChatServer = {
port: number;
close: () => Promise;
};
export async function...
integration-tests/fixtures/chat-widget/vite.config.ts
...} from "./mock-chat-server.ts";
cleanupFixtureRunPaths(resolveFixtureRunPaths());
export default defineConfig(async ({ command }) => {
if (command === "serve") {
const server =...
integration-tests/fixtures/custom-entry/vite.config.ts
...from '../../scripts/e2e-vite-config.ts'
cleanupFixtureRunPaths(resolveFixtureRunPaths())
export default defineConfig(createE2EViteConfig({
plugins: [
holocron({ entry: './server.tsx',...
integration-tests/fixtures/custom-virtual-modules/vite.config.ts
...String.raw\`# Virtual v2 API\n\nThis page only exists in the virtual config navigation.\`,
}
export async function getMdxSlugs() {
return Object.keys(pages)
}
export function getStaticFiles()...
integration-tests/fixtures/docs-subfolder/vite.config.ts
...from '../../scripts/e2e-vite-config.ts'
cleanupFixtureRunPaths(resolveFixtureRunPaths())
export default defineConfig(createE2EViteConfig({
plugins: [
holocron({ entry: './server.tsx',...
integration-tests/fixtures/openapi-pagesdir/vite.config.ts
...from '../../scripts/e2e-vite-config.ts'
cleanupFixtureRunPaths(resolveFixtureRunPaths())
export default defineConfig(createE2EViteConfig({
plugins: [holocron({ pagesDir: './src', pageCache:...
integration-tests/fixtures/runtime-provider/providers/mock-blog.ts
...=> ({
group: tag,
pages: slugs,
}))
return { groups, mdxContent }
},
}
export default provider
// Expose call count for testing cache behavior
export { generateCallCount }
integration-tests/fixtures/tailwind-scan/vite.config.ts
...from "../../scripts/e2e-vite-config.ts";
cleanupFixtureRunPaths(resolveFixtureRunPaths());
export default defineConfig(createE2EViteConfig({
plugins: [holocron({ pagesDir: "src", pageCache:...
integration-tests/lib/ai-cache.ts
...{ createHash } from 'node:crypto'
import fs from 'node:fs'
import path from 'node:path'
export type AiCacheOptions = {
/** Directory to store cached responses. Defaults to `.aicache`...
integration-tests/playwright.config.ts
...null,
deviceScaleFactor: undefined,
baseURL: `http://localhost:${port}`,
},
}));
export default defineConfig({
globalTeardown: "./scripts/cleanup-e2e.ts",
timeout: 45_000,
...
integration-tests/playwright.deploy-preview.config.ts
...the test talks to holocron.so.
import { defineConfig, devices } from "@playwright/test";
export default defineConfig({
testDir: "e2e/deploy-preview",
timeout: 180_000,
expect: {
...
integration-tests/scripts/cleanup-e2e.ts
... cache and build artifacts.
*/
import { cleanupAllFixtureRunArtifacts } from "./fixtures.ts";
export function cleanupCurrentRunArtifacts(): void {
const runId = process.env["E2E_RUN_ID"]?.trim();...
integration-tests/scripts/e2e-vite-config.ts
...} from "vite";
import { getFixtureCacheDir, getFixtureOutDir } from "./fixtures.ts";
export type FixtureRunPaths = {
fixtureRoot?: string;
cacheDir?: string;
outDir?:...
integration-tests/scripts/fixtures.ts
...No code changes anywhere else.
*/
import fs from "node:fs";
import path from "node:path";
export type Fixture = {
/** Folder name under `fixtures/` (also the Playwright project name and test...
integration-tests/vite.config.ts
...= process.env.E2E_START === "1"
&& /[/\\]basic$/.test(process.env.E2E_FIXTURE_ROOT ?? "");
export default defineConfig(createE2EViteConfig({
build: analyzeBundle ? { sourcemap: true } :...
notaku-shell/vite.config.ts
...notakuRepo =
process.env.NOTAKU_REPO || path.resolve(import.meta.dirname, '../../notaku')
export default defineConfig({
clearScreen: false,
plugins: [
holocron({
pagesDir:...
og-worker/src/ico-utils.ts
...return the first one with
* PNG magic bytes. If none contain PNG data, returns undefined.
*/
export function extractPngFromIco(buf: ArrayBuffer): Uint8Array | undefined {
const view = new...
og-worker/worker-configuration.d.ts
...value?: any);
value: any;
valueOf(): any;
}
type ImportValue = ExportValue | number;
type ModuleImports = Record;
type Imports =...
outrank/src/index.ts
...file (e.g. ./providers/blog.ts):
*
* import { outrank } from '@holocron.so/outrank'
* export default outrank({ apiKey: process.env.OUTRANK_API_KEY! })
*
* Then in docs.json:
*
* {...
vite/scripts/bundle-chat-css.ts
... ' * Injected into the shadow DOM by ChatShadowHost.',
' */',
'',
'// prettier-ignore',
'export const chatCssBundle = ' + JSON.stringify(css),
'',
].join('\n')
fs.writeFileSync(output,...
vite/src/bin.ts
#!/usr/bin/env node
// Thin bin entrypoint: re-exports the Holocron CLI so installing
// @holocron.so/vite also provides the `holocron`...
vite/src/build-navigation-data.test.ts
...rocket\n---\n\n# Home\n',
})
expect(result.dataChunkSource).toContain('export function getIconAtlas()')
expect(result.dataChunkSource).toContain('lucide:rocket')
...
vite/src/build-navigation-data.ts
...{
HolocronMdxParseError,
isHolocronMdxParseError,
} from './lib/logger.ts'
export { HolocronMdxParseError, isHolocronMdxParseError }
export type HolocronNavigationData =...
vite/src/chat/chat-sessions.ts
... capped so storage stays bounded.
*/
import { chatWidgetStore } from './chat-widget-store.ts'
export type StoredChatSession = {
/** chs_... session id (the bearer token used to restore the...
vite/src/chat/chat-store.ts
...safely.
*/
import { createStore } from 'zustand'
import type { ReactNode } from 'react'
export type DrawerState = 'closed' | 'open'
/** Opaque AI SDK ModelMessage JSON. Holocron keeps this...
vite/src/chat/chat-submit.ts
...(cookie or localStorage),
* meaning the page should eagerly restore the conversation. */
export function hasExistingSession(): boolean {
const { chatApiUrl } = chatWidgetStore.getState()
...
vite/src/chat/chat-widget-store.ts
...} from './define-tool.ts'
import type { StoredChatSession } from './chat-sessions.ts'
export type ChatWidgetConfig = {
/** Full API URL for chat requests (e.g. "https://docs.myapp.com/hol...
vite/src/chat/define-tool.ts
...use`)
}
}
/** Schema sent to the gateway so AI SDK can register a manual tool. */
export type ChatToolSchema = {
name: string
description: string
inputJsonSchema: Record
vite/src/chat/index.ts
...ron.so/vite/chat'
*
*
*/
export { ChatWidget } from './chat-widget.tsx'
export type { ChatWidgetProps } from './chat-widget.tsx'...
vite/src/chat/page-tools.ts
...} from './define-tool.ts'
import { chatWidgetStore } from './chat-widget-store.ts'
export type PageAction = {
name: string
description: string
selector: string
}
export type...
vite/src/chat/use-chat-widget.ts
..."result of getServerSnapshot should be cached" warning.
const emptyMessages: never[] = []
export function useChatWidget() {
const isOpen = useSyncExternalStore(chatStore.subscribe, () =>...
vite/src/config.ts
...a string (image path or icon name) or a structured
* `{ name, library?, style? }` object. */
export type ConfigIcon = z.output
/** An anchor — persistent link rendered as a...
vite/src/hooks/use-active-toc.ts
...'react'
/** Last heading whose top is still at or above the sticky-header reading line. */
export function pickActiveHeadingId({
headings,
fallbackId,
offset,
}: {
headings: { id:...
vite/src/index.ts
...for building documentation websites
* from MDX files with a mintlify-compatible config.
*/
export { holocron, type HolocronPluginOptions, type HolocronVirtualModules } from './vite-plugin.ts'
/...
vite/src/lib/changelog/github-releases.ts
...} from 'node:child_process'
import { formatHolocronWarning, logger } from '../logger.ts'
export type GitHubRelease = {
tagName: string
name: string | null
body: string | null
...
vite/src/lib/changelog/parse-source.ts
... isolated makes it unit-testable
* and keeps the provider focused on fetching + rendering.
*/
export type ChangelogSource = {
platform: 'github'
owner: string
repo: string
/** Canonical...
vite/src/lib/changelog/provider.ts
...slug + ext)
if (fs.existsSync(abs)) return abs
}
}
}
return undefined
}
export const changelogProvider: VirtualTabProvider = {
name: 'changelog',
claims: (tab) =>...
vite/src/lib/chat-stream.ts
...consumes. Superset of ChatPart with the control
* messages the proxy forwards verbatim. */
export type ChatStreamPart =
| ChatPart
| { type: 'model-messages'; messages: unknown[] }
| {...
vite/src/lib/cloudflare-base-assets.ts
...tps://cdn.example.com/app/`), where assets are served
* by something other than the Worker.
*/
export function baseToAssetsDir(base: string): string | undefined {
if (!base.startsWith('/'))...
vite/src/lib/code-meta.ts
...*
* Use `metaBool()` at the consumer level to interpret string values as booleans.
*/
export type ParsedCodeMeta = {
title?: string
attributes: Record
}
/**
*...
vite/src/lib/collect-icons.ts
...NavGroup } from '../navigation.ts'
import { isNavGroup, isNavPage } from '../navigation.ts'
export type IconLibrary = HolocronConfig['icons']['library']
export type IconRef = string
export...
vite/src/lib/config-override.ts
...───────────────────────────────────── */
/** Parent → child: apply a config override by key. */
export type ConfigOverrideMessage = {
type: 'config-override'
/** The `doId:hash` key returned by...
vite/src/lib/css-vars.ts
...tailwind-merge'
/** Merge class names with Tailwind conflict resolution (shadcn convention). */
export function cn(...inputs: ClassValue[]) {
return twMerge(clsx(inputs))
}
export interface...
vite/src/lib/empty-mermaid.ts
...so SSR can resolve `#mermaid` here instead of
* bundling the multi-megabyte renderer.
*/
export default {
initialize() {},
async render() {
return { svg: '' }
},
}
vite/src/lib/enrich-navigation.ts
...} from './logger.ts'
const SUPPORTED_ICON_LIBRARIES = new Set(['lucide', 'fontawesome'])
export type EnrichedNavigationData = {
navigation: Navigation
switchers: { versions:...
vite/src/lib/frontmatter.ts
...contains ":". YAML treats this as a nested key. Quote the string: ${trimmed}`,
))
}
}
export function parseFrontmatterObject(content: string): Record {
const source =...
vite/src/lib/git-sha.ts
...the file hasn't changed
* and we skip re-parsing.
*/
import crypto from 'node:crypto'
export function gitBlobSha(content: string): string {
const buf = Buffer.from(content, 'utf-8')
...
vite/src/lib/github-stars.ts
...= 60 * 60
// ── URL parsing ──────────────────────────────────────────────────────────
export function parseGitHubRepo(url: string): { owner: string; repo: string } | null {
if (!url)...
vite/src/lib/highlight-code.test.ts
...module">from './foo'"
`)
})
test('mdx export from', () => {
expect(highlightCode("export { Foo } from './foo'\n", 'mdx')).toMatchInlineSn...
vite/src/lib/holocron-url.ts
...a.env?.VITE_HOLOCRON_URL
?? import.meta.env?.HOLOCRON_URL
?? processEnv?.HOLOCRON_URL
}
export function getHolocronBaseUrl(): string {
return normalizeBaseUrl(readHolocronUrlOverride())
}
...
vite/src/lib/image-processor.ts
...package-version.ts'
const PLACEHOLDER_WIDTH = 16
const CACHE_FILENAME = 'holocron-images.json'
export type ImageMeta = {
width: number
height: number
/** data:image/webp;base64,... — compact...
vite/src/lib/imageboard/provider.ts
...Last edit time (ms since epoch) — git commit time or mtime fallback. */
editTime: number
}
export const imageboardProvider: VirtualTabProvider = {
name: 'imageboard',
claims: (tab) =>...
vite/src/lib/imageboard/video-dimensions.ts
...render
* the video without a fixed aspect ratio in that case.
*/
import fs from 'node:fs'
export type VideoDimensions = { width: number; height: number }
const VIDEO_EXTENSIONS = new...
vite/src/lib/jsonc.ts
...commas before ] or }
const stringOrTrailingCommaRe = /("(?:\\?[^])*?")|(,\s*)(?=]|})/g
export function parseJsonc(text: string): unknown {
text = String(text)
try {
return...
vite/src/lib/jsx-utils.ts
... = Extract['expression'] & { raw?: string }
export type JsxAttribute = NativeJsxAttribute
export type JsxElementNode = NativeJsxElementNode
type...
vite/src/lib/link-utils.ts
... dependency.
*/
/** Check if a URL uses an external or special protocol (case-insensitive). */
export function isExternalUrl(url: string): boolean {
return /^(?:https?:|mailto:|tel:|javascript:)/i...
vite/src/lib/logger.ts
...close: string) {
return (value: string) => enabled ? `${open}${value}${close}` : value
}
export const colors = {
cyan: formatter('\x1b[36m', '\x1b[39m'),
dim: formatter('\x1b[2m',...
vite/src/lib/mcp/provider.ts
... .trim()
}
/* ── Provider ─────────────────────────────────────────────────────────── */
export const mcpProvider: VirtualTabProvider = {
name: 'mcp',
claims: (tab) => !!tab.mcp,
async...
vite/src/lib/mdx-component-names.ts
...map and
* off static placeholder properties in sync.ts. They don't need entries here.
*/
export const SAFE_MDX_COMPONENT_NAMES = [
'p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'Heading', 'a',...
vite/src/lib/mdx-processor.ts
...local='Foo' source='./bar'.
* For `import { X } from './bar'`, local='X' source='./bar'. */
export type ImportBinding = {
local: string
source: string
}
/** An internal link found in MDX...
vite/src/lib/mdx-sections.ts
...'./page-frontmatter.ts'
type FlowJsxNode = Extract
export type MdastSection = {
contentNodes: RootContent[]
asideNodes: RootContent[]
/** Full-span...
vite/src/lib/memoize-node.ts
...value shape or parser output changes.
*/
const CACHE_VERSION = 'v3'
const DEFAULT_MAX = 64
export interface MemoizeOptions {
namespace: string
fn: (...args: Args)...
vite/src/lib/memoize-workerd.ts
...DEFAULT_TTL = 7 * 24 * 60 * 60
const DEFAULT_MAX = 64
let cacheOrigin: string | undefined
export function rememberCacheOrigin(requestUrl: string): void {
if (cacheOrigin) return
...
vite/src/lib/mermaid-browser.ts
/** Browser Mermaid import target for the `#mermaid` package import. */
export { default } from 'mermaid'
vite/src/lib/nav-store.ts
...so the chat widget can be extracted independently.
*/
import { createStore } from 'zustand'
export type NavState = {
navDrawerOpen: boolean
}
export const navStore = createStore(()...
vite/src/lib/normalize-config.ts
...'GitHub',
discord: 'Discord',
slack: 'Slack',
button: 'Button',
link: 'Link',
}
export function normalize(raw: Record): HolocronConfig {
const icons =...
vite/src/lib/normalize-mdx.ts
...} from './logger.ts'
import { stripMdExtFromPath, isExternalUrl } from './link-utils.ts'
export type NormalizedMdx = {
/** Serialized MDX string after all remark transforms */
content:...
vite/src/lib/og-utils.ts
... renders OG images server-side via takumi.
*/
import { holocronUrl } from './holocron-url.ts'
export type OgImageUrlOptions = {
title: string
description?: string | null
iconUrl?: string
...
vite/src/lib/openapi/code-samples.ts
... inside ``.
*/
import { codeFence, fenceTitle } from '../virtual-page-mdx.ts'
export interface OpenApiCodeSample {
/** Prism / fence language id (normalized). */
lang: string
...
vite/src/lib/openapi/curl-generator.ts
...token.
return { flags: [` -H ${quote('Authorization: Bearer ')}`], query: [] }
}
export function generateCurl(op: ExtractedOperation, doc: DereferencedDocument): string {
const...
vite/src/lib/openapi/endpoint-mdx.ts
...normalize-mdx.ts'
import { codeSampleFenceBlocks, extractCodeSamples } from './code-samples.ts'
export type OpWithDoc = { op: ExtractedOperation; doc: DereferencedDocument }
/**
* Emits generated...
vite/src/lib/openapi/endpoint-ref.ts
... slug and returned as `null`.
*/
import { HTTP_METHODS, type HttpMethod } from './process.ts'
export interface EndpointRef {
/** Optional spec file the endpoint belongs to (multi-spec form). */
...
vite/src/lib/openapi/generate.ts
... processOpenAPISpec } from './process.ts'
import { createPageEmitter } from './endpoint-mdx.ts'
export interface GenerateOpenAPIPagesOptions {
/** Raw OpenAPI spec content (YAML or JSON string), a...
vite/src/lib/openapi/process.ts
...upgrade+dereference
* the document is always 3.x but we keep both for type flexibility. */
export type OpenAPIDocument = OpenAPIV3.Document | OpenAPIV3_1.Document
/** Fully dereferenced...
vite/src/lib/openapi/provider.ts
...returned. */
const REST_PLACEHOLDER: ConfigNavGroup = Object.freeze({ group: '', pages: [] })
export const openapiProvider: VirtualTabProvider = {
name: 'openapi',
claims: (tab) =>...
vite/src/lib/package-version.ts
...across releases.
*/
import packageJson from '../../package.json' with { type: 'json' }
export const PACKAGE_VERSION = packageJson.version
vite/src/lib/page-frontmatter.ts
... 'twitter:site',
'twitter:image:width',
'twitter:image:height',
] as const
export type PageSeoMetaKey = (typeof pageSeoMetaKeys)[number]
export const pageFrontmatterSchema =...
vite/src/lib/raw-markdown.ts
...from 'remark-gfm'
/** Check if the request explicitly asks for markdown via Accept header. */
export function isAgentRequest(request: Request): boolean {
const accept = (request.headers.get('acce...
vite/src/lib/redirects.ts
...irects'][number]
/** Substitute `:name` and `:splat` placeholders in a destination template. */
export function interpolateDestination(template: string, params: Record): string {
...
vite/src/lib/remark-code-group.ts
...JSX, so normalize the
* authoring syntax here before safe-mdx tries to render the page.
*/
export function remarkCodeGroup() {
return (tree) => {
visit(tree, 'mdxJsxFlowElement', (node,...
vite/src/lib/remark-details-toggle.test.ts
...website url every 2 seconds with a HEAD request, when the \`etag\` header changes it will re-export the components.
`, remarkDetailsToggle)
expect(result.markdown).toMatchInlineSna...
vite/src/lib/remark-details-toggle.ts
...}
}
return node
})
return [{ ...child, children: cleaned }]
})
}
export function remarkDetailsToggle() {
return (tree: Root) => {
visit(tree, 'mdxJsxFlowElement',...
vite/src/lib/remark-github-callouts.ts
...[{ type: 'mdxJsxAttribute', name: 'title', value: callout.title }],
children,
}
}
export function remarkGithubCallouts() {
return (tree: Root) => {
visit(tree, 'blockquote',...
vite/src/lib/remark-headings.ts
...* Keeps Mintlify's {#custom-id} syntax and injects missing ids on native JSX headings.
*/
export function remarkHeadings(this: { data(): Record }) {
const data =...
vite/src/lib/remark-inline-imports.test.ts
... 
"
`)
})
test('rewrites import sources precisely, not export constants with same string', () => {
const imports = new Map([
...
vite/src/lib/remark-inline-imports.ts
...are removed from the original source). The import
* The virtual module for the .md/.mdx file exports a no-op component
* that is never rendered since all `` usages have been replaced.
*
*...
vite/src/lib/remark-mermaid.ts
... runtime can
* render SVG diagrams instead of treating them like ordinary highlighted code.
*/
export function remarkMermaidCode() {
return (tree) => {
visit(tree, 'code', (node, index,...
vite/src/lib/remark-sidebar-components.ts
...wrappers so the
* section splitter only needs to reason about one sidebar primitive.
*/
export function remarkSidebarComponents() {
return (tree: Root) => {
visit(tree, 'mdxJsxFlowEleme...
vite/src/lib/remark-single-accordion.ts
...front so both single and grouped author
* syntax go through the same component structure.
*/
export function remarkSingleAccordionItems() {
return (tree) => {
visit(tree, 'mdxJsxFlowElement'...
vite/src/lib/remark-test-utils.ts
...type { Root } from 'mdast'
import remarkMdx from 'remark-mdx'
import { remark } from 'remark'
export function runRemarkPlugin(
content: string,
plugin: () => (tree: Root) => void,
) {
const...
vite/src/lib/resolve-icons.ts
...lect-icons.ts'
import { formatHolocronError, formatHolocronWarning, logger } from './logger.ts'
export type IconAtlasEntry = {
/** Inner SVG body (path/g/circle elements), NOT wrapped in
vite/src/lib/runtime-cache.ts
...so there's no need for
* package.json imports conditions or separate build targets.
*/
export interface RuntimeCache {
get(key: string): Promise
set(key: string,...
vite/src/lib/runtime-provider.ts
..."Blog", "provider": "./providers/blog.ts", "base": "blog" }
*
* The provider file default-exports a CustomTabProvider object.
*/
import type { ConfigNavGroup, ConfigNavTab } from...
vite/src/lib/sample.ts
...Schema / OpenAPI schema object.
* Expects a fully dereferenced schema (no $ref pointers).
*/
export function sample(schema: Record): unknown {
return traverse(schema)
}
vite/src/lib/search.ts
...────────────────────── */
/** Flat searchable item derived from NavGroup/NavPage/NavHeading. */
export type SearchEntry = {
label: string
href: string
searchText: string
/** Path-based group...
vite/src/lib/sidebar-widths.test.ts
...
`
expect(computeFromMdx(mdx)).toMatchInlineSnapshot(`460`)
})
test('exports a static widths map for the sidebar components', () => {
expect(COMPONENT_SIDEBAR_WIDTHS).t...
vite/src/lib/sidebar-widths.ts
...1200,
} as const
/** Default right-sidebar width (px). Matches `--grid-nav-width`. */
export const DEFAULT_SIDEBAR_WIDTH: number = GRID_TOKENS['--grid-sidebar-width']
/** Minimum...
vite/src/lib/sync.test.ts
...{ recursive: true })
fs.writeFileSync(path.join(snippetsDir, 'greeting.tsx'), 'export const Greeting = () => hi
')
fs.writeFileSync(path.join(snippetsDir,...
vite/src/lib/sync.ts
... title,
gitSha: `redirect:${slug}`,
headings: [],
frontmatter: { title },
}
}
export type SyncResult = {
navigation: Navigation
/** Version/dropdown metadata with enriched...
vite/src/lib/test-mdx-util.ts
...type { Root } from 'mdast'
import type { MdastSection } from './mdx-sections.ts'
export function formatSectionsToMdx(sections: MdastSection[]): string {
let out = ''
for (const...
vite/src/lib/toc-tree.ts
... 'github-slugger'
/* ── TOC tree types ──────────────────────────────────────────────────── */
export type TocNodeType = 'page' | `h${1 | 2 | 3 | 4 | 5 | 6}`
/** Recursive tree node — the...
vite/src/lib/virtual-page-mdx.ts
...import paths) and
* sync.ts (to resolve inline imports from that virtual directory). */
export function virtualPageDir(pagesDir: string, slug: string): string {
return path.join(pagesDir,...
vite/src/lib/virtual-tab-provider.ts
... ConfigNavTab } from '../config.ts'
import { formatHolocronWarning, logger } from './logger.ts'
export type VirtualTabResult = {
groups: ConfigNavGroup[]
/** slug → virtual MDX string */
...
vite/src/navigation.ts
...variant (string path → `![]()
` or
* library icon; object → library/style aware lookup). */
export type NavIcon = ConfigIcon
/** An enriched tab — reuses the schema-derived base (tab/icon/hidden...
vite/src/router.ts
...} from 'spiceflow/react'
import type { HolocronLoaderData } from './app-factory.tsx'
export { router }
export const href = router.href
/** Typed per-request loader data. Throws if...
vite/src/schema.ts
... 'lucide'])
.optional()
.describe('The icon library to resolve the icon name from'),
})
export const iconSchema = z
.union([lucideIconNameSchema, fontawesomeIconNameSchema, z.string(),...
vite/src/serve-static.ts
// Re-export Spiceflow's static middleware through Holocron so Spiceflow's
// virtual production entry can...
vite/src/site-data.ts
...hasVisibleSidebarEntries, isNavPage, isNavGroup, isVisibleNavPage } from './navigation.ts'
export type HolocronSiteData = {
config: HolocronConfig
navigation: Navigation
switchers: {
...
vite/src/virtual.d.ts
...module 'virtual:holocron-config' {
import type { HolocronConfig } from './config.ts'
export const base: string
export function getConfig(): Promise
}
declare module...
vite/src/vite-plugin.ts
... the user already installed them.
*
* import { holocron } from '@holocron.so/vite/vite'
* export default defineConfig({ plugins: [holocron()] })
*/
import { createHash } from 'node:crypto'
im...
vite/test-mcp-types.ts
import type { Tool, Resource, Prompt } from '@modelcontextprotocol/sdk'
export function example() {
const tool: Tool = {
name: "test_tool",
inputSchema: { type:...
vite/vitest.config.ts
import { defineConfig } from 'vitest/config'
import path from 'node:path'
export default defineConfig({
resolve: {
alias: {
'#memoize': path.resolve(import.meta.dirn...
website/scripts/cf-loader.ts
...are never called, only
// route metadata (schemas, paths) is read by the openapi plugin.
export function resolve(
specifier: string,
context: { parentURL?: string },
next: Function,
)...
website/src/ai-logo.ts
... cropH }
}
// Cache the template blob across requests
let cachedTemplateBlob: Blob | undefined
export const aiLogoApp = new Spiceflow().get(
'/api/ai-logo/:text',
async ({ params, request }: {...
website/src/api-auth.test.ts
...so error assertions check
// `instanceof Error` + `.status`. The class itself is not re-exported from
// `spiceflow/client`, hence the structural check instead of an `instanceof`
// against...
website/src/api.ts
...409 })
}
}
// ── App ─────────────────────────────────────────────────────────────────
export const apiApp = new Spiceflow()
.use(gatewayApp)
.use(deployApp)
.use(domainApp)
...
website/src/auth-redirect.ts
...URLs, never internal RSC transport URLs.
const redirectBase = 'https://holocron.local'
export function normalizeAuthRedirectPath(value: string | undefined): string {
if (!value ||...
website/src/chat-bash-tool.ts
... */
import { tool } from 'ai'
import { Bash } from 'just-bash/browser'
import { z } from 'zod'
export type ChatBashToolOptions = {
files: Record
skillUrls?: string[]
}
type...
website/src/chat-session-do.ts
... from 'cloudflare:workers'
/** Sessions idle longer than this are pruned by the daily alarm. */
export const SESSION_TTL_MS = 30 * 24 * 60 * 60 * 1000
/** Max conversations kept per site; oldest (by...
website/src/config-override-api.ts
...z.record(z.string(), z.unknown()),
doId: z.string().optional(),
mode: z.literal('full'),
})
export const configOverrideApp = new Spiceflow()
// CORS preflight for cross-origin POST from docs...
website/src/config-override-do.ts
...Uint8Array(hashBuffer)]
.map((b) => b.toString(16).padStart(2, '0'))
.join('')
}
export class ConfigOverrideDO extends DurableObject {
constructor(ctx: DurableObjectState, env:...
website/src/dashboard-actions.ts
...createApiKeyInput = z.object({ name: nameSchema, projectId: projectIdSchema })
export async function createApiKeyAction(
input: z.input,
): Promise<{ id:...
website/src/db.ts
...unknown>[]) {
return results.map((row) => Object.keys(row).map((k) => row[k]))
}
export function getDb() {
return drizzle(
async (sql, params, method) => {
const stmt =...
website/src/deploy-api.ts
...* e.g. basePath="/docs/" + project="my-docs-remorses" → "docs-base-my-docs-remorses" */
export function buildBasePathSubdomain(basePath: string, projectSubdomain: string): string {
//...
website/src/deploy-auth.ts
...keys create --name production --project ',
},
{ status: 403 },
)
}
export const GITHUB_OIDC_HEADER = 'x-holocron-github-oidc-token'
const GITHUB_OIDC_JWKS =...
website/src/deploy-email.ts
... node scripts or plain workers. Strings
// work everywhere.
import dedent from 'string-dedent'
export interface DeployEmailData {
githubOwner: string
githubRepo: string
url: string
branch:...
website/src/domain-api.ts
... Domain is not fully active; ensure no stale KV entry exists
await env.SITES_KV.delete(key)
}
export const domainApp = new Spiceflow()
// ── Add a custom domain ─────────────────────────────────...
website/src/gateway.ts
...(chat/chat-store.ts).
// Both sides must stay in sync — this crosses a network boundary.
export type HolocronChatNoticeChunk = {
type: 'notice'
code: string
title: string
message:...
website/src/globals.d.ts
...path="../worker-configuration.d.ts" />
declare module '*.css' {
const content: string
export default content
}
declare module 'jpeg-js' {
interface DecodedJPEG {
width: number
...
website/src/lib/ai-models.ts
...Order matters for chat: the first entry is the primary model; the rest are fallbacks.
export const DEFAULT_MODEL = 'deepseek-v4-flash'
export const ALLOWED_MODELS: Record...
website/src/lib/billing-rules.ts
...that own many Holocron projects under one org.
import type { OrgPlan } from 'db/schema'
export const PRO_PRICE_LOOKUP_KEYS = {
monthly: 'pro_monthly',
yearly: 'pro_yearly',
} as...
website/src/lib/cloudflare.ts
...The zone is holocron.so for all custom hostnames.
import { env } from 'cloudflare:workers'
export type CloudflareSSLStatus =
| 'initializing'
| 'pending_validation'
| 'deleted'
|...
website/src/lib/credits.ts
...dollar layer.
/** Real USD spend one credit represents. The only exchange-rate knob. */
export const USD_PER_CREDIT = 0.001
/** Free projects: 5,000 credits = $5/month. */
export const...
website/src/lib/memoize.ts
... CACHE_BASE = 'https://0.0.0.0/'
interface CacheEnvelope {
value: T
createdAt: number
}
export interface MemoizeOptions {
namespace: string
fn: (...args: Args)...
website/src/lib/product-events.ts
...API keys, session tokens, or raw user content.
import { track } from '@strada.sh/sdk'
export type ProductEventName =
| 'project.created'
| 'project.deleted'
| 'org.created'
|...
website/src/lib/stripe-webhook.ts
...} from '@strada.sh/sdk'
import { getStripe, handleSubscriptionChange } from './stripe.ts'
export class WebhookSignatureError extends errore.createTaggedError({
name: 'WebhookSignatureError',
...
website/src/lib/stripe.ts
... './product-events.ts'
// ── Tagged errors ───────────────────────────────────────────────────
export class StripeApiError extends errore.createTaggedError({
name: 'StripeApiError',
message:...
website/src/lib/utils.ts
... classes.
import { clsx, type ClassValue } from 'clsx'
import { twMerge } from 'tailwind-merge'
export function cn(...inputs: ClassValue[]) {
return twMerge(clsx(inputs))
}
/** Format an epoch-ms...
website/src/maintain-api.ts
...MaintainRunToken = {
runId: string
projectId: string
orgId: string
exp: number
}
export type ChatUsage = {
inputTokens: number
outputTokens: number
cachedInputTokens: number
...
website/src/strada-client.ts
...so initStrada()
// runs once when the module loads in the browser.
//
// The `browser` export condition resolves `@strada.sh/sdk` to the browser
// entry, which sets up WebTracerProvider,...
website/src/strada-ssr.ts
...runs
// at module evaluation time, before Spiceflow creates any spans.
//
// The `workerd` export condition resolves `@strada.sh/sdk` to the Cloudflare
// Workers entry, which uses...
website/src/test/seed.ts
... schema from 'db/schema'
import { ulid } from 'ulid'
const YEAR_MS = 1000 * 60 * 60 * 24 * 365
export interface SeededUser {
userId: string
/** Send as `Authorization: Bearer ` to...
website/src/usage-counter-do.ts
... capped independently of its paid siblings.
import { DurableObject } from 'cloudflare:workers'
export const NOTICE_USAGE_LIMIT_REACHED = {
type: 'notice',
code: 'HOLOCRON_USAGE_LIMIT_REACHED',
...
website/vite.config.ts
...} from 'rollup-plugin-visualizer'
const analyzeBundle = process.env.ANALYZE_BUNDLE === '1'
export default defineConfig({
server: { port: 7664, strictPort: true },
clearScreen: false,
...
website/vitest.config.ts
...{ stradaVitePlugin } from '@strada.sh/sdk/vite'
import { defineConfig } from 'vite'
export default defineConfig(async () => {
// D1 migrations live in the shared db package (flat .sql...
website/worker-configuration.d.ts
...value?: any);
value: any;
valueOf(): any;
}
type ImportValue = ExportValue | number;
type ModuleImports = Record;
type Imports =...