@barefootjs/vite 0.30.0

package/dist/manifest.d.ts

@@ -0,0 +1,39 @@
+import type { Manifest } from 'vite';
+/** Read and parse the manifest Vite just wrote to `outDir`. `manifestOption`
+ * mirrors `build.manifest`: `true` → the default `.vite/manifest.json`
+ * path; a string → that custom path, relative to `outDir`. */
+export declare function loadManifest(outDir: string, manifestOption: boolean | string): Promise<Manifest>;
+/** Join a Vite `base` (may or may not have a trailing slash; may be a full
+ * URL, an absolute path, or `'./'`) with a manifest-relative file path
+ * (never starts with `/`) into the URL an adapter should register. */
+export declare function joinBaseAndFile(base: string, file: string): string;
+/**
+ * The ordered `scriptAssets` list for one component's entry, per the
+ * design: just the entry's own hashed file — shared chunks (including the
+ * `@barefootjs/client` runtime) arrive as ESM imports the browser follows
+ * on its own, so they need no separate registration. `[]` when the entry
+ * isn't in the manifest (e.g. a `'use client'` file whose compile produced
+ * no client JS at all, or a stale discovery/build mismatch).
+ */
+export declare function resolveScriptAssets(manifest: Manifest, manifestKey: string, base: string): string[];
+/**
+ * The ordered `preloadAssets` list for one component's entry: every chunk
+ * the entry pulls in **transitively** via static `imports`, excluding the
+ * entry's own file (that one is already covered by `resolveScriptAssets`).
+ *
+ * Walked **breadth-first** from the entry so the chunks most likely to be
+ * shared across components (the runtime chunk, common child islands) sort
+ * first, and deduped by manifest key — both needed to keep the returned
+ * order deterministic across builds; a rebuild that reshuffles this list
+ * for no reason would show up as a spurious template diff. A `seen` set
+ * keyed by manifest key also guards against import cycles.
+ *
+ * Deliberately does NOT follow `dynamicImports`: a dynamic import is by
+ * definition not needed for first paint — the app chose to defer it — and
+ * preloading it would pull that deferred work forward, defeating the
+ * point of having split it out.
+ *
+ * `[]` when the entry isn't in the manifest, same as `resolveScriptAssets`.
+ */
+export declare function resolvePreloadAssets(manifest: Manifest, manifestKey: string, base: string): string[];
+//# sourceMappingURL=manifest.d.ts.map

package/dist/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../src/manifest.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,MAAM,CAAA;AAEpC;;8DAE8D;AAC9D,wBAAsB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAItG;AAED;;sEAEsE;AACtE,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAGlE;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,EAClB,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,MAAM,GACX,MAAM,EAAE,CAIV;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,QAAQ,EAClB,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,MAAM,GACX,MAAM,EAAE,CAmBV"}

package/dist/paths.d.ts

@@ -0,0 +1,57 @@
+/** Posix-normalized path of `absPath` relative to `root` (manifest keys and
+ * Rollup `input` specifiers both want forward slashes regardless of OS). */
+export declare function toPosixRelative(root: string, absPath: string): string;
+/**
+ * A `rollupOptions.input` OBJECT KEY safe for `absPath`, given the Vite
+ * project root — NOT the same thing as a manifest lookup key (Vite's own
+ * manifest is keyed by the source file's root-relative path regardless of
+ * what name you give an entry here; see `manifest.ts` / `writeBundle` in
+ * `plugin.ts`, which never call this and must not start).
+ *
+ * Rollup uses an object-form `input`'s key AS THE CHUNK NAME (the `[name]`
+ * substitution in `output.entryFileNames`), and REJECTS a name that is
+ * itself an absolute or parent-relative path outright
+ * (`Invalid substitution "…" for placeholder "[name]"`) — which
+ * `toPosixRelative(root, absPath)` produces whenever `absPath` is OUTSIDE
+ * `root`, exactly the common case this monorepo's real layouts hit (a
+ * `components` dir that's a SIBLING of, not a descendant of, the app's
+ * Vite root — see `plugin.ts`'s `configureServer` docstring for the same
+ * layout fact from the dev side). Falls back to `absPath`'s position under
+ * whichever configured `componentDirs` entry contains it (the same
+ * mirroring `relativeUnderComponentDir` already does for emitted template
+ * paths) — short and readable (`blog/LikeButton`), unlike falling all the
+ * way back to the bare filesystem-rooted absolute path, which would work
+ * (no `..` possible once `path.resolve()`-normalized) but bakes the
+ * building machine's own directory structure into every output filename.
+ */
+export declare function safeRollupEntryName(root: string, absPath: string, componentDirs: readonly string[]): string;
+/**
+ * `absPath`'s position relative to whichever `componentDirs` entry
+ * contains it (POSIX, WITH extension) — e.g. `ui/button/index.tsx` for
+ * `<componentDir>/ui/button/index.tsx`. Falls back to the bare basename
+ * when the file isn't under any configured dir (shouldn't happen for
+ * discovered files, but keeps this total).
+ */
+export declare function relativeUnderComponentDir(absPath: string, componentDirs: readonly string[]): string;
+/** Swap `.tsx`/`.ts` for `newExtension` (e.g. adapter.extension, or
+ * `.ssr-defaults.json`) on a POSIX relative path. */
+export declare function withExtension(relPath: string, newExtension: string): string;
+/**
+ * Output path (relative to `templatesDir`, still POSIX) for a
+ * `templatesPerComponent` adapter's per-component file — same directory as
+ * the source file's mirror, named after the exported component instead of
+ * the source basename (Mojolicious-style template lookup by component
+ * name).
+ */
+export declare function perComponentRelPath(relUnderComponentDir: string, componentName: string, extension: string): string;
+/**
+ * Build a `rewriteRelativeImport` function for `compileJSX` — re-anchors a
+ * relative specifier written in `sourcePath` so it still resolves once the
+ * template is emitted to `outputPath` under `templatesDir` instead of
+ * living beside its source. Implemented standalone for the reason in this
+ * file's header comment. Only exercised by adapters whose templates carry
+ * real `import` statements (Hono-shaped JS-runtime adapters) — Go/Mojo/etc.
+ * templates have no import syntax and never call this.
+ */
+export declare function buildRelativeImportRewriter(sourcePath: string, outputPath: string, componentDirs: readonly string[], templatesDir: string): (importPath: string) => string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../src/paths.ts"],"names":[],"mappings":"AAUA;4EAC4E;AAC5E,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAErE;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAI3G;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAQnG;AAED;qDACqD;AACrD,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAE3E;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,oBAAoB,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAGlH;AAED;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,SAAS,MAAM,EAAE,EAChC,YAAY,EAAE,MAAM,GACnB,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,CAmBhC"}

package/dist/plugin.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from 'vite';
+import type { BarefootViteOptions } from './types.ts';
+export declare const PLUGIN_NAME = "barefoot";
+export declare function barefoot(options: BarefootViteOptions): Plugin;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAkEA,OAAO,KAAK,EAAE,MAAM,EAAiC,MAAM,MAAM,CAAA;AAMjE,OAAO,KAAK,EAAqB,mBAAmB,EAAE,MAAM,YAAY,CAAA;AA+BxE,eAAO,MAAM,WAAW,aAAa,CAAA;AAuCrC,wBAAgB,QAAQ,CAAC,OAAO,EAAE,mBAAmB,GAAG,MAAM,CAyoB7D"}

package/dist/resolve-client-js.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Resolve `source` (an import specifier seen by Vite's `resolveId`) to the
+ * real `.tsx` file it stands in for, or `null` if this shim doesn't apply.
+ */
+export declare function resolveClientJsSpecifier(source: string, importer: string | undefined): string | null;
+//# sourceMappingURL=resolve-client-js.d.ts.map

package/dist/resolve-client-js.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-client-js.d.ts","sourceRoot":"","sources":["../src/resolve-client-js.ts"],"names":[],"mappings":"AAqBA;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAQpG"}

package/dist/types.d.ts

@@ -0,0 +1,141 @@
+import type { TemplateAdapter } from '@barefootjs/jsx';
+/**
+ * Narrow context handed to `afterEmit` once per eager pass (`writeBundle`
+ * for `vite build`, the dev pass for `vite dev`) — AFTER every discovered
+ * component's template has already been written to `templatesDir`. This is
+ * the one escape hatch this plugin exposes, and its shape is deliberately
+ * minimal:
+ *
+ * - `types`: adapter-generated `types` fragments (e.g. Go Props structs)
+ *   this pass produced, keyed by the source file's absolute path. Raw,
+ *   per-file, uncombined — combining them into a single backend-native
+ *   file (stripping headers, deduping, injecting shared helpers) is a
+ *   real per-language operation an adapter's own `/vite` subpath performs
+ *   (see `@barefootjs/go-template/vite`'s use of `combineGoTypes`), not
+ *   something core knows how to do generically.
+ * - `projectDir` / `templatesDir` / `outDir`: the same absolute paths the
+ *   plugin itself just used to write templates and (for `outDir`) that
+ *   Vite wrote client assets to.
+ * - `mode`: which eager pass just ran. Go's `components.go` (and any other
+ *   adapter-side derived file) has to exist for `go run .` to even compile
+ *   in dev, which is why this fires from BOTH passes, not just the build
+ *   one — a hook named `postBuild` would misleadingly suggest otherwise.
+ *
+ * What this deliberately does NOT carry: emitted client JS. That's the
+ * one thing a caller must never be handed to rewrite post-compile (see
+ * CLAUDE.md's "never add compiler options/hooks for tool-specific output
+ * rewriting") — closing that door by TYPE, not by convention, is the
+ * point of keeping this context this narrow.
+ */
+export interface AfterEmitContext {
+    /** Per-source-file `types` output, keyed by that file's absolute path.
+     * Empty when no discovered file in this pass produced a `types` output. */
+    types: Map<string, string>;
+    /** Absolute path to the Vite project root. */
+    projectDir: string;
+    /** Absolute path to the configured `templates` output dir. */
+    templatesDir: string;
+    /** Absolute path to Vite's configured `build.outDir`. */
+    outDir: string;
+    /** Which eager pass just ran. */
+    mode: 'build' | 'dev';
+}
+/**
+ * One `components` entry with per-directory compile behavior. A plain
+ * string is exactly equivalent to `{ dir: string }` — see
+ * `BarefootViteOptions.components`.
+ */
+export interface ComponentDirEntry {
+    /** Source directory to scan, relative to the Vite root (or absolute). */
+    dir: string;
+    /** `CompileOptions.cssLayerPrefix` for every component under `dir`:
+     *  static class strings get `layer-{value}:` prefixes so a library's
+     *  base classes land in a lower cascade layer than app overrides. Set
+     *  it on library entries, leave it off app entries. */
+    cssLayerPrefix?: string;
+    /** Directory NAMES to skip anywhere under `dir` (e.g. `['shared']`). */
+    skipDirs?: string[];
+}
+/**
+ * Public options for the `barefoot()` Vite plugin. Exactly three
+ * BarefootJS-specific FIELDS — everything else (bundling, hashing,
+ * chunking, tree-shaking, minification, dev server, `base`, `outDir`) is
+ * stock Vite config. Do not add more fields here; see the design doc for
+ * the full list of options this deliberately drops in favor of Vite's own
+ * equivalents (`minify` → `build.minify`, `externals` → Rollup's automatic
+ * chunk splitting, `clientJsBasePath`/`barefootJsPath` → `base` + manifest
+ * resolution, etc).
+ *
+ * The cap is on FIELDS, not on per-directory expressiveness: whether a
+ * directory's classes need a CSS cascade layer, or which subdirectories to
+ * skip, is a function of WHICH `components` entry a file came from — so
+ * that behavior rides on the `components` entries themselves
+ * (`ComponentDirEntry`) rather than becoming a 4th/5th top-level option.
+ */
+export interface BarefootViteOptions {
+    /** A constructed `TemplateAdapter` instance (e.g. `new
+     * GoTemplateAdapter({ packageName: 'main' })`). Not a factory function —
+     * the plugin never constructs adapters itself. */
+    adapter: TemplateAdapter;
+    /** Source directories to scan for `.tsx` components, relative to the
+     * Vite project root (or absolute). A plain string is exactly equivalent
+     * to `{ dir: string }` (a `ComponentDirEntry` with no `cssLayerPrefix`/
+     * `skipDirs`) — use the object form only when a directory needs one of
+     * those. Entries are processed in array order, and that order is also
+     * the precedence when the same file is reachable under more than one
+     * entry: the first entry wins. */
+    components: (string | ComponentDirEntry)[];
+    /**
+     * Where compiled templates, `ssrDefaults`, and adapter-generated types
+     * land — relative to the Vite project root (or absolute). This is a
+     * backend source directory the server-side app reads, NOT
+     * `build.outDir` (which is Vite's client-asset output).
+     *
+     * Optional for an adapter whose `generate()` output is ALWAYS empty
+     * (e.g. `CSRAdapter` — CSR has no template-language backend to point a
+     * `templates` dir at). When omitted, the eager pass still compiles every
+     * discovered component (client JS generation is unaffected) but writes
+     * nothing to disk on its behalf — no per-component template/ssrDefaults/
+     * types files, no `manifest.json`. If some discovered component turns
+     * out to produce a REAL (non-empty) template anyway, the eager pass
+     * refuses loudly instead of silently dropping it: omitting `templates`
+     * is a claim about the adapter's output that this plugin verifies rather
+     * than trusts. See `plugin.ts`'s `assertNoRealTemplateOutput`.
+     */
+    templates?: string;
+    /**
+     * Optional escape hatch called once per eager pass (build AND dev), after
+     * templates are written, with a narrow `AfterEmitContext`. NOT a
+     * user-facing 4th option in the design-doc sense — it exists so an
+     * adapter's own `/vite` subpath (e.g. `@barefootjs/go-template/vite`) can
+     * wire up its own per-language post-processing (e.g. combining `types`
+     * into a single `components.go`) while calling this core plugin
+     * underneath. See `AfterEmitContext`'s docstring for what it can and
+     * cannot see.
+     */
+    afterEmit?: (ctx: AfterEmitContext) => Promise<void> | void;
+}
+/**
+ * Shape exposed on the returned plugin's `.api` — Vite's own convention
+ * (a plugin may attach an `api` property "designed for other plugins or
+ * Vite-based tools to access") for exactly this: tooling that wants this
+ * plugin's resolved options without re-deriving them from `vite.config.ts`
+ * text. The `bf` CLI (`packages/cli/src/context.ts`) is the one consumer
+ * today — it uses Vite's own `loadConfigFromFile` to get the resolved
+ * config, finds the plugin by name (`PLUGIN_NAME`, exported from
+ * `plugin.ts`) in its `plugins` array, and reads `api.options.components`
+ * as `sourceDirs`.
+ *
+ * Populated synchronously the moment `barefoot(options)` is called —
+ * `options` needs no Vite lifecycle hook to have already run, deliberately:
+ * `loadConfigFromFile` never calls a plugin's hooks (`config`,
+ * `configResolved`, ...) at all, it just evaluates `vite.config.ts` and
+ * returns the resulting plugin instances, so anything gated behind
+ * `configResolved` (e.g. the plugin's own resolved absolute `componentDirs`)
+ * would never be visible to a caller going through that path.
+ */
+export interface BarefootPluginApi {
+    /** The exact options object `barefoot()` was constructed with. */
+    options: BarefootViteOptions;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,WAAW,gBAAgB;IAC/B;+EAC2E;IAC3E,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC1B,8CAA8C;IAC9C,UAAU,EAAE,MAAM,CAAA;IAClB,8DAA8D;IAC9D,YAAY,EAAE,MAAM,CAAA;IACpB,yDAAyD;IACzD,MAAM,EAAE,MAAM,CAAA;IACd,iCAAiC;IACjC,IAAI,EAAE,OAAO,GAAG,KAAK,CAAA;CACtB;AAED;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,yEAAyE;IACzE,GAAG,EAAE,MAAM,CAAA;IACX;;;2DAGuD;IACvD,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,wEAAwE;IACxE,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;CACpB;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,mBAAmB;IAClC;;sDAEkD;IAClD,OAAO,EAAE,eAAe,CAAA;IACxB;;;;;;sCAMkC;IAClC,UAAU,EAAE,CAAC,MAAM,GAAG,iBAAiB,CAAC,EAAE,CAAA;IAC1C;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;;;;;;;;OASG;IACH,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,gBAAgB,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;CAC5D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,iBAAiB;IAChC,kEAAkE;IAClE,OAAO,EAAE,mBAAmB,CAAA;CAC7B"}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@barefootjs/vite",
+  "version": "0.30.0",
+  "description": "Vite plugin for BarefootJS: Vite/Rollup owns bundling, hashing, chunking, tree-shaking and minification of client assets, BarefootJS keeps only the JSX to (template, client JS) compile",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "bun run build:js && bun run build:types",
+    "build:js": "bun build ./src/index.ts --outfile ./dist/index.js --format esm --target node --external vite --external typescript",
+    "build:types": "tsgo --emitDeclarationOnly --outDir ./dist",
+    "test": "bun test",
+    "clean": "rm -rf dist",
+    "prepack": "node ../../scripts/swap-publish-config.mjs pack",
+    "postpack": "node ../../scripts/swap-publish-config.mjs unpack"
+  },
+  "keywords": [
+    "vite",
+    "vite-plugin",
+    "barefoot",
+    "ssr"
+  ],
+  "author": "kobaken <kentafly88@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/piconic-ai/barefootjs",
+    "directory": "packages/vite"
+  },
+  "dependencies": {
+    "@barefootjs/shared": "0.30.6"
+  },
+  "peerDependencies": {
+    "@barefootjs/jsx": ">=0.2.0",
+    "vite": "^6.0.0"
+  },
+  "devDependencies": {
+    "@barefootjs/client": "0.30.6",
+    "@barefootjs/go-template": "0.30.6",
+    "@barefootjs/hono": "0.30.6",
+    "@barefootjs/jsx": "0.30.6",
+    "typescript": "^5.0.0",
+    "vite": "^6.0.0"
+  }
+}

package/src/__tests__/child-marker.test.ts

@@ -0,0 +1,24 @@
+import { describe, test, expect } from 'bun:test'
+import { bfChildMarkerName, BF_CHILD_NOOP_ID } from '../child-marker.ts'
+
+describe('bfChildMarkerName', () => {
+  test('extracts the child name from a compiler-emitted marker', () => {
+    expect(bfChildMarkerName('/* @bf-child:TodoItem */')).toBe('TodoItem')
+  })
+
+  test('returns null for a normal specifier', () => {
+    expect(bfChildMarkerName('./TodoItem')).toBeNull()
+    expect(bfChildMarkerName('@barefootjs/client')).toBeNull()
+  })
+
+  test('returns null for a marker-shaped string with extra characters', () => {
+    expect(bfChildMarkerName('/* @bf-child:TodoItem */extra')).toBeNull()
+    expect(bfChildMarkerName('prefix/* @bf-child:TodoItem */')).toBeNull()
+  })
+})
+
+describe('BF_CHILD_NOOP_ID', () => {
+  test('is a virtual (null-byte-prefixed) module id', () => {
+    expect(BF_CHILD_NOOP_ID.startsWith('\0')).toBe(true)
+  })
+})

package/src/__tests__/compile-cache.test.ts

@@ -0,0 +1,73 @@
+import { describe, test, expect } from 'bun:test'
+import { CompileCache } from '../compile-cache.ts'
+import type { CompileResult } from '@barefootjs/jsx'
+
+function fakeResult(tag: string): CompileResult {
+  return { files: [{ path: tag, content: tag, type: 'clientJs' }], errors: [] }
+}
+
+describe('CompileCache', () => {
+  test('compiles once for the same (path, content) pair', () => {
+    const cache = new CompileCache()
+    let calls = 0
+    const compile = () => {
+      calls++
+      return fakeResult('a')
+    }
+
+    const first = cache.getOrCompile('/a.tsx', 'content', compile)
+    const second = cache.getOrCompile('/a.tsx', 'content', compile)
+
+    expect(calls).toBe(1)
+    expect(first).toBe(second)
+  })
+
+  test('recompiles when the content changes', () => {
+    const cache = new CompileCache()
+    let calls = 0
+    const compile = () => {
+      calls++
+      return fakeResult(`v${calls}`)
+    }
+
+    const first = cache.getOrCompile('/a.tsx', 'v1', compile)
+    const second = cache.getOrCompile('/a.tsx', 'v2', compile)
+
+    expect(calls).toBe(2)
+    expect(first).not.toBe(second)
+  })
+
+  test('tracks distinct paths independently', () => {
+    const cache = new CompileCache()
+    let calls = 0
+    const compile = () => {
+      calls++
+      return fakeResult(`n${calls}`)
+    }
+
+    cache.getOrCompile('/a.tsx', 'same', compile)
+    cache.getOrCompile('/b.tsx', 'same', compile)
+
+    expect(calls).toBe(2)
+  })
+
+  test('peek returns undefined before any compile and the cached result after', () => {
+    const cache = new CompileCache()
+    expect(cache.peek('/a.tsx')).toBeUndefined()
+    const result = cache.getOrCompile('/a.tsx', 'content', () => fakeResult('a'))
+    expect(cache.peek('/a.tsx')).toBe(result)
+  })
+
+  test('clear() forces a recompile', () => {
+    const cache = new CompileCache()
+    let calls = 0
+    const compile = () => {
+      calls++
+      return fakeResult('a')
+    }
+    cache.getOrCompile('/a.tsx', 'content', compile)
+    cache.clear()
+    cache.getOrCompile('/a.tsx', 'content', compile)
+    expect(calls).toBe(2)
+  })
+})