Add revalidatePaths

.changeset/cool-seas-approve.md

@@ -0,0 +1,5 @@
+---
+"gitbook": patch
+---
+
+Fix navigation between sections/variants when previewing a site in v2

.changeset/nasty-moles-visit.md

@@ -0,0 +1,5 @@
+---
+"gitbook-v2": patch
+---
+
+fix ISR on preview env

.changeset/rotten-seals-rush.md

@@ -0,0 +1,5 @@
+---
+'@gitbook/react-openapi': patch
+---
+
+Indent JSON python code sample

.changeset/slow-lizards-obey.md

@@ -0,0 +1,5 @@
+---
+"gitbook": patch
+---
+
+Make TOC height dynamic based on visible header and footer elements

.changeset/stupid-plums-perform.md

@@ -0,0 +1,6 @@
+---
+"gitbook": patch
+"gitbook-v2": patch
+---
+
+cache fonts and static image used in OGImage in memory

.changeset/thin-buckets-grow.md

@@ -0,0 +1,5 @@
+---
+"gitbook-v2": patch
+---
+
+Add `urlObject.hash` to `linker.toLinkForContent` to pass through URL fragment identifiers, used in search

.github/CODEOWNERS

@@ -1,3 +0,0 @@
-# Changes to the API data cache functions can invalidate all existing data cache
-# causing a massive amount of revalidation, impacting our API.
-packages/gitbook/src/lib/data/api.ts   @SamyPesse

.github/CONTRIBUTING.md

@@ -53,40 +53,17 @@ After forking this repository, you'll want to [create a branch](https://docs.git
 
 #### 3. Install dependencies and run the project locally
 
-##### Prerequisites:
+GitBook uses [Bun](https://bun.sh/) to run the project. Make sure you're using the specified version of `node` before running any of the development commands to ensure a smooth development experience.
-- Node.js (Version: >=20.6)
-  - Use `nvm` for easy Node management
-- [Bun](https://bun.sh/) (Version: >=1.2.15)
-  - We use a text-based lockfile which isn't supported below 1.2.15
 
-##### Setup steps:
+You can easily do this by running the command `nvm use`.
 
-1. Ensure you are using the project's version of Node:
+To start your local version of GitBook, run the command `bun dev`.
-```bash
-nvm use
-```
-
-2. Install dependencies using Bun:
-```bash
-bun install
-```
-
-3. Start the development server:
-```bash
-bun dev
-```
-
-Additional development commands:
-- `bun format`: Format the code using Biome
-- `bun typecheck`: Run TypeScript type checking
-- `bun unit`: Run unit tests
-- `bun e2e`: Run end-to-end tests
 
 #### 4. Preview your changes
 
-When running the development server, published GitBook sites can be rendered through your local version at `http://localhost:3000/url`.
+When running the development server, published GitBook sites can be rendered through your local version at `http://localhost:3000/`.
 
-For example, our published docs can be viewed using the local version by visiting `http://localhost:3000/url/gitbook.com/docs` after running the development server.
+For example, our published docs can be viewed using the local version by visiting `http://localhost:3000/gitbook.com/docs` after running the development server.
 
 You can visit any published GitBook site behind your development server. Please make sure your site is [published publicly](https://gitbook.com/docs/published-documentation/publish-your-content-as-a-docs-site) to ensure you can view the site correctly in your development version.
 

.github/actions/gradual-deploy-cloudflare/action.yaml

@@ -1,83 +0,0 @@
-name: Gradual Deploy to Cloudflare
-description: Use gradual deployment to deploy to Cloudflare. This action will upload the middleware and server versions to Cloudflare and kept them bound together
-inputs:
-  apiToken:
-    description: 'Cloudflare API token'
-    required: true
-  accountId:
-    description: 'Cloudflare account ID'
-    required: true
-  environment:
-    description: 'Cloudflare environment to deploy to (staging, production, preview)'
-    required: true
-  middlewareVersionId:
-    description: 'Middleware version ID to deploy'
-    required: true
-  serverVersionId:
-    description: 'Server version ID to deploy'
-    required: true
-outputs:
-  deployment-url: 
-    description: "Deployment URL"
-    value: ${{ steps.deploy_middleware.outputs.deployment-url }}
-runs:
-  using: 'composite'
-  steps:
-      - id: wrangler_status
-        name: Check wrangler deployment status
-        uses: cloudflare/wrangler-action@v3.14.0
-        with:
-            apiToken: ${{ inputs.apiToken }}
-            accountId: ${{ inputs.accountId }}
-            workingDirectory: ./
-            wranglerVersion: '4.10.0'
-            environment: ${{ inputs.environment }}
-            command: deployments status --config ./packages/gitbook/openNext/customWorkers/defaultWrangler.jsonc
-
-      # This step is used to get the version ID that is currently deployed to Cloudflare.
-      - id: extract_current_version
-        name: Extract current version
-        shell: bash
-        run: |
-          version_id=$(echo "${{ steps.wrangler_status.outputs.command-output }}" | grep -A 3 "(100%)" | grep -oP '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}')
-          echo "version_id=$version_id" >> $GITHUB_OUTPUT
-
-      - id: deploy_server
-        name: Deploy server to Cloudflare at 0%
-        uses: cloudflare/wrangler-action@v3.14.0
-        with:
-            apiToken: ${{ inputs.apiToken }}
-            accountId: ${{ inputs.accountId }}
-            workingDirectory: ./
-            wranglerVersion: '4.10.0'
-            environment: ${{ inputs.environment }}
-            command: versions deploy ${{ steps.extract_current_version.outputs.version_id }}@100% ${{ inputs.serverVersionId }}@0% -y --config ./packages/gitbook/openNext/customWorkers/defaultWrangler.jsonc
-
-      # Since we use version overrides headers, we can directly deploy the middleware to 100%.
-      - id: deploy_middleware
-        name: Deploy middleware to Cloudflare at 100%
-        uses: cloudflare/wrangler-action@v3.14.0
-        with:
-            apiToken: ${{ inputs.apiToken }}
-            accountId: ${{ inputs.accountId }}
-            workingDirectory: ./
-            wranglerVersion: '4.10.0'
-            environment: ${{ inputs.environment }}
-            command: versions deploy ${{ inputs.middlewareVersionId }}@100% -y --config ./packages/gitbook/openNext/customWorkers/middlewareWrangler.jsonc
-
-      - name: Deploy server to Cloudflare at 100%
-        uses: cloudflare/wrangler-action@v3.14.0
-        with:
-            apiToken: ${{ inputs.apiToken }}
-            accountId: ${{ inputs.accountId }}
-            workingDirectory: ./
-            wranglerVersion: '4.10.0'
-            environment: ${{ inputs.environment }}
-            command: versions deploy ${{ inputs.serverVersionId }}@100% -y --config ./packages/gitbook/openNext/customWorkers/defaultWrangler.jsonc
-
-      - name: Outputs
-        shell: bash
-        env:
-          DEPLOYMENT_URL: ${{ steps.deploy_middleware.outputs.deployment-url }}
-        run: |
-            echo "URL: ${{ steps.deploy_middleware.outputs.deployment-url }}"

.github/composite/deploy-cloudflare/action.yaml

@@ -28,7 +28,7 @@ inputs:
 outputs:
     deployment-url: 
       description: "Deployment URL"
-      value: ${{ steps.upload_middleware.outputs.deployment-url }}
+      value: ${{ steps.deploy.outputs.deployment-url }}
 runs:
     using: 'composite'
     steps:
@@ -59,12 +59,12 @@ runs:
             GITBOOK_ASSETS_PREFIX: ${{ inputs.opItem }}/GITBOOK_ASSETS_PREFIX
             GITBOOK_FONTS_URL: ${{ inputs.opItem }}/GITBOOK_FONTS_URL
         - name: Build worker
-          run: bun run turbo build:cloudflare
+          run: bun run turbo build:v2:cloudflare
           env:
             GITBOOK_RUNTIME: cloudflare
           shell: bash
-
+        - id: deploy
-        - name: Upload the DO worker
+          name: Deploy to Cloudflare
           uses: cloudflare/wrangler-action@v3.14.0
           with:
               apiToken: ${{ inputs.apiToken }}
@@ -72,67 +72,10 @@ runs:
               workingDirectory: ./
               wranglerVersion: '4.10.0'
               environment: ${{ inputs.environment }}
-              command: deploy --config ./packages/gitbook/openNext/customWorkers/doWrangler.jsonc
+              command: ${{ inputs.deploy == 'true' && 'deploy' || format('versions upload --tag {0} --message "{1}"', inputs.commitTag, inputs.commitMessage) }} --config ./packages/gitbook-v2/wrangler.jsonc
-
-        - id: upload_server
-          name: Upload server to Cloudflare
-          uses: cloudflare/wrangler-action@v3.14.0
-          with:
-              apiToken: ${{ inputs.apiToken }}
-              accountId: ${{ inputs.accountId }}
-              workingDirectory: ./
-              wranglerVersion: '4.10.0'
-              environment: ${{ inputs.environment }}
-              command: ${{ format('versions upload --tag {0} --message "{1}"', inputs.commitTag, inputs.commitMessage) }} --config ./packages/gitbook/openNext/customWorkers/defaultWrangler.jsonc
-
-        - name: Extract server version worker ID
-          shell: bash
-          id: extract_server_version_id
-          run: |
-              version_id=$(echo '${{ steps.upload_server.outputs.command-output }}' | grep "Worker Version ID" | awk '{print $4}')
-              echo "version_id=$version_id" >> $GITHUB_OUTPUT
-
-        - name: Run updateWrangler scripts
-          shell: bash
-          run: |
-              bun run ./packages/gitbook/openNext/customWorkers/script/updateWrangler.ts ${{ steps.extract_server_version_id.outputs.version_id }}
-
-        - id: upload_middleware
-          name: Upload middleware to Cloudflare
-          uses: cloudflare/wrangler-action@v3.14.0
-          with:
-              apiToken: ${{ inputs.apiToken }}
-              accountId: ${{ inputs.accountId }}
-              workingDirectory: ./
-              wranglerVersion: '4.10.0'
-              environment: ${{ inputs.environment }}
-              command: ${{ format('versions upload --tag {0} --message "{1}"', inputs.commitTag, inputs.commitMessage) }} --config ./packages/gitbook/openNext/customWorkers/middlewareWrangler.jsonc
-        
-        - name: Extract middleware version worker ID
-          shell: bash
-          id: extract_middleware_version_id
-          run: |
-              version_id=$(echo '${{ steps.upload_middleware.outputs.command-output }}' | grep "Worker Version ID" | awk '{print $4}')
-              echo "version_id=$version_id" >> $GITHUB_OUTPUT
-
-        - name: Deploy server and middleware to Cloudflare
-          if: ${{ inputs.deploy == 'true' }}
-          uses: ./.github/actions/gradual-deploy-cloudflare
-          with:
-              apiToken: ${{ inputs.apiToken }}
-              accountId: ${{ inputs.accountId }}
-              opServiceAccount: ${{ inputs.opServiceAccount }}
-              opItem: ${{ inputs.opItem }}
-              environment: ${{ inputs.environment }}
-              serverVersionId: ${{ steps.extract_server_version_id.outputs.version_id }}
-              middlewareVersionId: ${{ steps.extract_middleware_version_id.outputs.version_id }}
-              deploy: ${{ inputs.deploy }}
-
-
         - name: Outputs
           shell: bash
           env:
-            DEPLOYMENT_URL: ${{ steps.upload_middleware.outputs.deployment-url }}
+            DEPLOYMENT_URL: ${{ steps.deploy.outputs.deployment-url }}
           run: |
-              echo "URL: ${{ steps.upload_middleware.outputs.deployment-url }}"
+              echo "URL: ${{ steps.deploy.outputs.deployment-url }}"
-              echo "Output server: ${{ steps.upload_server.outputs.command-output }}"

.github/workflows/deploy-preview.yaml

@@ -7,6 +7,53 @@ on:
 env:
     NPM_TOKEN_READONLY: ${{ secrets.NPM_TOKEN_READONLY }}
 jobs:
+    deploy-v1-cloudflare:
+        name: Deploy v1 to Cloudflare Pages
+        runs-on: ubuntu-latest
+        environment:
+          name: ${{ github.ref == 'refs/heads/main' && '1c-production' || '1c-preview' }}
+          url: ${{ steps.deploy.outputs.deployment-url }}
+        permissions:
+            contents: read
+            deployments: write
+            issues: write
+            pull-requests: write
+            checks: write
+            statuses: write
+        outputs:
+            deployment-url: ${{ steps.deploy.outputs.deployment-url }}
+            deployment-alias-url: ${{ steps.deploy.outputs.deployment-alias-url }}
+        steps:
+            - name: Checkout
+              uses: actions/checkout@v4
+            - name: Setup Bun
+              uses: ./.github/composite/setup-bun
+            - name: Install dependencies
+              run: bun install --frozen-lockfile
+              env:
+                  PUPPETEER_SKIP_DOWNLOAD: 1
+            - name: Sets env vars for production
+              if: github.ref == 'refs/heads/main'
+              run: |
+                echo "GITBOOK_ASSETS_PREFIX=https://static.gitbook.com" >> $GITHUB_ENV
+            - name: Build Next.js with next-on-pages
+              run: bun run turbo gitbook#build:cloudflare
+              env:
+                  NEXT_SERVER_ACTIONS_ENCRYPTION_KEY: ${{ secrets.NEXT_SERVER_ACTIONS_ENCRYPTION_KEY }}
+                  GITBOOK_RUNTIME: cloudflare
+            - id: deploy
+              name: Deploy to Cloudflare
+              uses: cloudflare/wrangler-action@v3.14.0
+              with:
+                  apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
+                  accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+                  workingDirectory: ./
+                  wranglerVersion: '3.112.0'
+                  command: pages deploy ./packages/gitbook/.vercel/output/static --project-name=${{ vars.CLOUDFLARE_PROJECT_NAME }} --branch=${{ github.ref == 'refs/heads/main' && 'main' || format('pr{0}', github.event.pull_request.number) }}
+            - name: Outputs
+              run: |
+                  echo "URL: ${{ steps.deploy.outputs.deployment-url }}"
+                  echo "Alias URL: ${{ steps.deploy.outputs.deployment-alias-url }}"
     deploy-v2-vercel:
         name: Deploy v2 to Vercel (preview)
         runs-on: ubuntu-latest
@@ -67,6 +114,7 @@ jobs:
         name: Comment Deployments (preview)
         if: always() && !startsWith(github.ref, 'refs/heads/main')
         needs:
+            - deploy-v1-cloudflare
             - deploy-v2-vercel
             - deploy-v2-cloudflare
         steps:
@@ -86,6 +134,15 @@ jobs:
                   body: |
                       Summary of the deployments:
 
+                      ### Version 1
+
+                      | Version | URL | Status |
+                      | --- | --- | --- |
+                      | Latest commit | [${{ needs.deploy-v1-cloudflare.outputs.deployment-url }}](${{ needs.deploy-v1-cloudflare.outputs.deployment-url }}) | ${{ needs.deploy-v1-cloudflare.result == 'success' && '✅' || '❌' }} |
+                      | PR | [${{ needs.deploy-v1-cloudflare.outputs.deployment-alias-url }}](${{ needs.deploy-v1-cloudflare.outputs.deployment-alias-url }}) | ${{ needs.deploy-v1-cloudflare.result == 'success' && '✅' || '❌' }} |
+
+                      ### Version 2
+
                       | Version | URL | Status |
                       | --- | --- | --- |
                       | Vercel | [${{ needs.deploy-v2-vercel.outputs.deployment-url }}](${{ needs.deploy-v2-vercel.outputs.deployment-url }}) | ${{ needs.deploy-v2-vercel.result == 'success' && '✅' || '❌' }} |
@@ -93,16 +150,35 @@ jobs:
 
                       ### Test content
 
-                      | Site | `2v` | `2c` |
+                      | Site | `v1` | `2v` | `2c` |
-                      | --- | --- | --- |
+                      | --- | --- | --- | --- |
-                      | GitBook | [${{ needs.deploy-v2-vercel.outputs.deployment-url }}/url/gitbook.com/docs](${{ needs.deploy-v2-vercel.outputs.deployment-url }}/url/gitbook.com/docs) | [${{ needs.deploy-v2-cloudflare.outputs.deployment-url }}/url/gitbook.com/docs](${{ needs.deploy-v2-cloudflare.outputs.deployment-url }}/url/gitbook.com/docs) |
+                      | GitBook | [${{ needs.deploy-v1-cloudflare.outputs.deployment-url }}/gitbook.com/docs](${{ needs.deploy-v1-cloudflare.outputs.deployment-url }}/gitbook.com/docs) | [${{ needs.deploy-v2-vercel.outputs.deployment-url }}/url/gitbook.com/docs](${{ needs.deploy-v2-vercel.outputs.deployment-url }}/url/gitbook.com/docs) | [${{ needs.deploy-v2-cloudflare.outputs.deployment-url }}/url/gitbook.com/docs](${{ needs.deploy-v2-cloudflare.outputs.deployment-url }}/url/gitbook.com/docs) |
-                      | E2E | [${{ needs.deploy-v2-vercel.outputs.deployment-url }}/url/gitbook.gitbook.io/test-gitbook-open](${{ needs.deploy-v2-vercel.outputs.deployment-url }}/url/gitbook.gitbook.io/test-gitbook-open) | [${{ needs.deploy-v2-cloudflare.outputs.deployment-url }}/url/gitbook.gitbook.io/test-gitbook-open](${{ needs.deploy-v2-cloudflare.outputs.deployment-url }}/url/gitbook.gitbook.io/test-gitbook-open) |
+                      | E2E | [${{ needs.deploy-v1-cloudflare.outputs.deployment-url }}/gitbook.gitbook.io/test-gitbook-open](${{ needs.deploy-v1-cloudflare.outputs.deployment-url }}/gitbook.gitbook.io/test-gitbook-open) | [${{ needs.deploy-v2-vercel.outputs.deployment-url }}/url/gitbook.gitbook.io/test-gitbook-open](${{ needs.deploy-v2-vercel.outputs.deployment-url }}/url/gitbook.gitbook.io/test-gitbook-open) | [${{ needs.deploy-v2-cloudflare.outputs.deployment-url }}/url/gitbook.gitbook.io/test-gitbook-open](${{ needs.deploy-v2-cloudflare.outputs.deployment-url }}/url/gitbook.gitbook.io/test-gitbook-open) |
                   edit-mode: replace
+    visual-testing-v1:
+        runs-on: ubuntu-latest
+        name: Visual Testing v1
+        needs: deploy-v1-cloudflare
+        timeout-minutes: 8
+        steps:
+            - name: Checkout
+              uses: actions/checkout@v4
+            - name: Setup Bun
+              uses: ./.github/composite/setup-bun
+            - name: Install dependencies
+              run: bun install --frozen-lockfile
+            - name: Setup Playwright
+              uses: ./.github/actions/setup-playwright
+            - name: Run Playwright tests
+              run: bun e2e
+              env:
+                  BASE_URL: ${{ needs.deploy-v1-cloudflare.outputs.deployment-url }}
+                  ARGOS_TOKEN: ${{ secrets.ARGOS_TOKEN }}
     visual-testing-v2-vercel:
         runs-on: ubuntu-latest
         name: Visual Testing v2
         needs: deploy-v2-vercel
-        timeout-minutes: 15
+        timeout-minutes: 10
         steps:
             - name: Checkout
               uses: actions/checkout@v4
@@ -123,7 +199,7 @@ jobs:
         runs-on: ubuntu-latest
         name: Visual Testing v2 (Cloudflare)
         needs: deploy-v2-cloudflare
-        timeout-minutes: 15
+        timeout-minutes: 10
         steps:
             - name: Checkout
               uses: actions/checkout@v4
@@ -140,11 +216,31 @@ jobs:
                   SITE_BASE_URL: ${{ needs.deploy-v2-cloudflare.outputs.deployment-url }}/url/
                   ARGOS_TOKEN: ${{ secrets.ARGOS_TOKEN }}
                   ARGOS_BUILD_NAME: 'v2-cloudflare'
+    visual-testing-customers-v1:
+        runs-on: ubuntu-latest
+        name: Visual Testing Customers v1
+        needs: deploy-v1-cloudflare
+        timeout-minutes: 8
+        steps:
+            - name: Checkout
+              uses: actions/checkout@v4
+            - name: Setup Bun
+              uses: ./.github/composite/setup-bun
+            - name: Install dependencies
+              run: bun install --frozen-lockfile
+            - name: Setup Playwright
+              uses: ./.github/actions/setup-playwright
+            - name: Run Playwright tests
+              run: bun e2e-customers
+              env:
+                  BASE_URL: ${{ needs.deploy-v1-cloudflare.outputs.deployment-url }}
+                  ARGOS_TOKEN: ${{ secrets.ARGOS_TOKEN }}
+                  ARGOS_BUILD_NAME: 'customers-v1'
     visual-testing-customers-v2:
         runs-on: ubuntu-latest
         name: Visual Testing Customers v2
         needs: deploy-v2-vercel
-        timeout-minutes: 15
+        timeout-minutes: 8
         steps:
             - name: Checkout
               uses: actions/checkout@v4
@@ -165,7 +261,7 @@ jobs:
         runs-on: ubuntu-latest
         name: Visual Testing Customers v2 (Cloudflare)
         needs: deploy-v2-cloudflare
-        timeout-minutes: 15
+        timeout-minutes: 8
         steps:
             - name: Checkout
               uses: actions/checkout@v4
@@ -182,10 +278,10 @@ jobs:
                   SITE_BASE_URL: ${{ needs.deploy-v2-cloudflare.outputs.deployment-url }}/url/
                   ARGOS_TOKEN: ${{ secrets.ARGOS_TOKEN }}
                   ARGOS_BUILD_NAME: 'customers-v2'
-    pagespeed-testing-v2:
+    pagespeed-testing-v1:
         runs-on: ubuntu-latest
         name: PageSpeed Testing v1
-        needs: deploy-v2-vercel
+        needs: deploy-v1-cloudflare
         steps:
             - name: Checkout
               uses: actions/checkout@v4
@@ -198,5 +294,5 @@ jobs:
             - name: Run pagespeed tests
               run: bun ./packages/gitbook/tests/pagespeed-testing.ts
               env:
-                  BASE_URL: ${{needs.deploy-v2-vercel.outputs.deployment-url}}
+                  BASE_URL: ${{needs.deploy-v1-cloudflare.outputs.deployment-url}}
                   PAGESPEED_API_KEY: ${{ secrets.PAGESPEED_API_KEY }}

.github/workflows/publish.yaml

@@ -39,4 +39,22 @@ jobs:
                   NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
                   CLOUDFLARE_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
                   CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
-
+    release-preview:
+        # For now it releases the cache-do to both preview and production
+        # Once we changed to deploy the app only on release, we should change `release:preview` in `cache-do`
+        name: Release Preview
+        runs-on: ubuntu-latest
+        steps:
+            - name: Checkout Repo
+              uses: actions/checkout@v3
+            - name: Setup Bun
+              uses: ./.github/composite/setup-bun
+            - name: Install dependencies
+              run: bun install --frozen-lockfile
+              env:
+                  PUPPETEER_SKIP_DOWNLOAD: 1
+            - name: Release preview packages
+              run: bun run release:preview
+              env:
+                  CLOUDFLARE_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+                  CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}

README.md

@@ -1,7 +1,7 @@
 <h1 align="center">GitBook</h1>
 
 <p align="center">
-  <a href="https://gitbook.com/docs/">Docs</a> - <a href="https://github.com/GitbookIO/community">Community</a> - <a href="https://developer.gitbook.com/">Developer Docs</a> - <a href="https://changelog.gitbook.com/">Changelog</a> - <a href="https://github.com/GitbookIO/gitbook/issues/new?assignees=&labels=bug&template=bug_report.md">Bug reports</a> - <a href="https://github.com/orgs/GitbookIO/discussions/categories/feature-requests">Feature requests</a> 
+  <a href="https://gitbook.com/docs/">Docs</a> - <a href="https://github.com/GitbookIO/community">Community</a> - <a href="https://developer.gitbook.com/">Developer Docs</a> - <a href="https://changelog.gitbook.com/">Changelog</a> - <a href="https://github.com/GitbookIO/gitbook/issues/new?assignees=&labels=bug&template=bug_report.md">Bug reports</a> 
 </p>
 
 <p align="center">
@@ -37,8 +37,8 @@ To run a local version of this project, please follow these simple steps.
 
 -   Node.js (Version: >=20.6)
   - Use nvm for easy Node management
-- [Bun](https://bun.sh/) (Version: >=1.2.15)
+-   Bun (Version: >=1.2.1)
-  - We use a text-based lockfile which isn't supported below 1.2.15
+  - We use a text-based lockfile which isn't supported below 1.2.1
 
 ### Set up
 
@@ -59,10 +59,10 @@ bun install
 4. Start your local development server.
 
 ```
-bun dev
+bun dev:v2
 ```
 
-6. Open a published GitBook space in your web browser, prefixing it with `http://localhost:3000/url`.
+5. Open a published GitBook space in your web browser, prefixing it with `http://localhost:3000/`.
 
 examples:
 
@@ -71,6 +71,11 @@ examples:
 
 Any published GitBook site can be accessed through your local development instance, and any updates you make to the codebase will be reflected in your browser.
 
+### Other development commands
+
+-   `bun format`: format the code
+-   `bun lint`: lint the code
+
 ### CI and testing
 
 All pull-requests will be tested against both visual and performances testing to prevent regressions.
@@ -145,11 +150,11 @@ See `LICENSE` for more information.
 </p>
 
 ```md
-[![GitBook](https://img.shields.io/static/v1?message=Documented%20on%20GitBook&logo=gitbook&logoColor=ffffff&label=%20&labelColor=5c5c5c&color=3F89A1)](https://www.gitbook.com/preview?utm_source=gitbook_readme_badge&utm_medium=organic&utm_campaign=preview_documentation&utm_content=link)
+[![GitBook](https://img.shields.io/static/v1?message=Documented%20on%20GitBook&logo=gitbook&logoColor=ffffff&label=%20&labelColor=5c5c5c&color=3F89A1)](https://gitbook.com/)
 ```
 
 ```html
-<a href="https://www.gitbook.com/preview?utm_source=gitbook_readme_badge&utm_medium=organic&utm_campaign=preview_documentation&utm_content=link">
+<a href="https://gitbook.com">
     <img
         src="https://img.shields.io/static/v1?message=Documented%20on%20GitBook&logo=gitbook&logoColor=ffffff&label=%20&labelColor=5c5c5c&color=3F89A1"
     />

biome.json

@@ -21,8 +21,7 @@
             "packages/openapi-parser/src/fixtures/**/*",
             "packages/emoji-codepoints/index.ts",
             "packages/icons/src/data/*.json",
-            "packages/gitbook/worker-configuration.d.ts",
+            "packages/cache-do/worker-configuration.d.ts"
-            "**/*.css"
         ]
     },
     "formatter": {
@@ -128,6 +127,7 @@
         {
             "include": [
                 "packages/gitbook/**/*",
+                "packages/gitbook-v2/**/*",
                 "packages/react-openapi/**/*",
                 "packages/react-math/**/*",
                 "packages/react-contentkit/**/*",

package.json

@@ -7,17 +7,19 @@
         "turbo": "^2.5.0",
         "vercel": "^39.3.0"
     },
-    "packageManager": "bun@1.2.15",
+    "packageManager": "bun@1.2.11",
     "overrides": {
         "@codemirror/state": "6.4.1",
+        "@gitbook/api": "^0.115.0",
         "react": "^19.0.0",
-        "react-dom": "^19.0.0",
+        "react-dom": "^19.0.0"
-        "esbuild": "0.24.2"
     },
     "private": true,
     "scripts": {
         "dev": "turbo run dev",
+        "dev:v2": "turbo run dev:v2",
         "build": "turbo run build",
+        "build:v2": "turbo run build:v2",
         "clean-deps": "rm -rf node_modules && rm -rf packages/*/node_modules",
         "typecheck": "turbo run typecheck",
         "format": "biome check --write ./",
@@ -28,15 +30,11 @@
         "changeset": "changeset",
         "changeset-version": "changeset version && bun run format",
         "release": "turbo run release && changeset publish",
+        "release:preview": "turbo run release:preview",
         "download:env": "op read op://gitbook-x-dev/gitbook-open/.env.local >> .env.local",
         "clean": "turbo run clean"
     },
-    "workspaces": {
+    "workspaces": ["packages/*"],
-        "packages": ["packages/*"],
-        "catalog": {
-            "@gitbook/api": "^0.130.0"
-        }
-    },
     "patchedDependencies": {
         "decode-named-character-reference@1.0.2": "patches/decode-named-character-reference@1.0.2.patch",
         "@vercel/next@4.4.2": "patches/@vercel%2Fnext@4.4.2.patch"

packages/cache-do/.gitignore

@@ -0,0 +1,3 @@
+.wrangler
+worker-configuration.d.ts
+dist/

packages/cache-do/CHANGELOG.md

@@ -0,0 +1,18 @@
+# @gitbook/cache-do
+
+## 0.1.1
+
+### Patch Changes
+
+-   b7a5106: Disable cloudflare observability in production
+
+## 0.1.0
+
+### Minor Changes
+
+-   9b8d519: Experiment with optimizing billable duration in Cloudflare by using multiple RPC sessions instead of one
+-   636b868: First version of a new cache backend powered by Cloudflare Durable Objects
+
+### Patch Changes
+
+-   56f5fa1: Enable Workers observability with a sampling of 0.1

packages/cache-do/README.md

@@ -0,0 +1,22 @@
+# `@gitbook/cache-do`
+
+Cache backend, powered by Cloudflare Durable Objects. The cache is optimized for GitBook use-cases.
+
+### Performances
+
+The cache backend is optimized for performances by being distributed and accessible close to the worker locations that are reading it.
+
+### Geo-distribution
+
+To achieve a good balance between **performances** and **consistency**, cache objects are distributed over 7 locations, representing continents.
+
+It makes it possible to purge all 7 locations in one go and achieve fast consistency.
+
+### Concepts
+
+**Cache tag**: unique tag in the cache environment. A cache tag groups multiple keys that should be purged together in one operation.
+Cache tags should not contain a large set of unique keys. Exceeding thousands could lead to performances or reliability issues.
+
+**Cache key**: unique key in the cache environment. Each key should be assigned to a `tag`.
+
+**Location**: cache is distributed over 7 unique locations, one for each continent.

packages/cache-do/package.json

@@ -0,0 +1,35 @@
+{
+    "name": "@gitbook/cache-do",
+    "type": "module",
+    "private": true,
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "development": "./src/index.ts",
+            "default": "./dist/index.js"
+        },
+        "./api": {
+            "types": "./dist/api.d.ts",
+            "development": "./src/api.ts",
+            "default": "./dist/api.js"
+        }
+    },
+    "version": "0.1.1",
+    "dependencies": {
+        "@msgpack/msgpack": "^3.0.0-beta2",
+        "lru_map": "^0.4.1"
+    },
+    "devDependencies": {
+        "typescript": "^5.5.3",
+        "wrangler": "^4.10.0"
+    },
+    "scripts": {
+        "generate": "wrangler types",
+        "build": "tsc",
+        "typecheck": "tsc --noEmit",
+        "dev": "tsc -w",
+        "release": "wrangler deploy",
+        "release:preview": "wrangler deploy && wrangler deploy --env preview"
+    },
+    "files": ["dist", "src", "bin", "data", "README.md", "CHANGELOG.md"]
+}

packages/cache-do/src/CacheObject.ts

@@ -0,0 +1,292 @@
+import { DurableObject } from 'cloudflare:workers';
+import { decode, encode } from '@msgpack/msgpack';
+import { LRUMap } from 'lru_map';
+
+export interface CacheObjectDescriptor {
+    get: <Value = unknown>(key: string) => Promise<Value | undefined>;
+    set: <Value = unknown>(key: string, value: Value, expiresAt: number) => Promise<void>;
+}
+
+/**
+ * Value stored in a chunked binary msgpack format.
+ * Stored under the key `prop.${key}.${index}`.
+ */
+interface CacheObjectProp<Value = unknown> {
+    value: Value;
+    expiresAt: number;
+}
+
+/**
+ * Expiration clock stored under the key `exp.${expiresAt}.${key}`.
+ */
+interface CacheObjectExp {
+    /** Key of the property */
+    k: string;
+    /** Number of chunks */
+    c: number;
+}
+
+/**
+ * Durable Object class being deployed as a distributed cache.
+ */
+export class CacheObject extends DurableObject {
+    private lru = new LRUMap<string, { match: CacheObjectProp | undefined }>(500);
+
+    /**
+     * Open a descriptor to access the cache object.
+     * The goal is to minimize the amount of RPC sessions between the client and the cache object.
+     * One session is opened per request on the client side and used to perform multiple operations.
+     * https://developers.cloudflare.com/workers/runtime-apis/rpc/#return-functions-from-rpc-methods
+     */
+    public open(): CacheObjectDescriptor {
+        return {
+            get: async <Value = unknown>(key: string) => {
+                return this.get<Value>(key);
+            },
+            set: async <Value = unknown>(key: string, value: Value, expiresAt: number) => {
+                await this.set(key, value, expiresAt);
+            },
+        };
+    }
+
+    /**
+     * Get the value of a property.
+     */
+    public async get<Value = unknown>(key: string) {
+        return this.logOperation({ operation: 'get', key }, async (setLog) => {
+            // Try the memory state first.
+            const memoryEntry = this.lru.get(key);
+            if (memoryEntry) {
+                setLog({ memory: true });
+                setLog({ memoryMatch: !!memoryEntry.match });
+                if (!memoryEntry.match) {
+                    return;
+                }
+
+                const isExpired = memoryEntry.match.expiresAt < Date.now();
+                setLog({ memoryExpired: isExpired });
+
+                if (!isExpired) {
+                    return memoryEntry.match.value as Value;
+                }
+            }
+
+            return await this.getFromStorage<Value>(key);
+        });
+    }
+
+    /**
+     * Get the value of a property from the DO storage.
+     */
+    public async getFromStorage<Value = unknown>(key: string) {
+        return this.logOperation({ operation: 'getFromStorage', key }, async (setLog) => {
+            const entries = await this.ctx.storage.list<Uint8Array>({
+                prefix: getStoragePropKey(key),
+                noCache: true,
+            });
+            if (entries.size) {
+                const entry = decodeChunks<CacheObjectProp<Value>>(entries);
+                setLog({ chunks: entries.size, chunksSize: entry?.size ?? 0 });
+                if (entry && entry.value.expiresAt > Date.now()) {
+                    // Found
+                    this.lru.set(key, { match: entry.value });
+                    return entry.value.value;
+                }
+            }
+
+            // Not found
+            this.lru.set(key, { match: undefined });
+        });
+    }
+
+    /**
+     * Set a value in the cache object.
+     */
+    public async set<Value = unknown>(key: string, value: Value, expiresAt: number) {
+        return this.logOperation({ operation: 'set', key }, async (setLog) => {
+            const prop: CacheObjectProp<Value> = {
+                value,
+                expiresAt,
+            };
+
+            this.lru.set(key, { match: prop });
+            await this.ctx.storage.transaction(async (tx) => {
+                const entries = encodeChunks(key, prop);
+                const chunks = Object.keys(entries).length;
+                setLog({ chunks });
+
+                const clockValue: CacheObjectExp = {
+                    k: key,
+                    c: chunks,
+                };
+
+                await tx.put(getGCClockKey(key, expiresAt), clockValue);
+                await tx.put(entries);
+
+                const currentAlarm = await tx.getAlarm();
+                if (!currentAlarm) {
+                    // Set an alarm to garbage collect all entries that have expired in 12h.
+                    await tx.setAlarm(Date.now() + 12 * 60 * 60 * 1000);
+                }
+            });
+        });
+    }
+
+    /**
+     * Purge all keys in the cache object.
+     */
+    public async purge() {
+        return this.logOperation({ operation: 'purge' }, async (setLog) => {
+            const result = new Set<string>();
+
+            try {
+                // List all the keys in the cache object.
+                const entries = await this.ctx.storage.list<CacheObjectExp>({
+                    prefix: 'exp.',
+                    noCache: true,
+                });
+                setLog({ entries: entries.size });
+                entries.forEach((exp) => {
+                    result.add(exp.k);
+                });
+            } catch (_error) {}
+
+            await this.reset();
+            return Array.from(result);
+        });
+    }
+
+    /**
+     * Alarm to garbage collect all entries that have expired.
+     */
+    async alarm() {
+        return this.logOperation({ operation: 'alarm' }, async (setLog) => {
+            try {
+                const entries = await this.ctx.storage.list<CacheObjectExp>({
+                    prefix: 'exp.',
+                    noCache: true,
+                });
+                setLog({ entries: entries.size });
+                const toDeleteSet = new Set<string>();
+
+                for (const [key, exp] of entries) {
+                    const timestamp = Number.parseInt(key.split('.')[1]);
+                    if (timestamp < Date.now()) {
+                        toDeleteSet.add(key);
+                        for (let i = 0; i < exp.c; i++) {
+                            toDeleteSet.add(getStoragePropChunkKey(exp.k, i));
+                        }
+                    }
+                }
+
+                // Delete the keys by batch of 128.
+                const toDelete = Array.from(toDeleteSet);
+                setLog({ toDelete: toDelete.length });
+                for (let i = 0; i < toDelete.length; i += 128) {
+                    await this.ctx.storage.delete(toDelete.slice(i, i + 128));
+                }
+
+                // If there are still keys to delete, set an alarm to continue the deletion in 12h.
+                if (toDelete.length) {
+                    await this.ctx.storage.setAlarm(Date.now() + 12 * 60 * 60 * 1000);
+                }
+            } catch (_error) {
+                await this.reset();
+            }
+        });
+    }
+
+    /**
+     * Reset the cache object.
+     */
+    async reset() {
+        return this.logOperation({ operation: 'reset' }, async () => {
+            this.lru.clear();
+            await this.ctx.storage.deleteAll();
+        });
+    }
+
+    /**
+     * Time and log an operation.
+     */
+    async logOperation<T>(
+        log: Record<string, unknown>,
+        fn: (update: (log: Record<string, unknown>) => void) => Promise<T>
+    ): Promise<T> {
+        const objectId = this.ctx.id.name ?? this.ctx.id.toString();
+        const update: Record<string, unknown> = {};
+        const start = performance.now();
+        try {
+            return await fn((arg) => {
+                Object.assign(update, arg);
+            });
+        } finally {
+            const duration = performance.now() - start;
+            console.log({ ...log, ...update, objectId, duration });
+        }
+    }
+}
+
+function getStoragePropKey(key: string): string {
+    return `prop.${key}.`;
+}
+
+function getStoragePropChunkKey(key: string, index: number): string {
+    return `${getStoragePropKey(key)}${index}`;
+}
+
+function getGCClockRootKey(timestamp: number): string {
+    return `exp.${timestamp}.`;
+}
+
+function getGCClockKey(key: string, expiresAt: number): string {
+    return `${getGCClockRootKey(expiresAt)}${key}`;
+}
+
+function encodeChunks<T>(key: string, value: T): Record<string, Uint8Array> {
+    const buf = encode(value);
+    const entries: Record<string, Uint8Array> = {};
+    const chunks = chunkUint8Array(buf, 128 * 1024);
+
+    for (let index = 0; index < chunks.length; index++) {
+        entries[getStoragePropChunkKey(key, index)] = chunks[index];
+    }
+
+    return entries;
+}
+
+function decodeChunks<T>(entries: Map<string, Uint8Array>): { value: T; size: number } | undefined {
+    const chunks = Array.from(entries.entries())
+        .map(([key, value]) => {
+            const index = Number.parseInt(key.split('.').pop()!);
+            return [index, value] as const;
+        })
+        .sort(([a], [b]) => a - b)
+        .map(([, value]) => value);
+
+    if (chunks.length === 0) {
+        return;
+    }
+
+    const buf = mergeUint8Array(chunks);
+    return { value: decode(buf) as T, size: buf.length };
+}
+
+function chunkUint8Array(input: Uint8Array, chunkSize: number): Uint8Array[] {
+    const chunks: Uint8Array[] = [];
+    for (let i = 0; i < input.length; i += chunkSize) {
+        chunks.push(input.slice(i, i + chunkSize));
+    }
+    return chunks;
+}
+
+function mergeUint8Array(chunks: Uint8Array[]): Uint8Array {
+    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return result;
+}

packages/cache-do/src/CacheObjectStub.ts

@@ -0,0 +1,97 @@
+import type { CacheObject } from './CacheObject';
+
+export type CacheLocationId = ContinentCode;
+const allLocations: CacheLocationId[] = ['AF', 'AS', 'NA', 'SA', 'AN', 'EU', 'OC'];
+
+/**
+ * Location hint for the CacheObject durable object.
+ */
+const doLocationHints: {
+    [key in CacheLocationId]: DurableObjectLocationHint;
+} = {
+    AF: 'afr',
+    AS: 'apac',
+    NA: 'wnam',
+    SA: 'sam',
+    AN: 'oc',
+    EU: 'weur',
+    OC: 'oc',
+};
+
+/**
+ * Client to access a cache tag.
+ */
+export class CacheObjectStub {
+    private stub: DurableObjectStub<CacheObject>;
+
+    constructor(
+        /** Binding to the CacheObject durable object */
+        private doNamespace: DurableObjectNamespace<CacheObject>,
+        /** ID of the location to target */
+        private locationId: CacheLocationId,
+        /** Name of the tag */
+        private tag: string
+    ) {
+        const groupId = getCacheObjectIdName(this.locationId, this.tag);
+        this.stub = this.doNamespace.get(this.doNamespace.idFromName(groupId), {
+            // Initialize the object with a locaiton hint,
+            // as we might want to purge all locations before the object is created.
+            // https://developers.cloudflare.com/durable-objects/reference/data-location/
+            locationHint: doLocationHints[this.locationId],
+        });
+    }
+
+    /**
+     * Open a descriptor to the cache object.
+     * It can be used to perform multiple operations in a single RPC session.
+     * Ex:
+     * ```ts
+     * using desc = cache.open();
+     * await desc.set('key', 'value', Date.now() + 1000);
+     * await desc.get('key');
+     * ```
+     */
+    async open() {
+        return await this.stub.open();
+    }
+
+    /**
+     * Get a value from the cache.
+     */
+    async get<Value = unknown>(key: string) {
+        return (await this.stub.get(key)) as Value | undefined;
+    }
+
+    /**
+     * Set a value in the cache.
+     */
+    async set<Value = unknown>(key: string, value: Value, expiresAt: number) {
+        return await this.stub.set(key, value, expiresAt);
+    }
+
+    /**
+     * Purge all keys in the cache tag.
+     */
+    async purge() {
+        const keys = new Set<string>();
+        await Promise.all(
+            allLocations.map(async (locationId) => {
+                const groupId = getCacheObjectIdName(locationId, this.tag);
+                const cacheGroup = this.doNamespace.get(this.doNamespace.idFromName(groupId), {
+                    // Initialize the object with a locaiton hint,
+                    // as we might want to purge all locations before the object is created.
+                    // https://developers.cloudflare.com/durable-objects/reference/data-location/
+                    locationHint: doLocationHints[this.locationId],
+                });
+                const locationkeys = await cacheGroup.purge();
+                locationkeys.forEach((key) => keys.add(key));
+            })
+        );
+
+        return keys;
+    }
+}
+
+function getCacheObjectIdName(locationId: CacheLocationId, tag: string): string {
+    return `${locationId}:${tag}`;
+}

packages/cache-do/src/api.ts

@@ -0,0 +1 @@
+export * from './CacheObjectStub';

packages/cache-do/src/index.ts

@@ -0,0 +1,9 @@
+import { WorkerEntrypoint } from 'cloudflare:workers';
+
+export * from './CacheObject';
+
+export default class Worker extends WorkerEntrypoint {
+    fetch() {
+        return new Response('Hello, world!');
+    }
+}

packages/cache-do/tsconfig.json

@@ -1,23 +1,20 @@
 {
     "compilerOptions": {
-        "lib": ["es2023"],
+        "target": "esnext",
-        "module": "ESNext",
+        "lib": ["dom", "dom.iterable", "esnext"],
-        "target": "es2022",
-        "strict": true,
-        "esModuleInterop": true,
-        "skipLibCheck": true,
-        "moduleResolution": "bundler",
         "allowJs": true,
+        "skipLibCheck": true,
+        "strict": true,
         "noEmit": false,
         "declaration": true,
         "outDir": "dist",
+        "esModuleInterop": true,
+        "module": "esnext",
+        "moduleResolution": "bundler",
         "resolveJsonModule": true,
         "isolatedModules": true,
-        "jsx": "react-jsx",
         "incremental": true,
-        "types": [
+        "types": ["./worker-configuration.d.ts"]
-            "bun-types" // add Bun global
-        ]
     },
     "include": ["src/**/*.ts"],
     "exclude": ["node_modules"]

packages/cache-do/turbo.json

@@ -0,0 +1,8 @@
+{
+    "extends": ["//"],
+    "tasks": {
+        "generate": {
+            "outputs": ["worker-configuration.d.ts"]
+        }
+    }
+}

packages/cache-do/wrangler.toml

@@ -0,0 +1,27 @@
+main = "./src/index.ts"
+name = "gitbook-open-cache"
+compatibility_date = "2024-09-02"
+
+durable_objects.bindings = [
+  {name = "CACHE", class_name = "CacheObject"}
+]
+
+migrations = [
+  {tag = "v1", new_classes = ["CacheObject"]}
+]
+
+[observability]
+enabled = false
+
+[env.preview]
+name = "gitbook-open-cache-preview"
+durable_objects.bindings = [
+  {name = "CACHE", class_name = "CacheObject"}
+]
+migrations = [
+  {tag = "v1", new_classes = ["CacheObject"]}
+]
+
+[env.preview.observability]
+enabled = true
+head_sampling_rate = 0.1

packages/cache-tags/package.json

@@ -10,7 +10,7 @@
     },
     "version": "0.3.1",
     "dependencies": {
-        "@gitbook/api": "catalog:",
+        "@gitbook/api": "^0.115.0",
         "assert-never": "^1.2.1"
     },
     "devDependencies": {

packages/cache-tags/src/index.ts

@@ -90,7 +90,7 @@ export function getCacheTag(
         | {
               tag: 'translation';
               organization: string;
-              translation: string;
+              translationSettings: string;
           }
 ): string {
     switch (spec.tag) {
@@ -115,7 +115,7 @@ export function getCacheTag(
         case 'openapi':
             return `organization:${spec.organization}:openapi:${spec.openAPISpec}`;
         case 'translation':
-            return `organization:${spec.organization}:translation:${spec.translation}`;
+            return `organization:${spec.organization}:translation:${spec.translationSettings}`;
         default:
             assertNever(spec);
     }
@@ -144,10 +144,6 @@ export function getComputedContentSourceCacheTags(
 ) {
     const tags: string[] = [];
 
-    if (!('dependencies' in source)) {
-        return tags;
-    }
-
     // We add the dependencies as tags, to ensure that the computed content is invalidated
     // when the dependencies are updated.
     const dependencies = Object.values(source.dependencies ?? {});
@@ -171,12 +167,12 @@ export function getComputedContentSourceCacheTags(
                         })
                     );
                     break;
-                case 'translation':
+                case 'translation-language':
                     tags.push(
                         getCacheTag({
                             tag: 'translation',
                             organization: inContext.organizationId,
-                            translation: dependency.ref.translation,
+                            translationSettings: dependency.ref.translationSettings,
                         })
                     );
                     break;

packages/fonts/.gitignore

@@ -1,2 +0,0 @@
-dist/
-src/data/*.json

packages/fonts/CHANGELOG.md

@@ -1,7 +0,0 @@
-# @gitbook/fonts
-
-## 0.1.0
-
-### Minor Changes
-
-- fbfcca5: Initial version of the package

packages/fonts/README.md

@@ -1,3 +0,0 @@
-# `@gitbook/fonts`
-
-Utilities to lookup default fonts supported by GitBook.

packages/fonts/bin/generate.ts

@@ -1,91 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-
-import { APIv2 } from 'google-font-metadata';
-
-import { CustomizationDefaultFont } from '@gitbook/api';
-
-import type { FontDefinitions } from '../src/types';
-
-const googleFontsMap: { [fontName in CustomizationDefaultFont]: string } = {
-    [CustomizationDefaultFont.Inter]: 'inter',
-    [CustomizationDefaultFont.FiraSans]: 'fira-sans-extra-condensed',
-    [CustomizationDefaultFont.IBMPlexSerif]: 'ibm-plex-serif',
-    [CustomizationDefaultFont.Lato]: 'lato',
-    [CustomizationDefaultFont.Merriweather]: 'merriweather',
-    [CustomizationDefaultFont.NotoSans]: 'noto-sans',
-    [CustomizationDefaultFont.OpenSans]: 'open-sans',
-    [CustomizationDefaultFont.Overpass]: 'overpass',
-    [CustomizationDefaultFont.Poppins]: 'poppins',
-    [CustomizationDefaultFont.Raleway]: 'raleway',
-    [CustomizationDefaultFont.Roboto]: 'roboto',
-    [CustomizationDefaultFont.RobotoSlab]: 'roboto-slab',
-    [CustomizationDefaultFont.SourceSansPro]: 'source-sans-3',
-    [CustomizationDefaultFont.Ubuntu]: 'ubuntu',
-    [CustomizationDefaultFont.ABCFavorit]: 'inter',
-};
-
-/**
- * Scripts to generate the list of all icons.
- */
-async function main() {
-    // @ts-expect-error - we build the object
-    const output: FontDefinitions = {};
-
-    for (const font of Object.values(CustomizationDefaultFont)) {
-        const googleFontName = googleFontsMap[font];
-        const fontMetadata = APIv2[googleFontName.toLowerCase()];
-        if (!fontMetadata) {
-            throw new Error(`Font ${googleFontName} not found`);
-        }
-
-        output[font] = {
-            font: googleFontName,
-            unicodeRange: fontMetadata.unicodeRange,
-            variants: {
-                '400': {},
-                '700': {},
-            },
-        };
-
-        Object.keys(output[font].variants).forEach((weight) => {
-            const variants = fontMetadata.variants[weight];
-            const normalVariant = variants.normal;
-            if (!normalVariant) {
-                throw new Error(`Font ${googleFontName} has no normal variant`);
-            }
-
-            output[font].variants[weight] = {};
-            Object.entries(normalVariant).forEach(([script, url]) => {
-                output[font].variants[weight][script] = url.url.woff;
-            });
-        });
-    }
-
-    await writeDataFile('fonts', JSON.stringify(output, null, 2));
-}
-
-/**
- * We write both in dist and src as the build process might have happen already
- * and tsc doesn't copy the files.
- */
-async function writeDataFile(name, content) {
-    const srcData = path.resolve(__dirname, '../src/data');
-    const distData = path.resolve(__dirname, '../dist/data');
-
-    // Ensure the directories exists
-    await Promise.all([
-        fs.mkdir(srcData, { recursive: true }),
-        fs.mkdir(distData, { recursive: true }),
-    ]);
-
-    await Promise.all([
-        fs.writeFile(path.resolve(srcData, `${name}.json`), content),
-        fs.writeFile(path.resolve(distData, `${name}.json`), content),
-    ]);
-}
-
-main().catch((error) => {
-    console.error(`Error generating icons list: ${error}`);
-    process.exit(1);
-});

packages/fonts/package.json

@@ -1,31 +0,0 @@
-{
-    "name": "@gitbook/fonts",
-    "type": "module",
-    "exports": {
-        ".": {
-            "types": "./dist/index.d.ts",
-            "development": "./src/index.ts",
-            "default": "./dist/index.js"
-        }
-    },
-    "version": "0.1.0",
-    "dependencies": {
-        "@gitbook/api": "catalog:"
-    },
-    "devDependencies": {
-        "google-font-metadata": "^6.0.3",
-        "typescript": "^5.5.3"
-    },
-    "scripts": {
-        "generate": "bun ./bin/generate.js",
-        "build": "tsc --project tsconfig.build.json",
-        "typecheck": "tsc --noEmit",
-        "dev": "tsc -w",
-        "clean": "rm -rf ./dist && rm -rf ./src/data",
-        "unit": "bun test"
-    },
-    "files": ["dist", "src", "bin", "README.md", "CHANGELOG.md"],
-    "engines": {
-        "node": ">=20.0.0"
-    }
-}

packages/fonts/src/__snapshots__/getDefaultFont.test.ts.snap

@@ -1,57 +0,0 @@
-// Bun Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`getDefaultFont should return correct object for Latin text 1`] = `
-{
-  "font": "Inter",
-  "url": "https://fonts.gstatic.com/s/inter/v18/UcCO3FwrK3iLTeHuS_nVMrMxCp50SjIw2boKoduKmMEVuLyfAZ9hjp-Ek-_0ew.woff",
-}
-`;
-
-exports[`getDefaultFont should return correct object for Cyrillic text 1`] = `
-{
-  "font": "Inter",
-  "url": "https://fonts.gstatic.com/s/inter/v18/UcCO3FwrK3iLTeHuS_nVMrMxCp50SjIw2boKoduKmMEVuLyfAZthjp-Ek-_0ewmM.woff",
-}
-`;
-
-exports[`getDefaultFont should return correct object for Greek text 1`] = `
-{
-  "font": "Inter",
-  "url": "https://fonts.gstatic.com/s/inter/v18/UcCO3FwrK3iLTeHuS_nVMrMxCp50SjIw2boKoduKmMEVuLyfAZxhjp-Ek-_0ewmM.woff",
-}
-`;
-
-exports[`getDefaultFont should handle mixed script text 1`] = `
-{
-  "font": "Inter",
-  "url": "https://fonts.gstatic.com/s/inter/v18/UcCO3FwrK3iLTeHuS_nVMrMxCp50SjIw2boKoduKmMEVuLyfAZthjp-Ek-_0ewmM.woff",
-}
-`;
-
-exports[`getDefaultFont should handle different font weights: regular 1`] = `
-{
-  "font": "Inter",
-  "url": "https://fonts.gstatic.com/s/inter/v18/UcCO3FwrK3iLTeHuS_nVMrMxCp50SjIw2boKoduKmMEVuLyfAZ9hjp-Ek-_0ew.woff",
-}
-`;
-
-exports[`getDefaultFont should handle different font weights: bold 1`] = `
-{
-  "font": "Inter",
-  "url": "https://fonts.gstatic.com/s/inter/v18/UcCO3FwrK3iLTeHuS_nVMrMxCp50SjIw2boKoduKmMEVuFuYAZ9hjp-Ek-_0ew.woff",
-}
-`;
-
-exports[`getDefaultFont should handle different fonts: inter 1`] = `
-{
-  "font": "Inter",
-  "url": "https://fonts.gstatic.com/s/inter/v18/UcCO3FwrK3iLTeHuS_nVMrMxCp50SjIw2boKoduKmMEVuLyfAZ9hjp-Ek-_0ew.woff",
-}
-`;
-
-exports[`getDefaultFont should handle different fonts: roboto 1`] = `
-{
-  "font": "Roboto",
-  "url": "https://fonts.gstatic.com/s/roboto/v32/KFOmCnqEu92Fr1Mu4mxMKTU1Kg.woff",
-}
-`;

packages/fonts/src/fonts.ts

@@ -1,5 +0,0 @@
-import type { FontDefinitions } from './types';
-
-import rawFonts from './data/fonts.json' with { type: 'json' };
-
-export const fonts: FontDefinitions = rawFonts;

packages/fonts/src/getDefaultFont.test.ts

@@ -1,119 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import { CustomizationDefaultFont } from '@gitbook/api';
-import { getDefaultFont } from './getDefaultFont';
-
-describe('getDefaultFont', () => {
-    it('should return null for invalid font', () => {
-        const result = getDefaultFont({
-            font: 'invalid-font' as CustomizationDefaultFont,
-            text: 'Hello',
-            weight: 400,
-        });
-        expect(result).toBeNull();
-    });
-
-    it('should return null for invalid weight', () => {
-        const result = getDefaultFont({
-            font: CustomizationDefaultFont.Inter,
-            text: 'Hello',
-            weight: 999 as any,
-        });
-        expect(result).toBeNull();
-    });
-
-    it('should return null for text not supported by any script', () => {
-        const result = getDefaultFont({
-            font: CustomizationDefaultFont.Inter,
-            text: '😀', // Emoji not supported by Inter
-            weight: 400,
-        });
-        expect(result).toBeNull();
-    });
-
-    it('should return correct object for Latin text', () => {
-        const result = getDefaultFont({
-            font: CustomizationDefaultFont.Inter,
-            text: 'Hello World',
-            weight: 400,
-        });
-        expect(result).not.toBeNull();
-        expect(result?.font).toBe(CustomizationDefaultFont.Inter);
-        expect(result).toMatchSnapshot();
-    });
-
-    it('should return correct object for Cyrillic text', () => {
-        const result = getDefaultFont({
-            font: CustomizationDefaultFont.Inter,
-            text: 'Привет мир',
-            weight: 400,
-        });
-        expect(result).not.toBeNull();
-        expect(result?.font).toBe(CustomizationDefaultFont.Inter);
-        expect(result).toMatchSnapshot();
-    });
-
-    it('should return correct object for Greek text', () => {
-        const result = getDefaultFont({
-            font: CustomizationDefaultFont.Inter,
-            text: 'Γεια σας',
-            weight: 400,
-        });
-        expect(result).not.toBeNull();
-        expect(result?.font).toBe(CustomizationDefaultFont.Inter);
-        expect(result).toMatchSnapshot();
-    });
-
-    it('should handle mixed script text', () => {
-        const result = getDefaultFont({
-            font: CustomizationDefaultFont.Inter,
-            text: 'Hello Привет',
-            weight: 400,
-        });
-        expect(result).not.toBeNull();
-        expect(result?.font).toBe(CustomizationDefaultFont.Inter);
-        expect(result).toMatchSnapshot();
-    });
-
-    it('should handle different font weights', () => {
-        const regular = getDefaultFont({
-            font: CustomizationDefaultFont.Inter,
-            text: 'Hello',
-            weight: 400,
-        });
-        const bold = getDefaultFont({
-            font: CustomizationDefaultFont.Inter,
-            text: 'Hello',
-            weight: 700,
-        });
-        expect(regular).not.toBeNull();
-        expect(bold).not.toBeNull();
-        expect(regular).toMatchSnapshot('regular');
-        expect(bold).toMatchSnapshot('bold');
-    });
-
-    it('should handle empty string', () => {
-        const result = getDefaultFont({
-            font: CustomizationDefaultFont.Inter,
-            text: '',
-            weight: 400,
-        });
-        expect(result).toBeNull();
-    });
-
-    it('should handle different fonts', () => {
-        const inter = getDefaultFont({
-            font: CustomizationDefaultFont.Inter,
-            text: 'Hello',
-            weight: 400,
-        });
-        const roboto = getDefaultFont({
-            font: CustomizationDefaultFont.Roboto,
-            text: 'Hello',
-            weight: 400,
-        });
-        expect(inter).not.toBeNull();
-        expect(roboto).not.toBeNull();
-        expect(inter).toMatchSnapshot('inter');
-        expect(roboto).toMatchSnapshot('roboto');
-    });
-});

packages/fonts/src/getDefaultFont.ts

@@ -1,112 +0,0 @@
-import type { CustomizationDefaultFont } from '@gitbook/api';
-import { fonts } from './fonts';
-import type { FontWeight } from './types';
-
-/**
- * Get the URL to load a font for a text.
- */
-export function getDefaultFont(input: {
-    /**
-     * GitBook font to use.
-     */
-    font: CustomizationDefaultFont;
-
-    /**
-     * Text to display with the font.
-     */
-    text: string;
-
-    /**
-     * Font weight to use.
-     */
-    weight: FontWeight;
-}): { font: string; url: string } | null {
-    if (!input.text.trim()) {
-        return null;
-    }
-
-    const fontDefinition = fonts[input.font];
-    if (!fontDefinition) {
-        return null;
-    }
-
-    const variant = fontDefinition.variants[`${input.weight}`];
-    if (!variant) {
-        return null;
-    }
-
-    const script = getBestUnicodeRange(input.text, fontDefinition.unicodeRange);
-    if (!script) {
-        return null;
-    }
-
-    return variant[script]
-        ? {
-              font: input.font,
-              url: variant[script],
-          }
-        : null;
-}
-
-/**
- * Determine which named @font-face unicode-range covers
- * the greatest share of the characters in `text`.
- *
- * @param text   The text you want to inspect.
- * @param ranges An object whose keys are range names and whose
- *               values are CSS-style comma-separated unicode-range
- *               declarations (e.g. "U+0370-03FF,U+1F00-1FFF").
- * @returns      The key of the best-matching range, or `null`
- *               when nothing matches at all.
- */
-function getBestUnicodeRange(text: string, ranges: Record<string, string>): string | null {
-    // ---------- helper: parse "U+XXXX" or "U+XXXX-YYYY" ----------
-    const parseOne = (token: string): [number, number] | null => {
-        token = token.trim().toUpperCase();
-        if (!token.startsWith('U+')) return null;
-
-        const body = token.slice(2); // drop "U+"
-        const [startHex, endHex] = body.split('-');
-        const start = Number.parseInt(startHex, 16);
-        const end = endHex ? Number.parseInt(endHex, 16) : start;
-
-        if (Number.isNaN(start) || Number.isNaN(end) || end < start) return null;
-        return [start, end];
-    };
-
-    // ---------- helper: build lookup table ----------
-    const parsed: Record<string, [number, number][]> = {};
-    for (const [label, list] of Object.entries(ranges)) {
-        parsed[label] = list
-            .split(',')
-            .map(parseOne)
-            .filter((x): x is [number, number] => x !== null);
-    }
-
-    // ---------- tally code-point hits ----------
-    const hits: Record<string, number> = Object.fromEntries(Object.keys(parsed).map((k) => [k, 0]));
-
-    for (let i = 0; i < text.length; ) {
-        const cp = text.codePointAt(i)!;
-        i += cp > 0xffff ? 2 : 1; // advance by 1 UTF-16 code-unit (or 2 for surrogates)
-
-        for (const [label, rangesArr] of Object.entries(parsed)) {
-            if (rangesArr.some(([lo, hi]) => cp >= lo && cp <= hi)) {
-                hits[label]++;
-            }
-        }
-    }
-
-    // ---------- choose the "best" ----------
-    let winner: string | null = null;
-    let maxCount = 0;
-
-    for (const [label, count] of Object.entries(hits)) {
-        if (count > maxCount) {
-            maxCount = count;
-            winner = label;
-        }
-    }
-
-    return maxCount > 0 ? winner : null;
-}

packages/fonts/src/index.ts

@@ -1,2 +0,0 @@
-export * from './getDefaultFont';
-export * from './types';

packages/fonts/src/types.ts

@@ -1,17 +0,0 @@
-import type { CustomizationDefaultFont } from '@gitbook/api';
-
-export type FontWeight = 400 | 700;
-
-export type FontDefinition = {
-    font: string;
-    unicodeRange: {
-        [script: string]: string;
-    };
-    variants: {
-        [weight in string]: {
-            [script: string]: string;
-        };
-    };
-};
-
-export type FontDefinitions = { [fontName in CustomizationDefaultFont]: FontDefinition };

packages/fonts/tsconfig.build.json

@@ -1,4 +0,0 @@
-{
-    "extends": "./tsconfig.json",
-    "exclude": ["node_modules", "src/**/*.test.ts"]
-}

packages/fonts/turbo.json

@@ -1,9 +0,0 @@
-{
-    "extends": ["//"],
-    "tasks": {
-        "generate": {
-            "inputs": ["bin/**/*", "package.json"],
-            "outputs": ["src/data/*.json", "dist/data/*.json"]
-        }
-    }
-}

packages/gitbook-v2/.gitignore

@@ -0,0 +1,12 @@
+# next.js
+/.next/
+
+# vercel
+.vercel
+
+# cloudflare
+.open-next
+.wrangler
+
+# Symbolic links
+public

packages/gitbook-v2/CHANGELOG.md

@@ -0,0 +1,81 @@
+# gitbook-v2
+
+## 0.3.0
+
+### Minor Changes
+
+- 3119066: Add support for reusable content across spaces.
+- 7d7806d: Pass SVG images through image resizing without resizing them to serve them from optimal host.
+
+### Patch Changes
+
+- 1c8d9fe: keep data cache in OpenNext between deployment
+- 778624a: Only resize images with supported extensions.
+- e6ddc0f: Fix URL in sitemap
+- 5e975ab: Fix code highlighting for HTTP
+- e15757d: Fix crash on Cloudflare by using latest stable version of Next.js instead of canary
+- 634e0b4: Improve error messages around undefined site sections.
+- 97b7c79: Increase logging around caching behaviour causing page crashes.
+- 3f29206: Update the regex for validating site redirect
+- dd043df: Revert investigation work around URL caches.
+
+## 0.2.5
+
+### Patch Changes
+
+- Updated dependencies [77397ca]
+  - @gitbook/cache-tags@0.3.1
+
+## 0.2.4
+
+### Patch Changes
+
+- 4234289: Fix incoming URL for requests that were proxied
+- Updated dependencies [116575c]
+  - @gitbook/cache-tags@0.3.0
+
+## 0.2.3
+
+### Patch Changes
+
+- 5b2bf82: Use stable site URL data for route rewrite in the middleware
+
+## 0.2.2
+
+### Patch Changes
+
+- 54ee014: Add initial support for loading custom fonts
+- bba2e52: Fix site redirects when it includes a section/variant path
+
+## 0.2.1
+
+### Patch Changes
+
+- Updated dependencies [f32bf1f]
+  - @gitbook/cache-tags@0.2.0
+
+## 0.2.0
+
+### Minor Changes
+
+- 76c7974: Add route to revalidate cached data
+
+## 0.1.2
+
+### Patch Changes
+
+- 05ffd0e: Improving data cache management for computed content
+- Updated dependencies [05ffd0e]
+  - @gitbook/cache-tags@0.1.0
+
+## 0.1.1
+
+### Patch Changes
+
+- 3e11678: fix: lost section groups
+
+## 0.1.0
+
+### Minor Changes
+
+- cfccc44: Setup structure and deployment for new version

packages/gitbook-v2/next-env.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

packages/gitbook-v2/next.config.mjs

@@ -14,9 +14,6 @@ const nextConfig = {
             dynamic: 3600, // 1 hour
             static: 3600, // 1 hour
         },
-
-        // Since content is fully static, we don't want to fetch on hover again
-        optimisticClientCache: false,
     },
 
     env: {

packages/gitbook-v2/open-next.config.ts

@@ -0,0 +1,26 @@
+import { defineCloudflareConfig } from '@opennextjs/cloudflare';
+import doShardedTagCache from '@opennextjs/cloudflare/overrides/tag-cache/do-sharded-tag-cache';
+import {
+    softTagFilter,
+    withFilter,
+} from '@opennextjs/cloudflare/overrides/tag-cache/tag-cache-filter';
+
+export default defineCloudflareConfig({
+    incrementalCache: () => import('./openNext/incrementalCache').then((m) => m.default),
+    tagCache: withFilter({
+        tagCache: doShardedTagCache({
+            baseShardSize: 12,
+            regionalCache: true,
+            shardReplication: {
+                numberOfSoftReplicas: 2,
+                numberOfHardReplicas: 1,
+            },
+        }),
+        // We don't use `revalidatePath`, so we filter out soft tags
+        filterFn: softTagFilter,
+    }),
+    queue: () => import('./openNext/queue').then((m) => m.default),
+
+    // Performance improvements as we don't use PPR
+    enableCacheInterception: true,
+});

packages/gitbook-v2/openNext/incrementalCache.ts

@@ -0,0 +1,186 @@
+import { createHash } from 'node:crypto';
+
+import { trace } from '@/lib/tracing';
+import type {
+    CacheEntryType,
+    CacheValue,
+    IncrementalCache,
+    WithLastModified,
+} from '@opennextjs/aws/types/overrides.js';
+import { getCloudflareContext } from '@opennextjs/cloudflare';
+
+export const BINDING_NAME = 'NEXT_INC_CACHE_R2_BUCKET';
+export const DEFAULT_PREFIX = 'incremental-cache';
+
+export type KeyOptions = {
+    cacheType?: CacheEntryType;
+};
+
+/**
+ *
+ * It is very similar to the `R2IncrementalCache` in the `@opennextjs/cloudflare` package, but it allow us to trace
+ * the cache operations. It also integrates both R2 and Cache API in a single class.
+ * Having our own, will allow us to customize it in the future if needed.
+ */
+class GitbookIncrementalCache implements IncrementalCache {
+    name = 'GitbookIncrementalCache';
+
+    protected localCache: Cache | undefined;
+
+    async get<CacheType extends CacheEntryType = 'cache'>(
+        key: string,
+        cacheType?: CacheType
+    ): Promise<WithLastModified<CacheValue<CacheType>> | null> {
+        const cacheKey = this.getR2Key(key, cacheType);
+        return trace(
+            {
+                operation: 'openNextIncrementalCacheGet',
+                name: cacheKey,
+            },
+            async (span) => {
+                span.setAttribute('cacheType', cacheType ?? 'cache');
+                const r2 = getCloudflareContext().env[BINDING_NAME];
+                const localCache = await this.getCacheInstance();
+                if (!r2) throw new Error('No R2 bucket');
+                try {
+                    // Check local cache first if available
+                    const localCacheEntry = await localCache.match(this.getCacheUrlKey(cacheKey));
+                    if (localCacheEntry) {
+                        span.setAttribute('cacheHit', 'local');
+                        return localCacheEntry.json();
+                    }
+
+                    const r2Object = await r2.get(cacheKey);
+                    if (!r2Object) return null;
+
+                    span.setAttribute('cacheHit', 'r2');
+                    return {
+                        value: await r2Object.json(),
+                        lastModified: r2Object.uploaded.getTime(),
+                    };
+                } catch (e) {
+                    console.error('Failed to get from cache', e);
+                    return null;
+                }
+            }
+        );
+    }
+
+    async set<CacheType extends CacheEntryType = 'cache'>(
+        key: string,
+        value: CacheValue<CacheType>,
+        cacheType?: CacheType
+    ): Promise<void> {
+        const cacheKey = this.getR2Key(key, cacheType);
+        return trace(
+            {
+                operation: 'openNextIncrementalCacheSet',
+                name: cacheKey,
+            },
+            async (span) => {
+                span.setAttribute('cacheType', cacheType ?? 'cache');
+                const r2 = getCloudflareContext().env[BINDING_NAME];
+                const localCache = await this.getCacheInstance();
+                if (!r2) throw new Error('No R2 bucket');
+
+                try {
+                    await r2.put(cacheKey, JSON.stringify(value));
+
+                    //TODO: Check if there is any places where we don't have tags
+                    // Ideally we should always have tags, but in case we don't, we need to decide how to handle it
+                    // For now we default to a build ID tag, which allow us to invalidate the cache in case something is wrong in this deployment
+                    const tags = this.getTagsFromCacheEntry(value) ?? [
+                        `build_id/${process.env.NEXT_BUILD_ID}`,
+                    ];
+
+                    // We consider R2 as the source of truth, so we update the local cache
+                    // only after a successful R2 write
+                    await localCache.put(
+                        this.getCacheUrlKey(cacheKey),
+                        new Response(
+                            JSON.stringify({
+                                value,
+                                // Note: `Date.now()` returns the time of the last IO rather than the actual time.
+                                //       See https://developers.cloudflare.com/workers/reference/security-model/
+                                lastModified: Date.now(),
+                            }),
+                            {
+                                headers: {
+                                    // Cache-Control default to 30 minutes, will be overridden by `revalidate`
+                                    // In theory we should always get the `revalidate` value
+                                    'cache-control': `max-age=${value.revalidate ?? 60 * 30}`,
+                                    'cache-tag': tags.join(','),
+                                },
+                            }
+                        )
+                    );
+                } catch (e) {
+                    console.error('Failed to set to cache', e);
+                }
+            }
+        );
+    }
+
+    async delete(key: string): Promise<void> {
+        const cacheKey = this.getR2Key(key);
+        return trace(
+            {
+                operation: 'openNextIncrementalCacheDelete',
+                name: cacheKey,
+            },
+            async () => {
+                const r2 = getCloudflareContext().env[BINDING_NAME];
+                const localCache = await this.getCacheInstance();
+                if (!r2) throw new Error('No R2 bucket');
+
+                try {
+                    await r2.delete(cacheKey);
+
+                    // Here again R2 is the source of truth, so we delete from local cache first
+                    await localCache.delete(this.getCacheUrlKey(cacheKey));
+                } catch (e) {
+                    console.error('Failed to delete from cache', e);
+                }
+            }
+        );
+    }
+
+    async getCacheInstance(): Promise<Cache> {
+        if (this.localCache) return this.localCache;
+        this.localCache = await caches.open('incremental-cache');
+        return this.localCache;
+    }
+
+    // Utility function to generate keys for R2/Cache API
+    getR2Key(key: string, cacheType: CacheEntryType = 'cache'): string {
+        const hash = createHash('sha256').update(key).digest('hex');
+        return `${DEFAULT_PREFIX}/${cacheType === 'cache' ? process.env?.NEXT_BUILD_ID : 'dataCache'}/${hash}.${cacheType}`.replace(
+            /\/+/g,
+            '/'
+        );
+    }
+
+    getCacheUrlKey(cacheKey: string): string {
+        return `http://cache.local/${cacheKey}`;
+    }
+
+    getTagsFromCacheEntry<CacheType extends CacheEntryType>(
+        entry: CacheValue<CacheType>
+    ): string[] | undefined {
+        if ('tags' in entry && entry.tags) {
+            return entry.tags;
+        }
+
+        if ('meta' in entry && entry.meta && 'headers' in entry.meta && entry.meta.headers) {
+            const rawTags = entry.meta.headers['x-next-cache-tags'];
+            if (typeof rawTags === 'string') {
+                return rawTags.split(',');
+            }
+        }
+        if ('value' in entry) {
+            return entry.tags;
+        }
+    }
+}
+
+export default new GitbookIncrementalCache();

packages/gitbook-v2/openNext/queue.ts

@@ -0,0 +1,17 @@
+import type { Queue } from '@opennextjs/aws/types/overrides.js';
+import { getCloudflareContext } from '@opennextjs/cloudflare';
+import doQueue from '@opennextjs/cloudflare/overrides/queue/do-queue';
+import memoryQueue from '@opennextjs/cloudflare/overrides/queue/memory-queue';
+
+interface Env {
+    IS_PREVIEW?: string;
+}
+
+export default {
+    name: 'GitbookISRQueue',
+    send: async (msg) => {
+        const { ctx, env } = getCloudflareContext();
+        const isPreview = (env as Env).IS_PREVIEW === 'true';
+        ctx.waitUntil(isPreview ? memoryQueue.send(msg) : doQueue.send(msg));
+    },
+} satisfies Queue;

packages/gitbook-v2/package.json

@@ -0,0 +1,36 @@
+{
+    "name": "gitbook-v2",
+    "version": "0.3.0",
+    "private": true,
+    "dependencies": {
+        "@gitbook/api": "^0.115.0",
+        "@gitbook/cache-tags": "workspace:*",
+        "@opennextjs/cloudflare": "1.0.4",
+        "@sindresorhus/fnv1a": "^3.1.0",
+        "assert-never": "^1.2.1",
+        "jwt-decode": "^4.0.0",
+        "next": "^15.3.2",
+        "react": "^19.0.0",
+        "react-dom": "^19.0.0",
+        "rison": "^0.1.1",
+        "server-only": "^0.0.1",
+        "warn-once": "^0.1.1"
+    },
+    "devDependencies": {
+        "gitbook": "*",
+        "@types/rison": "^0.0.9",
+        "tailwindcss": "^3.4.0",
+        "postcss": "^8"
+    },
+    "scripts": {
+        "generate": "rm -rf ./public && cp -r ../gitbook/public ./public",
+        "dev:v2": "env-cmd --silent -f ../../.env.local next --turbopack",
+        "build": "next build",
+        "build:v2": "next build",
+        "start": "next start",
+        "build:v2:cloudflare": "opennextjs-cloudflare build",
+        "dev:v2:cloudflare": "wrangler dev --port 8771 --env preview",
+        "unit": "bun test",
+        "typecheck": "tsc --noEmit"
+    }
+}

packages/gitbook-v2/postcss.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+    plugins: {
+        tailwindcss: {},
+        autoprefixer: {},
+    },
+};

packages/gitbook-v2/src/app/sites/dynamic/[mode]/[siteURL]/[siteData]/(content)/[pagePath]/page.tsx

@@ -1,9 +1,9 @@
-import { type RouteParams, getDynamicSiteContext, getPagePathFromParams } from '@/app/utils';
 import {
     SitePage,
     generateSitePageMetadata,
     generateSitePageViewport,
 } from '@/components/SitePage';
+import { type RouteParams, getDynamicSiteContext, getPagePathFromParams } from '@v2/app/utils';
 import type { Metadata, Viewport } from 'next';
 
 type PageProps = {

packages/gitbook-v2/src/app/sites/dynamic/[mode]/[siteURL]/[siteData]/(content)/layout.tsx

@@ -1,13 +1,12 @@
-import { type RouteLayoutParams, getDynamicSiteContext } from '@/app/utils';
 import { CustomizationRootLayout } from '@/components/RootLayout';
 import {
     SiteLayout,
     generateSiteLayoutMetadata,
     generateSiteLayoutViewport,
 } from '@/components/SiteLayout';
-import { getThemeFromMiddleware } from '@/lib/middleware';
+import { type RouteLayoutParams, getDynamicSiteContext } from '@v2/app/utils';
-import { shouldTrackEvents } from '@/lib/tracking';
+import { GITBOOK_DISABLE_TRACKING } from '@v2/lib/env';
-import { headers } from 'next/headers';
+import { getThemeFromMiddleware } from '@v2/lib/middleware';
 
 interface SiteDynamicLayoutProps {
     params: Promise<RouteLayoutParams>;
@@ -19,14 +18,13 @@ export default async function SiteDynamicLayout({
 }: React.PropsWithChildren<SiteDynamicLayoutProps>) {
     const { context, visitorAuthClaims } = await getDynamicSiteContext(await params);
     const forcedTheme = await getThemeFromMiddleware();
-    const withTracking = shouldTrackEvents(await headers());
 
     return (
         <CustomizationRootLayout forcedTheme={forcedTheme} customization={context.customization}>
             <SiteLayout
                 context={context}
                 forcedTheme={forcedTheme}
-                withTracking={withTracking}
+                withTracking={!GITBOOK_DISABLE_TRACKING}
                 visitorAuthClaims={visitorAuthClaims}
             >
                 {children}

packages/gitbook-v2/src/app/sites/dynamic/[mode]/[siteURL]/[siteData]/~gitbook/icon/route.ts

@@ -1,7 +1,7 @@
 import type { NextRequest } from 'next/server';
 
-import { type RouteLayoutParams, getDynamicSiteContext } from '@/app/utils';
 import { serveIcon } from '@/routes/icon';
+import { type RouteLayoutParams, getDynamicSiteContext } from '@v2/app/utils';
 
 export async function GET(
     request: NextRequest,

packages/gitbook-v2/src/app/sites/dynamic/[mode]/[siteURL]/[siteData]/~gitbook/ogimage/[pageId]/route.ts

@@ -1,8 +1,8 @@
 import type { NextRequest } from 'next/server';
 
-import { type RouteLayoutParams, getDynamicSiteContext } from '@/app/utils';
 import type { PageIdParams } from '@/components/SitePage';
 import { serveOGImage } from '@/routes/ogimage';
+import { type RouteLayoutParams, getDynamicSiteContext } from '@v2/app/utils';
 
 export async function GET(
     _request: NextRequest,

packages/gitbook-v2/src/app/sites/dynamic/[mode]/[siteURL]/[siteData]/~gitbook/pdf/layout.tsx

@@ -1,5 +1,5 @@
-import { type RouteLayoutParams, getDynamicSiteContext } from '@/app/utils';
 import { PDFRootLayout } from '@/components/PDF';
+import { type RouteLayoutParams, getDynamicSiteContext } from '@v2/app/utils';
 
 export default async function RootLayout(props: {
     params: Promise<RouteLayoutParams>;

packages/gitbook-v2/src/app/sites/dynamic/[mode]/[siteURL]/[siteData]/~gitbook/pdf/page.tsx

@@ -1,5 +1,5 @@
-import { type RouteLayoutParams, getDynamicSiteContext } from '@/app/utils';
 import { PDFPage, generatePDFMetadata } from '@/components/PDF';
+import { type RouteLayoutParams, getDynamicSiteContext } from '@v2/app/utils';
 
 export async function generateMetadata({
     params,

packages/gitbook-v2/src/app/sites/static/[mode]/[siteURL]/[siteData]/[pagePath]/page.tsx

@@ -1,9 +1,9 @@
-import { type RouteParams, getPagePathFromParams, getStaticSiteContext } from '@/app/utils';
 import {
     SitePage,
     generateSitePageMetadata,
     generateSitePageViewport,
 } from '@/components/SitePage';
+import { type RouteParams, getPagePathFromParams, getStaticSiteContext } from '@v2/app/utils';
 
 import type { Metadata, Viewport } from 'next';
 

packages/gitbook-v2/src/app/sites/static/[mode]/[siteURL]/[siteData]/layout.tsx

@@ -1,11 +1,11 @@
-import { type RouteLayoutParams, getStaticSiteContext } from '@/app/utils';
 import { CustomizationRootLayout } from '@/components/RootLayout';
 import {
     SiteLayout,
     generateSiteLayoutMetadata,
     generateSiteLayoutViewport,
 } from '@/components/SiteLayout';
-import { shouldTrackEvents } from '@/lib/tracking';
+import { type RouteLayoutParams, getStaticSiteContext } from '@v2/app/utils';
+import { GITBOOK_DISABLE_TRACKING } from '@v2/lib/env';
 
 interface SiteStaticLayoutProps {
     params: Promise<RouteLayoutParams>;
@@ -16,13 +16,12 @@ export default async function SiteStaticLayout({
     children,
 }: React.PropsWithChildren<SiteStaticLayoutProps>) {
     const { context, visitorAuthClaims } = await getStaticSiteContext(await params);
-    const withTracking = shouldTrackEvents();
 
     return (
         <CustomizationRootLayout customization={context.customization}>
             <SiteLayout
                 context={context}
-                withTracking={withTracking}
+                withTracking={!GITBOOK_DISABLE_TRACKING}
                 visitorAuthClaims={visitorAuthClaims}
             >
                 {children}

packages/gitbook-v2/src/app/sites/static/[mode]/[siteURL]/[siteData]/llms.txt/route.ts

@@ -1,7 +1,7 @@
 import type { NextRequest } from 'next/server';
 
-import { type RouteLayoutParams, getStaticSiteContext } from '@/app/utils';
 import { serveLLMsTxt } from '@/routes/llms';
+import { type RouteLayoutParams, getStaticSiteContext } from '@v2/app/utils';
 
 export const dynamic = 'force-static';
 

packages/gitbook-v2/src/app/sites/static/[mode]/[siteURL]/[siteData]/robots.txt/route.ts

@@ -1,7 +1,7 @@
 import type { NextRequest } from 'next/server';
 
-import { type RouteLayoutParams, getStaticSiteContext } from '@/app/utils';
 import { serveRobotsTxt } from '@/routes/robots';
+import { type RouteLayoutParams, getStaticSiteContext } from '@v2/app/utils';
 
 export const dynamic = 'force-static';
 

packages/gitbook-v2/src/app/sites/static/[mode]/[siteURL]/[siteData]/sitemap-pages.xml/route.ts

@@ -1,7 +1,7 @@
 import type { NextRequest } from 'next/server';
 
-import { type RouteLayoutParams, getStaticSiteContext } from '@/app/utils';
 import { servePagesSitemap } from '@/routes/sitemap';
+import { type RouteLayoutParams, getStaticSiteContext } from '@v2/app/utils';
 
 export const dynamic = 'force-static';
 

packages/gitbook-v2/src/app/sites/static/[mode]/[siteURL]/[siteData]/sitemap.xml/route.ts

@@ -1,7 +1,7 @@
 import type { NextRequest } from 'next/server';
 
-import { type RouteLayoutParams, getStaticSiteContext } from '@/app/utils';
 import { serveRootSitemap } from '@/routes/sitemap';
+import { type RouteLayoutParams, getStaticSiteContext } from '@v2/app/utils';
 
 export const dynamic = 'force-static';
 

packages/gitbook-v2/src/app/sites/static/[mode]/[siteURL]/[siteData]/~gitbook/icon/route.ts

@@ -1,7 +1,7 @@
 import type { NextRequest } from 'next/server';
 
-import { type RouteLayoutParams, getStaticSiteContext } from '@/app/utils';
 import { serveIcon } from '@/routes/icon';
+import { type RouteLayoutParams, getStaticSiteContext } from '@v2/app/utils';
 
 export const dynamic = 'force-static';
 

packages/gitbook-v2/src/app/sites/static/[mode]/[siteURL]/[siteData]/~gitbook/markdown/[pagePath]/route.ts

@@ -1,5 +1,5 @@
-import { type RouteParams, getPagePathFromParams, getStaticSiteContext } from '@/app/utils';
 import { servePageMarkdown } from '@/routes/markdownPage';
+import { type RouteParams, getPagePathFromParams, getStaticSiteContext } from '@v2/app/utils';
 import type { NextRequest } from 'next/server';
 
 export const dynamic = 'force-static';

packages/gitbook-v2/src/app/sites/static/[mode]/[siteURL]/[siteData]/~gitbook/ogimage/[pageId]/route.ts

@@ -1,8 +1,8 @@
 import type { NextRequest } from 'next/server';
 
-import { type RouteLayoutParams, getStaticSiteContext } from '@/app/utils';
 import type { PageIdParams } from '@/components/SitePage';
 import { serveOGImage } from '@/routes/ogimage';
+import { type RouteLayoutParams, getStaticSiteContext } from '@v2/app/utils';
 
 export const dynamic = 'force-static';
 

packages/gitbook-v2/src/app/utils.ts

@@ -1,7 +1,6 @@
 import { getVisitorAuthClaims, getVisitorAuthClaimsFromToken } from '@/lib/adaptive';
-import { type SiteURLData, fetchSiteContextByURLLookup, getBaseContext } from '@/lib/context';
-import { getDynamicCustomizationSettings } from '@/lib/customization';
 import type { SiteAPIToken } from '@gitbook/api';
+import { type SiteURLData, fetchSiteContextByURLLookup, getBaseContext } from '@v2/lib/context';
 import { jwtDecode } from 'jwt-decode';
 import { forbidden } from 'next/navigation';
 import rison from 'rison';
@@ -14,7 +13,7 @@ export type RouteLayoutParams = {
     /** URL encoded site URL */
     siteURL: string;
 
-    /** URL and Rison encoded site data from resolvePublishedContentByUrl */
+    /** URL and Rison encoded site data from getPublishedContentByUrl */
     siteData: string;
 };
 
@@ -68,8 +67,6 @@ export async function getDynamicSiteContext(params: RouteLayoutParams) {
         siteURLData
     );
 
-    context.customization = await getDynamicCustomizationSettings(context.customization);
-
     return {
         context,
         visitorAuthClaims: getVisitorAuthClaims(siteURLData),

packages/gitbook-v2/src/app/~gitbook/env/route.ts

@@ -14,7 +14,7 @@ import {
     GITBOOK_SECRET,
     GITBOOK_URL,
     GITBOOK_USER_AGENT,
-} from '@/lib/env';
+} from '@v2/lib/env';
 
 /**
  * Output the public environment variables for this deployment

packages/gitbook-v2/src/app/~gitbook/revalidate/route.ts

@@ -0,0 +1,51 @@
+import { type NextRequest, NextResponse } from 'next/server';
+
+import { withVerifySignature } from '@v2/lib/routes';
+import { revalidatePath, revalidateTag } from 'next/cache';
+
+interface JsonBody {
+    tags: string[];
+    paths?: string[];
+}
+
+/**
+ * Revalidate cached data based on tags.
+ * The body should be a JSON with { tags: string[], paths?: string[] }
+ */
+export async function POST(req: NextRequest) {
+    return withVerifySignature<JsonBody>(req, async (body) => {
+        if (!body.tags || !Array.isArray(body.tags)) {
+            return NextResponse.json(
+                {
+                    error: 'tags must be an array',
+                },
+                { status: 400 }
+            );
+        }
+
+        if (body.paths && !Array.isArray(body.paths)) {
+            return NextResponse.json(
+                {
+                    error: 'paths must be an array',
+                },
+                { status: 400 }
+            );
+        }
+
+        body.tags.forEach((tag) => {
+            // biome-ignore lint/suspicious/noConsole: we want to log here
+            console.log(`Revalidating tag: ${tag}`);
+            revalidateTag(tag);
+        });
+
+        body.paths?.forEach((path) => {
+            // biome-ignore lint/suspicious/noConsole: we want to log here
+            console.log(`Revalidating path: ${path}`);
+            revalidatePath(path);
+        });
+
+        return NextResponse.json({
+            success: true,
+        });
+    });
+}

packages/gitbook-v2/src/app/~space/[spaceId]/pdf.ts

@@ -2,10 +2,10 @@ import {
     type GitBookBaseContext,
     type GitBookSpaceContext,
     fetchSpaceContextByIds,
-} from '@/lib/context';
+} from '@v2/lib/context';
-import { createDataFetcher } from '@/lib/data';
+import { createDataFetcher } from '@v2/lib/data';
-import { createLinker } from '@/lib/links';
+import { createLinker } from '@v2/lib/links';
-import { getAPITokenFromMiddleware } from '@/lib/middleware';
+import { getAPITokenFromMiddleware } from '@v2/lib/middleware';
 
 export type SpacePDFRouteParams = {
     spaceId: string;

packages/gitbook-v2/src/app/~space/[spaceId]/~/changes/[changeRequestId]/~gitbook/pdf/layout.tsx

@@ -0,0 +1,2 @@
+import RootLayout from '@v2/app/~space/[spaceId]/~gitbook/pdf/layout';
+export default RootLayout;

packages/gitbook-v2/src/app/~space/[spaceId]/~/changes/[changeRequestId]/~gitbook/pdf/page.tsx

@@ -0,0 +1,4 @@
+import PDFPage, { generateMetadata } from '@v2/app/~space/[spaceId]/~gitbook/pdf/page';
+
+export default PDFPage;
+export { generateMetadata };

packages/gitbook-v2/src/app/~space/[spaceId]/~/revisions/[changeRequestId]/~gitbook/pdf/layout.tsx

@@ -0,0 +1,2 @@
+import RootLayout from '@v2/app/~space/[spaceId]/~gitbook/pdf/layout';
+export default RootLayout;

packages/gitbook-v2/src/app/~space/[spaceId]/~/revisions/[changeRequestId]/~gitbook/pdf/page.tsx

@@ -0,0 +1,4 @@
+import PDFPage, { generateMetadata } from '@v2/app/~space/[spaceId]/~gitbook/pdf/page';
+
+export default PDFPage;
+export { generateMetadata };

packages/gitbook-v2/src/app/~space/[spaceId]/~gitbook/pdf/layout.tsx

@@ -1,5 +1,5 @@
-import { type SpacePDFRouteParams, getSpacePDFContext } from '@/app/~space/[spaceId]/pdf';
 import { PDFRootLayout } from '@/components/PDF';
+import { type SpacePDFRouteParams, getSpacePDFContext } from '@v2/app/~space/[spaceId]/pdf';
 
 export default async function RootLayout(props: {
     params: Promise<SpacePDFRouteParams>;

packages/gitbook-v2/src/app/~space/[spaceId]/~gitbook/pdf/page.tsx

@@ -1,5 +1,5 @@
-import { type SpacePDFRouteParams, getSpacePDFContext } from '@/app/~space/[spaceId]/pdf';
 import { PDFPage, generatePDFMetadata } from '@/components/PDF';
+import { type SpacePDFRouteParams, getSpacePDFContext } from '@v2/app/~space/[spaceId]/pdf';
 
 export async function generateMetadata({
     params,

packages/gitbook-v2/src/lib/context.ts

@@ -1,15 +1,8 @@
-import {
-    type GitBookDataFetcher,
-    createDataFetcher,
-    getDataOrNull,
-    throwIfDataError,
-} from '@/lib/data';
-import { getLogger } from '@/lib/logger';
 import { getSiteStructureSections } from '@/lib/sites';
 import type {
     ChangeRequest,
     PublishedSiteContent,
-    Revision,
+    RevisionPage,
     RevisionPageDocument,
     Site,
     SiteCustomizationSettings,
@@ -20,12 +13,18 @@ import type {
     SiteStructure,
     Space,
 } from '@gitbook/api';
+import {
+    type GitBookDataFetcher,
+    createDataFetcher,
+    getDataOrNull,
+    throwIfDataError,
+} from '@v2/lib/data';
 import assertNever from 'assert-never';
 import { notFound } from 'next/navigation';
 import { assert } from 'ts-essentials';
 import { GITBOOK_URL } from './env';
 import { type ImageResizer, createImageResizer } from './images';
-import { type GitBookLinker, createLinker, linkerForPublishedURL } from './links';
+import { type GitBookLinker, createLinker } from './links';
 
 /**
  * Data about the site URL. Provided by the middleware.
@@ -44,7 +43,6 @@ export type SiteURLData = Pick<
     | 'siteSection'
     | 'siteBasePath'
     | 'basePath'
-    | 'contextId'
 > & {
     /**
      * Identifier used for image resizing.
@@ -86,12 +84,12 @@ export type GitBookSpaceContext = GitBookBaseContext & {
     space: Space;
     changeRequest: ChangeRequest | null;
 
-    /** Revision of the space. */
+    /** ID of the current revision. */
-    revision: Revision;
-
-    /** Identifier of the revision. Could be different than `revision.id` when using computed. */
     revisionId: string;
 
+    /** Pages of the space. */
+    pages: RevisionPage[];
+
     /** Share key of the space. */
     shareKey: string | undefined;
 };
@@ -124,9 +122,6 @@ export type GitBookSiteContext = GitBookSpaceContext & {
 
     /** Scripts to load for the site. */
     scripts: SiteIntegrationScript[];
-
-    /** Context ID used by adaptive content. It represents an unique identifier for the authentication context */
-    contextId?: string;
 };
 
 /**
@@ -204,7 +199,6 @@ export async function fetchSiteContextByURLLookup(
         shareKey: data.shareKey,
         changeRequest: data.changeRequest,
         revision: data.revision,
-        contextId: data.contextId,
     });
 }
 
@@ -222,7 +216,6 @@ export async function fetchSiteContextByIds(
         shareKey: string | undefined;
         changeRequest: string | undefined;
         revision: string | undefined;
-        contextId?: string;
     }
 ): Promise<GitBookSiteContext> {
     const { dataFetcher } = baseContext;
@@ -297,11 +290,10 @@ export async function fetchSiteContextByIds(
                 return siteSpaceSettings;
             }
 
-            const logger = getLogger().subLogger('fetchSiteContextByIds', {});
             // We got the pointer from an API and customizations from another.
             // It's possible that the two are unsynced leading to not found customizations for the space.
             // It's better to fallback on customization of the site that displaying an error.
-            logger.warn('Customization not found for site space', ids.siteSpace);
+            console.warn('Customization not found for site space', ids.siteSpace);
         }
 
         return customizations.site;
@@ -309,9 +301,6 @@ export async function fetchSiteContextByIds(
 
     return {
         ...spaceContext,
-        linker: site.urls.published
-            ? linkerForPublishedURL(spaceContext.linker, site.urls.published)
-            : spaceContext.linker,
         organizationId: ids.organization,
         site,
         siteSpaces,
@@ -320,7 +309,6 @@ export async function fetchSiteContextByIds(
         structure: siteStructure,
         sections,
         scripts,
-        contextId: ids.contextId,
     };
 }
 
@@ -363,17 +351,20 @@ export async function fetchSpaceContextByIds(
 
     const revisionId = ids.revision ?? changeRequest?.revision ?? space.revision;
 
-    const revision = await getDataOrNull(
+    const pages = await getDataOrNull(
-        dataFetcher.getRevision({
+        dataFetcher.getRevisionPages({
             spaceId: ids.space,
             revisionId,
+            // We only care about the Git metadata when the Git sync is enabled,
+            // otherwise we can optimize performance by not fetching it
+            metadata: !!space.gitSync,
         }),
 
         // When trying to render a revision with an invalid / non-existing ID,
         // we should handle gracefully the 404 and throw notFound.
         ids.revision ? [404] : undefined
     );
-    if (!revision) {
+    if (!pages) {
         notFound();
     }
 
@@ -381,9 +372,9 @@ export async function fetchSpaceContextByIds(
         ...baseContext,
         organizationId: space.organization,
         space,
-        revision,
+        pages,
-        revisionId,
         changeRequest,
+        revisionId,
         shareKey: ids.shareKey,
     };
 }

packages/gitbook-v2/src/lib/data/api.ts

@@ -0,0 +1,873 @@
+import { trace } from '@/lib/tracing';
+import {
+    type ComputedContentSource,
+    GitBookAPI,
+    type GitBookAPIServiceBinding,
+    type HttpResponse,
+    type RenderIntegrationUI,
+} from '@gitbook/api';
+import { getCacheTag, getComputedContentSourceCacheTags } from '@gitbook/cache-tags';
+import { GITBOOK_API_TOKEN, GITBOOK_API_URL, GITBOOK_USER_AGENT } from '@v2/lib/env';
+import { unstable_cacheLife as cacheLife, unstable_cacheTag as cacheTag } from 'next/cache';
+import { getCloudflareContext, getCloudflareRequestGlobal } from './cloudflare';
+import { DataFetcherError, wrapDataFetcherError } from './errors';
+import { withCacheKey, withoutConcurrentExecution } from './memoize';
+import type { GitBookDataFetcher } from './types';
+
+interface DataFetcherInput {
+    /**
+     * API token.
+     */
+    apiToken: string | null;
+}
+
+/**
+ * Options to pass to the `fetch` call to disable the Next data-cache when wrapped in `use cache`.
+ */
+export const noCacheFetchOptions: Partial<RequestInit> = {
+    next: {
+        revalidate: 0,
+    },
+};
+
+/**
+ * Create a data fetcher using an API token.
+ * The data are being cached by Next.js built-in cache.
+ */
+export function createDataFetcher(
+    input: DataFetcherInput = { apiToken: null }
+): GitBookDataFetcher {
+    return {
+        async api() {
+            return apiClient(input);
+        },
+
+        withToken({ apiToken }) {
+            return createDataFetcher({
+                apiToken,
+            });
+        },
+
+        //
+        // API that are tied to the token
+        //
+        getPublishedContentSite(params) {
+            return trace('getPublishedContentSite', () =>
+                getPublishedContentSite(input, {
+                    organizationId: params.organizationId,
+                    siteId: params.siteId,
+                    siteShareKey: params.siteShareKey,
+                })
+            );
+        },
+        getSiteRedirectBySource(params) {
+            return trace('getSiteRedirectBySource', () =>
+                getSiteRedirectBySource(input, {
+                    organizationId: params.organizationId,
+                    siteId: params.siteId,
+                    siteShareKey: params.siteShareKey,
+                    source: params.source,
+                })
+            );
+        },
+        getRevision(params) {
+            return trace('getRevision', () =>
+                getRevision(input, {
+                    spaceId: params.spaceId,
+                    revisionId: params.revisionId,
+                    metadata: params.metadata,
+                })
+            );
+        },
+        getRevisionPages(params) {
+            return trace('getRevisionPages', () =>
+                getRevisionPages(input, {
+                    spaceId: params.spaceId,
+                    revisionId: params.revisionId,
+                    metadata: params.metadata,
+                })
+            );
+        },
+        getRevisionFile(params) {
+            return trace('getRevisionFile', () =>
+                getRevisionFile(input, {
+                    spaceId: params.spaceId,
+                    revisionId: params.revisionId,
+                    fileId: params.fileId,
+                })
+            );
+        },
+        getRevisionPageByPath(params) {
+            return trace('getRevisionPageByPath', () =>
+                getRevisionPageByPath(input, {
+                    spaceId: params.spaceId,
+                    revisionId: params.revisionId,
+                    path: params.path,
+                })
+            );
+        },
+        getRevisionPageMarkdown(params) {
+            return trace('getRevisionPageMarkdown', () =>
+                getRevisionPageMarkdown(input, {
+                    spaceId: params.spaceId,
+                    revisionId: params.revisionId,
+                    pageId: params.pageId,
+                })
+            );
+        },
+        getReusableContent(params) {
+            return trace('getReusableContent', () =>
+                getReusableContent(input, {
+                    spaceId: params.spaceId,
+                    revisionId: params.revisionId,
+                    reusableContentId: params.reusableContentId,
+                })
+            );
+        },
+        getLatestOpenAPISpecVersionContent(params) {
+            return trace('getLatestOpenAPISpecVersionContent', () =>
+                getLatestOpenAPISpecVersionContent(input, {
+                    organizationId: params.organizationId,
+                    slug: params.slug,
+                })
+            );
+        },
+        getSpace(params) {
+            return trace('getSpace', () =>
+                getSpace(input, {
+                    spaceId: params.spaceId,
+                    shareKey: params.shareKey,
+                })
+            );
+        },
+        getChangeRequest(params) {
+            return trace('getChangeRequest', () =>
+                getChangeRequest(input, {
+                    spaceId: params.spaceId,
+                    changeRequestId: params.changeRequestId,
+                })
+            );
+        },
+        getDocument(params) {
+            return trace('getDocument', () =>
+                getDocument(input, {
+                    spaceId: params.spaceId,
+                    documentId: params.documentId,
+                })
+            );
+        },
+        getComputedDocument(params) {
+            return trace('getComputedDocument', () =>
+                getComputedDocument(input, {
+                    organizationId: params.organizationId,
+                    spaceId: params.spaceId,
+                    source: params.source,
+                    seed: params.seed,
+                })
+            );
+        },
+        getEmbedByUrl(params) {
+            return trace('getEmbedByUrl', () =>
+                getEmbedByUrl(input, {
+                    url: params.url,
+                    spaceId: params.spaceId,
+                })
+            );
+        },
+        searchSiteContent(params) {
+            return trace('searchSiteContent', () => searchSiteContent(input, params));
+        },
+
+        renderIntegrationUi(params) {
+            return trace('renderIntegrationUi', () =>
+                renderIntegrationUi(input, {
+                    integrationName: params.integrationName,
+                    request: params.request,
+                })
+            );
+        },
+
+        getUserById(userId) {
+            return trace('getUserById', () => getUserById(input, { userId }));
+        },
+
+        streamAIResponse(params) {
+            return streamAIResponse(input, params);
+        },
+    };
+}
+
+const getUserById = withCacheKey(
+    withoutConcurrentExecution(
+        getCloudflareRequestGlobal,
+        async (_, input: DataFetcherInput, params: { userId: string }) => {
+            'use cache';
+            return trace(`getUserById(${params.userId})`, async () => {
+                return wrapDataFetcherError(async () => {
+                    const api = apiClient(input);
+                    const res = await api.users.getUserById(params.userId, {
+                        ...noCacheFetchOptions,
+                    });
+                    cacheTag(...getCacheTagsFromResponse(res));
+                    cacheLife('days');
+                    return res.data;
+                });
+            });
+        }
+    )
+);
+
+const getSpace = withCacheKey(
+    withoutConcurrentExecution(
+        getCloudflareRequestGlobal,
+        async (
+            _,
+            input: DataFetcherInput,
+            params: { spaceId: string; shareKey: string | undefined }
+        ) => {
+            'use cache';
+            cacheTag(
+                getCacheTag({
+                    tag: 'space',
+                    space: params.spaceId,
+                })
+            );
+
+            return trace(`getSpace(${params.spaceId}, ${params.shareKey})`, async () => {
+                return wrapDataFetcherError(async () => {
+                    const api = apiClient(input);
+                    const res = await api.spaces.getSpaceById(
+                        params.spaceId,
+                        {
+                            shareKey: params.shareKey,
+                        },
+                        {
+                            ...noCacheFetchOptions,
+                        }
+                    );
+                    cacheTag(...getCacheTagsFromResponse(res));
+                    cacheLife('days');
+                    return res.data;
+                });
+            });
+        }
+    )
+);
+
+const getChangeRequest = withCacheKey(
+    withoutConcurrentExecution(
+        getCloudflareRequestGlobal,
+        async (
+            _,
+            input: DataFetcherInput,
+            params: { spaceId: string; changeRequestId: string }
+        ) => {
+            'use cache';
+            cacheTag(
+                getCacheTag({
+                    tag: 'change-request',
+                    space: params.spaceId,
+                    changeRequest: params.changeRequestId,
+                })
+            );
+
+            return trace(
+                `getChangeRequest(${params.spaceId}, ${params.changeRequestId})`,
+                async () => {
+                    return wrapDataFetcherError(async () => {
+                        const api = apiClient(input);
+                        const res = await api.spaces.getChangeRequestById(
+                            params.spaceId,
+                            params.changeRequestId,
+                            {
+                                ...noCacheFetchOptions,
+                            }
+                        );
+                        cacheTag(...getCacheTagsFromResponse(res));
+                        cacheLife('minutes');
+                        return res.data;
+                    });
+                }
+            );
+        }
+    )
+);
+
+const getRevision = withCacheKey(
+    withoutConcurrentExecution(
+        getCloudflareRequestGlobal,
+        async (
+            _,
+            input: DataFetcherInput,
+            params: { spaceId: string; revisionId: string; metadata: boolean }
+        ) => {
+            'use cache';
+            return trace(`getRevision(${params.spaceId}, ${params.revisionId})`, async () => {
+                return wrapDataFetcherError(async () => {
+                    const api = apiClient(input);
+                    const res = await api.spaces.getRevisionById(
+                        params.spaceId,
+                        params.revisionId,
+                        {
+                            metadata: params.metadata,
+                        },
+                        {
+                            ...noCacheFetchOptions,
+                        }
+                    );
+                    cacheTag(...getCacheTagsFromResponse(res));
+                    cacheLife('max');
+                    return res.data;
+                });
+            });
+        }
+    )
+);
+
+const getRevisionPages = withCacheKey(
+    withoutConcurrentExecution(
+        getCloudflareRequestGlobal,
+        async (
+            _,
+            input: DataFetcherInput,
+            params: { spaceId: string; revisionId: string; metadata: boolean }
+        ) => {
+            'use cache';
+            return trace(`getRevisionPages(${params.spaceId}, ${params.revisionId})`, async () => {
+                return wrapDataFetcherError(async () => {
+                    const api = apiClient(input);
+                    const res = await api.spaces.listPagesInRevisionById(
+                        params.spaceId,
+                        params.revisionId,
+                        {
+                            metadata: params.metadata,
+                        },
+                        {
+                            ...noCacheFetchOptions,
+                        }
+                    );
+                    cacheTag(...getCacheTagsFromResponse(res));
+                    cacheLife('max');
+                    return res.data.pages;
+                });
+            });
+        }
+    )
+);
+
+const getRevisionFile = withCacheKey(
+    withoutConcurrentExecution(
+        getCloudflareRequestGlobal,
+        async (
+            _,
+            input: DataFetcherInput,
+            params: { spaceId: string; revisionId: string; fileId: string }
+        ) => {
+            'use cache';
+            return trace(
+                `getRevisionFile(${params.spaceId}, ${params.revisionId}, ${params.fileId})`,
+                async () => {
+                    return wrapDataFetcherError(async () => {
+                        const api = apiClient(input);
+                        const res = await api.spaces.getFileInRevisionById(
+                            params.spaceId,
+                            params.revisionId,
+                            params.fileId,
+                            {},
+                            {
+                                ...noCacheFetchOptions,
+                            }
+                        );
+                        cacheTag(...getCacheTagsFromResponse(res));
+                        cacheLife('max');
+                        return res.data;
+                    });
+                }
+            );
+        }
+    )
+);
+
+const getRevisionPageMarkdown = withCacheKey(
+    withoutConcurrentExecution(
+        getCloudflareRequestGlobal,
+        async (
+            _,
+            input: DataFetcherInput,
+            params: { spaceId: string; revisionId: string; pageId: string }
+        ) => {
+            'use cache';
+            return trace(
+                `getRevisionPageMarkdown(${params.spaceId}, ${params.revisionId}, ${params.pageId})`,
+                async () => {
+                    return wrapDataFetcherError(async () => {
+                        const api = apiClient(input);
+                        const res = await api.spaces.getPageInRevisionById(
+                            params.spaceId,
+                            params.revisionId,
+                            params.pageId,
+                            {
+                                format: 'markdown',
+                            },
+                            {
+                                ...noCacheFetchOptions,
+                            }
+                        );
+
+                        cacheTag(...getCacheTagsFromResponse(res));
+                        cacheLife('max');
+
+                        if (!('markdown' in res.data)) {
+                            throw new DataFetcherError('Page is not a document', 404);
+                        }
+                        return res.data.markdown;
+                    });
+                }
+            );
+        }
+    )
+);
+
+const getRevisionPageByPath = withCacheKey(
+    withoutConcurrentExecution(
+        getCloudflareRequestGlobal,
+        async (
+            _,
+            input: DataFetcherInput,
+            params: { spaceId: string; revisionId: string; path: string }
+        ) => {
+            'use cache';
+            return trace(
+                `getRevisionPageByPath(${params.spaceId}, ${params.revisionId}, ${params.path})`,
+                async () => {
+                    const encodedPath = encodeURIComponent(params.path);
+                    return wrapDataFetcherError(async () => {
+                        const api = apiClient(input);
+                        const res = await api.spaces.getPageInRevisionByPath(
+                            params.spaceId,
+                            params.revisionId,
+                            encodedPath,
+                            {},
+                            {
+                                ...noCacheFetchOptions,
+                            }
+                        );
+                        cacheTag(...getCacheTagsFromResponse(res));
+                        cacheLife('max');
+                        return res.data;
+                    });
+                }
+            );
+        }
+    )
+);
+
+const getDocument = withCacheKey(
+    withoutConcurrentExecution(
+        getCloudflareRequestGlobal,
+        async (_, input: DataFetcherInput, params: { spaceId: string; documentId: string }) => {
+            'use cache';
+            return trace(`getDocument(${params.spaceId}, ${params.documentId})`, async () => {
+                return wrapDataFetcherError(async () => {
+                    const api = apiClient(input);
+                    const res = await api.spaces.getDocumentById(
+                        params.spaceId,
+                        params.documentId,
+                        {},
+                        {
+                            ...noCacheFetchOptions,
+                        }
+                    );
+                    cacheTag(...getCacheTagsFromResponse(res));
+                    cacheLife('max');
+                    return res.data;
+                });
+            });
+        }
+    )
+);
+
+const getComputedDocument = withCacheKey(
+    withoutConcurrentExecution(
+        getCloudflareRequestGlobal,
+        async (
+            _,
+            input: DataFetcherInput,
+            params: {
+                spaceId: string;
+                organizationId: string;
+                source: ComputedContentSource;
+                seed: string;
+            }
+        ) => {
+            'use cache';
+            cacheTag(
+                ...getComputedContentSourceCacheTags(
+                    {
+                        spaceId: params.spaceId,
+                        organizationId: params.organizationId,
+                    },
+                    params.source
+                )
+            );
+
+            return trace(
+                `getComputedDocument(${params.spaceId}, ${params.organizationId}, ${params.source.type}, ${params.seed})`,
+                async () => {
+                    return wrapDataFetcherError(async () => {
+                        const api = apiClient(input);
+                        const res = await api.spaces.getComputedDocument(
+                            params.spaceId,
+                            {
+                                source: params.source,
+                                seed: params.seed,
+                            },
+                            {},
+                            {
+                                ...noCacheFetchOptions,
+                            }
+                        );
+                        cacheTag(...getCacheTagsFromResponse(res));
+                        cacheLife('max');
+                        return res.data;
+                    });
+                }
+            );
+        }
+    )
+);
+
+const getReusableContent = withCacheKey(
+    withoutConcurrentExecution(
+        getCloudflareRequestGlobal,
+        async (
+            _,
+            input: DataFetcherInput,
+            params: { spaceId: string; revisionId: string; reusableContentId: string }
+        ) => {
+            'use cache';
+            return trace(
+                `getReusableContent(${params.spaceId}, ${params.revisionId}, ${params.reusableContentId})`,
+                async () => {
+                    return wrapDataFetcherError(async () => {
+                        const api = apiClient(input);
+                        const res = await api.spaces.getReusableContentInRevisionById(
+                            params.spaceId,
+                            params.revisionId,
+                            params.reusableContentId,
+                            {},
+                            {
+                                ...noCacheFetchOptions,
+                            }
+                        );
+                        cacheTag(...getCacheTagsFromResponse(res));
+                        cacheLife('max');
+                        return res.data;
+                    });
+                }
+            );
+        }
+    )
+);
+
+const getLatestOpenAPISpecVersionContent = withCacheKey(
+    withoutConcurrentExecution(
+        getCloudflareRequestGlobal,
+        async (_, input: DataFetcherInput, params: { organizationId: string; slug: string }) => {
+            'use cache';
+            cacheTag(
+                getCacheTag({
+                    tag: 'openapi',
+                    organization: params.organizationId,
+                    openAPISpec: params.slug,
+                })
+            );
+
+            return trace(
+                `getLatestOpenAPISpecVersionContent(${params.organizationId}, ${params.slug})`,
+                async () => {
+                    return wrapDataFetcherError(async () => {
+                        const api = apiClient(input);
+                        const res = await api.orgs.getLatestOpenApiSpecVersionContent(
+                            params.organizationId,
+                            params.slug,
+                            {
+                                ...noCacheFetchOptions,
+                            }
+                        );
+                        cacheTag(...getCacheTagsFromResponse(res));
+                        cacheLife('max');
+                        return res.data;
+                    });
+                }
+            );
+        }
+    )
+);
+
+const getPublishedContentSite = withCacheKey(
+    withoutConcurrentExecution(
+        getCloudflareRequestGlobal,
+        async (
+            _,
+            input: DataFetcherInput,
+            params: { organizationId: string; siteId: string; siteShareKey: string | undefined }
+        ) => {
+            'use cache';
+            cacheTag(
+                getCacheTag({
+                    tag: 'site',
+                    site: params.siteId,
+                })
+            );
+
+            return trace(
+                `getPublishedContentSite(${params.organizationId}, ${params.siteId}, ${params.siteShareKey})`,
+                async () => {
+                    return wrapDataFetcherError(async () => {
+                        const api = apiClient(input);
+                        const res = await api.orgs.getPublishedContentSite(
+                            params.organizationId,
+                            params.siteId,
+                            {
+                                shareKey: params.siteShareKey,
+                            },
+                            {
+                                ...noCacheFetchOptions,
+                            }
+                        );
+                        cacheTag(...getCacheTagsFromResponse(res));
+                        cacheLife('days');
+                        return res.data;
+                    });
+                }
+            );
+        }
+    )
+);
+
+const getSiteRedirectBySource = withCacheKey(
+    withoutConcurrentExecution(
+        getCloudflareRequestGlobal,
+        async (
+            _,
+            input: DataFetcherInput,
+            params: {
+                organizationId: string;
+                siteId: string;
+                siteShareKey: string | undefined;
+                source: string;
+            }
+        ) => {
+            'use cache';
+            cacheTag(
+                getCacheTag({
+                    tag: 'site',
+                    site: params.siteId,
+                })
+            );
+
+            return trace(
+                `getSiteRedirectBySource(${params.organizationId}, ${params.siteId}, ${params.siteShareKey}, ${params.source})`,
+                async () => {
+                    return wrapDataFetcherError(async () => {
+                        const api = apiClient(input);
+                        const res = await api.orgs.getSiteRedirectBySource(
+                            params.organizationId,
+                            params.siteId,
+                            {
+                                shareKey: params.siteShareKey,
+                                source: params.source,
+                            },
+                            {
+                                ...noCacheFetchOptions,
+                            }
+                        );
+                        cacheTag(...getCacheTagsFromResponse(res));
+                        cacheLife('days');
+                        return res.data;
+                    });
+                }
+            );
+        }
+    )
+);
+
+const getEmbedByUrl = withCacheKey(
+    withoutConcurrentExecution(
+        getCloudflareRequestGlobal,
+        async (_, input: DataFetcherInput, params: { spaceId: string; url: string }) => {
+            'use cache';
+            cacheTag(
+                getCacheTag({
+                    tag: 'space',
+                    space: params.spaceId,
+                })
+            );
+
+            return trace(`getEmbedByUrl(${params.spaceId}, ${params.url})`, async () => {
+                return wrapDataFetcherError(async () => {
+                    const api = apiClient(input);
+                    const res = await api.spaces.getEmbedByUrlInSpace(
+                        params.spaceId,
+                        {
+                            url: params.url,
+                        },
+                        {
+                            ...noCacheFetchOptions,
+                        }
+                    );
+                    cacheTag(...getCacheTagsFromResponse(res));
+                    cacheLife('weeks');
+                    return res.data;
+                });
+            });
+        }
+    )
+);
+
+const searchSiteContent = withCacheKey(
+    withoutConcurrentExecution(
+        getCloudflareRequestGlobal,
+        async (
+            _,
+            input: DataFetcherInput,
+            params: Parameters<GitBookDataFetcher['searchSiteContent']>[0]
+        ) => {
+            'use cache';
+            cacheTag(
+                getCacheTag({
+                    tag: 'site',
+                    site: params.siteId,
+                })
+            );
+
+            return trace(
+                `searchSiteContent(${params.organizationId}, ${params.siteId}, ${params.query})`,
+                async () => {
+                    return wrapDataFetcherError(async () => {
+                        const { organizationId, siteId, query, scope } = params;
+                        const api = apiClient(input);
+                        const res = await api.orgs.searchSiteContent(
+                            organizationId,
+                            siteId,
+                            {
+                                query,
+                                ...scope,
+                            },
+                            {},
+                            {
+                                ...noCacheFetchOptions,
+                            }
+                        );
+                        cacheTag(...getCacheTagsFromResponse(res));
+                        cacheLife('hours');
+                        return res.data.items;
+                    });
+                }
+            );
+        }
+    )
+);
+
+const renderIntegrationUi = withCacheKey(
+    withoutConcurrentExecution(
+        getCloudflareRequestGlobal,
+        async (
+            _,
+            input: DataFetcherInput,
+            params: { integrationName: string; request: RenderIntegrationUI }
+        ) => {
+            'use cache';
+            cacheTag(
+                getCacheTag({
+                    tag: 'integration',
+                    integration: params.integrationName,
+                })
+            );
+
+            return trace(`renderIntegrationUi(${params.integrationName})`, async () => {
+                return wrapDataFetcherError(async () => {
+                    const api = apiClient(input);
+                    const res = await api.integrations.renderIntegrationUiWithPost(
+                        params.integrationName,
+                        params.request,
+                        {
+                            ...noCacheFetchOptions,
+                        }
+                    );
+                    cacheTag(...getCacheTagsFromResponse(res));
+                    cacheLife('days');
+                    return res.data;
+                });
+            });
+        }
+    )
+);
+
+async function* streamAIResponse(
+    input: DataFetcherInput,
+    params: Parameters<GitBookDataFetcher['streamAIResponse']>[0]
+) {
+    const api = apiClient(input);
+    const res = await api.orgs.streamAiResponseInSite(
+        params.organizationId,
+        params.siteId,
+        {
+            input: params.input,
+            output: params.output,
+            model: params.model,
+        },
+        {
+            ...noCacheFetchOptions,
+        }
+    );
+
+    for await (const event of res) {
+        yield event;
+    }
+}
+
+let loggedServiceBinding = false;
+
+/**
+ * Create a new API client.
+ */
+export function apiClient(input: DataFetcherInput = { apiToken: null }) {
+    const { apiToken } = input;
+    let serviceBinding: GitBookAPIServiceBinding | undefined;
+
+    const cloudflareContext = getCloudflareContext();
+    if (cloudflareContext) {
+        // @ts-expect-error
+        serviceBinding = cloudflareContext.env.GITBOOK_API as GitBookAPIServiceBinding | undefined;
+        if (!loggedServiceBinding) {
+            loggedServiceBinding = true;
+            if (serviceBinding) {
+                // biome-ignore lint/suspicious/noConsole: we want to log here
+                console.log(`using service binding for the API (${GITBOOK_API_URL})`);
+            } else {
+                // biome-ignore lint/suspicious/noConsole: we want to log here
+                console.warn(`no service binding for the API (${GITBOOK_API_URL})`);
+            }
+        }
+    }
+
+    const api = new GitBookAPI({
+        authToken: apiToken || GITBOOK_API_TOKEN || undefined,
+        endpoint: GITBOOK_API_URL,
+        userAgent: GITBOOK_USER_AGENT,
+        serviceBinding,
+    });
+
+    return api;
+}
+
+/**
+ * Get the tags from the API responses.
+ */
+function getCacheTagsFromResponse(response: HttpResponse<unknown, unknown>) {
+    const cacheTagHeader = response.headers.get('x-gitbook-cache-tag');
+    const tags = !cacheTagHeader ? [] : cacheTagHeader.split(',');
+    return tags;
+}

packages/gitbook-v2/src/lib/data/cloudflare.ts

@@ -11,3 +11,15 @@ export function getCloudflareContext() {
 
     return getCloudflareContextOpenNext();
 }
+
+/**
+ * Return an object representing the current request.
+ */
+export function getCloudflareRequestGlobal() {
+    const context = getCloudflareContext();
+    if (!context) {
+        return null;
+    }
+
+    return context.cf;
+}

packages/gitbook-v2/src/lib/data/errors.ts

@@ -0,0 +1,123 @@
+import { GitBookAPIError } from '@gitbook/api';
+import type { DataFetcherErrorData, DataFetcherResponse } from './types';
+
+export class DataFetcherError extends Error {
+    constructor(
+        message: string,
+        public readonly code: number
+    ) {
+        super(message);
+    }
+}
+
+/**
+ * Throw an error if the response contains an error.
+ */
+export function throwIfDataError<T>(response: DataFetcherResponse<T>): T;
+export function throwIfDataError<T>(response: Promise<DataFetcherResponse<T>>): Promise<T>;
+export function throwIfDataError<T>(
+    response: DataFetcherResponse<T> | Promise<DataFetcherResponse<T>>
+): T | Promise<T> {
+    if (response instanceof Promise) {
+        return response.then((result) => throwIfDataError(result));
+    }
+
+    if (response.error) {
+        throw new DataFetcherError(response.error.message, response.error.code);
+    }
+    return response.data;
+}
+
+/**
+ * Get the data from the response or null if there is an "Not found" error.
+ */
+export function getDataOrNull<T>(
+    response: DataFetcherResponse<T>,
+    ignoreErrors?: number[]
+): T | null;
+export function getDataOrNull<T>(
+    response: Promise<DataFetcherResponse<T>>,
+    ignoreErrors?: number[]
+): Promise<T | null>;
+export function getDataOrNull<T>(
+    response: DataFetcherResponse<T> | Promise<DataFetcherResponse<T>>,
+    ignoreErrors: number[] = [404]
+): T | null | Promise<T | null> {
+    if (response instanceof Promise) {
+        return response.then((result) => getDataOrNull(result, ignoreErrors));
+    }
+
+    if (response.error) {
+        if (ignoreErrors.includes(response.error.code)) return null;
+        throw new DataFetcherError(response.error.message, response.error.code);
+    }
+    return response.data;
+}
+
+/**
+ * Ignore error for an API or data call.
+ */
+export async function ignoreDataThrownError<T>(promise: Promise<T>): Promise<T | null> {
+    try {
+        return await promise;
+    } catch (error) {
+        getExposableError(error as Error);
+        return null;
+    }
+}
+
+/**
+ * Ignore all errors for an API or data call.
+ */
+export async function ignoreAllThrownError<T>(promise: Promise<T>): Promise<T | null> {
+    try {
+        return await promise;
+    } catch (error) {
+        console.warn('Ignoring error', error);
+        return null;
+    }
+}
+
+/**
+ * Wrap an async execution to handle errors and return a DataFetcherResponse.
+ */
+export async function wrapDataFetcherError<T>(
+    fn: () => Promise<T>
+): Promise<DataFetcherResponse<T>> {
+    try {
+        return { data: await fn() };
+    } catch (error) {
+        return {
+            error: getExposableError(error as Error),
+        };
+    }
+}
+
+/**
+ * Get a data fetcher exposable error from a JS error.
+ */
+export function getExposableError(error: Error): DataFetcherErrorData {
+    if (error instanceof GitBookAPIError) {
+        if (error.code >= 500) {
+            throw error;
+        }
+
+        return {
+            code: error.code,
+            message: error.errorMessage,
+        };
+    }
+
+    if (error instanceof DataFetcherError) {
+        if (error.code >= 500) {
+            throw error;
+        }
+
+        return {
+            code: error.code,
+            message: error.message,
+        };
+    }
+
+    throw error;
+}

packages/gitbook-v2/src/lib/data/index.ts

@@ -1,8 +1,7 @@
 export * from './api';
 export * from './types';
+export * from './pages';
 export * from './urls';
 export * from './errors';
 export * from './lookup';
 export * from './visitor';
-export * from './pages';
-export * from './revisions';

packages/gitbook-v2/src/lib/data/lookup.ts

@@ -1,7 +1,7 @@
 import { race, tryCatch } from '@/lib/async';
 import { joinPath, joinPathWithBaseURL } from '@/lib/paths';
 import { trace } from '@/lib/tracing';
-import type { PublishedSiteContentLookup, SiteVisitorPayload } from '@gitbook/api';
+import type { GitBookAPI, PublishedSiteContentLookup, SiteVisitorPayload } from '@gitbook/api';
 import { apiClient } from './api';
 import { getExposableError } from './errors';
 import type { DataFetcherResponse } from './types';
@@ -18,25 +18,21 @@ interface LookupPublishedContentByUrlInput {
  * Lookup a content by its URL using the GitBook resolvePublishedContentByUrl API endpoint.
  * To optimize caching, we try multiple lookup alternatives and return the first one that matches.
  */
-export async function lookupPublishedContentByUrl(
+export async function resolvePublishedContentByUrl(input: LookupPublishedContentByUrlInput) {
-    input: LookupPublishedContentByUrlInput
+    return lookupPublishedContentByUrl({
-): Promise<DataFetcherResponse<PublishedSiteContentLookup>> {
+        url: input.url,
-    const lookupURL = new URL(input.url);
+        fetchLookupAPIResult: ({ url, signal }) => {
-    const url = stripURLSearch(lookupURL);
-    const lookup = getURLLookupAlternatives(url);
-
-    const result = await race(lookup.urls, async (alternative, { signal }) => {
             const api = apiClient({ apiToken: input.apiToken });
-        const callResult = await trace(
+            return trace(
                 {
                     operation: 'resolvePublishedContentByUrl',
-                name: alternative.url,
+                    name: url,
                 },
                 () =>
                     tryCatch(
                         api.urls.resolvePublishedContentByUrl(
                             {
-                            url: alternative.url,
+                                url,
                                 ...(input.visitorPayload ? { visitor: input.visitorPayload } : {}),
                                 redirectOnError: input.redirectOnError,
                             },
@@ -44,6 +40,63 @@ export async function lookupPublishedContentByUrl(
                         )
                     )
             );
+        },
+    });
+}
+
+/**
+ * Lookup a content by its URL using the GitBook getPublishedContentByUrl API endpoint.
+ * To optimize caching, we try multiple lookup alternatives and return the first one that matches.
+ *
+ * @deprecated use resolvePublishedContentByUrl.
+ *
+ */
+export async function getPublishedContentByURL(input: LookupPublishedContentByUrlInput) {
+    return lookupPublishedContentByUrl({
+        url: input.url,
+        fetchLookupAPIResult: ({ url, signal }) => {
+            const api = apiClient({ apiToken: input.apiToken });
+            return trace(
+                {
+                    operation: 'getPublishedContentByURL',
+                    name: url,
+                },
+                () =>
+                    tryCatch(
+                        api.urls.getPublishedContentByUrl(
+                            {
+                                url,
+                                visitorAuthToken: input.visitorPayload.jwtToken ?? undefined,
+                                redirectOnError: input.redirectOnError,
+                                // @ts-expect-error - cacheVersion is not a real query param
+                                cacheVersion: 'v2',
+                            },
+                            { signal }
+                        )
+                    )
+            );
+        },
+    });
+}
+
+type TryCatch<T> = ReturnType<typeof tryCatch<T>>;
+
+async function lookupPublishedContentByUrl(input: {
+    url: string;
+    fetchLookupAPIResult: (args: {
+        url: string;
+        signal: AbortSignal;
+    }) => TryCatch<Awaited<ReturnType<GitBookAPI['urls']['resolvePublishedContentByUrl']>>>;
+}): Promise<DataFetcherResponse<PublishedSiteContentLookup>> {
+    const lookupURL = new URL(input.url);
+    const url = stripURLSearch(lookupURL);
+    const lookup = getURLLookupAlternatives(url);
+
+    const result = await race(lookup.urls, async (alternative, { signal }) => {
+        const callResult = await input.fetchLookupAPIResult({
+            url: alternative.url,
+            signal,
+        });
 
         if (callResult.error) {
             if (alternative.primary) {

packages/gitbook-v2/src/lib/data/memoize.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it, mock } from 'bun:test';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { withCacheKey, withoutConcurrentExecution } from './memoize';
+
+describe('withoutConcurrentExecution', () => {
+    it('should memoize the function based on the cache key', async () => {
+        const fn = mock(async (_cacheKey: string, a: number, b: number) => a + b);
+        const memoized = withoutConcurrentExecution(() => null, fn);
+
+        const p1 = memoized('c1', 1, 2);
+        const p2 = memoized('c1', 1, 2);
+        const p3 = memoized('c3', 2, 3);
+
+        expect(await p1).toBe(await p2);
+        expect(await p1).not.toBe(await p3);
+        expect(fn.mock.calls.length).toBe(2);
+    });
+
+    it('should support caching per request', async () => {
+        const fn = mock(async () => Math.random());
+
+        const request1 = { id: 'request1' };
+        const request2 = { id: 'request2' };
+
+        const requestContext = new AsyncLocalStorage<{ id: string }>();
+
+        const memoized = withoutConcurrentExecution(() => requestContext.getStore(), fn);
+
+        // Both in the same request
+        const promise1 = requestContext.run(request1, () => memoized('c1'));
+        const promise2 = requestContext.run(request1, () => memoized('c1'));
+
+        // In a different request
+        const promise3 = requestContext.run(request2, () => memoized('c1'));
+
+        expect(await promise1).toBe(await promise2);
+        expect(await promise1).not.toBe(await promise3);
+        expect(fn.mock.calls.length).toBe(2);
+    });
+});
+
+describe('withCacheKey', () => {
+    it('should wrap the function by passing the cache key', async () => {
+        const fn = mock(
+            async (cacheKey: string, arg: { a: number; b: number }, c: number) =>
+                `${cacheKey}, result=${arg.a + arg.b + c}`
+        );
+        const memoized = withCacheKey(fn);
+        expect(await memoized({ a: 1, b: 2 }, 4)).toBe('[[["a",1],["b",2]],4], result=7');
+        expect(fn.mock.calls.length).toBe(1);
+    });
+});

packages/gitbook-v2/src/lib/data/memoize.ts

@@ -0,0 +1,87 @@
+/**
+ * Wrap a function by preventing concurrent executions of the same function.
+ * With a logic to work per-request in Cloudflare Workers.
+ */
+export function withoutConcurrentExecution<ArgsType extends any[], ReturnType>(
+    getGlobalContext: () => object | null | undefined,
+    wrapped: (key: string, ...args: ArgsType) => Promise<ReturnType>
+): (cacheKey: string, ...args: ArgsType) => Promise<ReturnType> {
+    const globalPromiseCache = new WeakMap<object, Map<string, Promise<ReturnType>>>();
+
+    return (key: string, ...args: ArgsType) => {
+        const globalContext = getGlobalContext() ?? globalThis;
+
+        /**
+         * Cache storage that is scoped to the current request when executed in Cloudflare Workers,
+         * to avoid "Cannot perform I/O on behalf of a different request" errors.
+         */
+        const promiseCache =
+            globalPromiseCache.get(globalContext) ?? new Map<string, Promise<ReturnType>>();
+        globalPromiseCache.set(globalContext, promiseCache);
+
+        const concurrent = promiseCache.get(key);
+        if (concurrent) {
+            return concurrent;
+        }
+
+        const promise = (async () => {
+            try {
+                const result = await wrapped(key, ...args);
+                return result;
+            } finally {
+                promiseCache.delete(key);
+            }
+        })();
+
+        promiseCache.set(key, promise);
+
+        return promise;
+    };
+}
+
+/**
+ * Wrap a function by passing it a cache key that is computed from the function arguments.
+ */
+export function withCacheKey<ArgsType extends any[], ReturnType>(
+    wrapped: (cacheKey: string, ...args: ArgsType) => Promise<ReturnType>
+): (...args: ArgsType) => Promise<ReturnType> {
+    return (...args: ArgsType) => {
+        const cacheKey = getCacheKey(args);
+        return wrapped(cacheKey, ...args);
+    };
+}
+
+/**
+ * Compute a cache key from the function arguments.
+ */
+function getCacheKey(args: any[]) {
+    return JSON.stringify(deepSortValue(args));
+}
+
+function deepSortValue(value: unknown): unknown {
+    if (
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean' ||
+        value === null ||
+        value === undefined
+    ) {
+        return value;
+    }
+
+    if (Array.isArray(value)) {
+        return value.map(deepSortValue);
+    }
+
+    if (value && typeof value === 'object') {
+        return Object.entries(value)
+            .map(([key, subValue]) => {
+                return [key, deepSortValue(subValue)] as const;
+            })
+            .sort((a, b) => {
+                return a[0].localeCompare(b[0]);
+            });
+    }
+
+    return value;
+}

packages/gitbook-v2/src/lib/data/pages.ts

@@ -0,0 +1,30 @@
+import type { JSONDocument, RevisionPageDocument, Space } from '@gitbook/api';
+import { getDataOrNull } from './errors';
+import type { GitBookDataFetcher } from './types';
+
+/**
+ * Get the document for a page.
+ */
+export async function getPageDocument(
+    dataFetcher: GitBookDataFetcher,
+    space: Space,
+    page: RevisionPageDocument
+): Promise<JSONDocument | null> {
+    if (page.documentId) {
+        return getDataOrNull(
+            dataFetcher.getDocument({ spaceId: space.id, documentId: page.documentId })
+        );
+    }
+    if ('computed' in page && page.computed) {
+        return getDataOrNull(
+            dataFetcher.getComputedDocument({
+                organizationId: space.organization,
+                spaceId: space.id,
+                source: page.computed,
+                seed: page.computedSeed,
+            })
+        );
+    }
+
+    return null;
+}

packages/gitbook-v2/src/lib/data/types.ts

@@ -3,10 +3,6 @@ import type * as api from '@gitbook/api';
 export type DataFetcherErrorData = {
     code: number;
     message: string;
-    cache?: {
-        maxAge?: number;
-        staleWhileRevalidate?: number;
-    };
 };
 
 export type DataFetcherResponse<T> =
@@ -71,8 +67,27 @@ export interface GitBookDataFetcher {
     getRevision(params: {
         spaceId: string;
         revisionId: string;
+        metadata: boolean;
     }): Promise<DataFetcherResponse<api.Revision>>;
 
+    /**
+     * Get the revision pages by its space ID and revision ID.
+     */
+    getRevisionPages(params: {
+        spaceId: string;
+        revisionId: string;
+        metadata: boolean;
+    }): Promise<DataFetcherResponse<api.RevisionPage[]>>;
+
+    /**
+     * Get a revision file by its space ID, revision ID and file ID.
+     */
+    getRevisionFile(params: {
+        spaceId: string;
+        revisionId: string;
+        fileId: string;
+    }): Promise<DataFetcherResponse<api.RevisionFile>>;
+
     /**
      * Get a revision page by its path.
      */
@@ -91,15 +106,6 @@ export interface GitBookDataFetcher {
         pageId: string;
     }): Promise<DataFetcherResponse<string>>;
 
-    /**
-     * Get the document of a page by its path.
-     */
-    getRevisionPageDocument(params: {
-        spaceId: string;
-        revisionId: string;
-        pageId: string;
-    }): Promise<DataFetcherResponse<api.JSONDocument>>;
-
     /**
      * Get a document by its space ID and document ID.
      */
@@ -117,6 +123,15 @@ export interface GitBookDataFetcher {
         seed: string;
     }): Promise<DataFetcherResponse<api.JSONDocument>>;
 
+    /**
+     * Get a reusable content by its space ID, revision ID and reusable content ID.
+     */
+    getReusableContent(params: {
+        spaceId: string;
+        revisionId: string;
+        reusableContentId: string;
+    }): Promise<DataFetcherResponse<api.RevisionReusableContent>>;
+
     /**
      * Get the latest OpenAPI spec version content by its organization ID and slug.
      */
@@ -164,4 +179,15 @@ export interface GitBookDataFetcher {
         integrationName: string;
         request: api.RenderIntegrationUI;
     }): Promise<DataFetcherResponse<api.ContentKitRenderOutput>>;
+
+    /**
+     * Stream an AI response.
+     */
+    streamAIResponse(params: {
+        organizationId: string;
+        siteId: string;
+        input: api.AIMessageInput[];
+        output: api.AIOutputFormat;
+        model: api.AIModel;
+    }): AsyncGenerator<api.AIStreamResponse, void, unknown>;
 }

packages/gitbook-v2/src/lib/data/urls.test.ts

@@ -362,35 +362,6 @@ describe('getURLLookupAlternatives', () => {
             ],
         });
     });
-
-    it('should skip proxy root URLs', () => {
-        expect(
-            getURLLookupAlternatives(
-                new URL('https://proxy.gitbook.site/sites/site_foo/hello/world')
-            )
-        ).toEqual({
-            revision: undefined,
-            changeRequest: undefined,
-            basePath: undefined,
-            urls: [
-                {
-                    url: 'https://proxy.gitbook.site/sites/site_foo',
-                    extraPath: 'hello/world',
-                    primary: false,
-                },
-                {
-                    url: 'https://proxy.gitbook.site/sites/site_foo/hello',
-                    extraPath: 'world',
-                    primary: false,
-                },
-                {
-                    url: 'https://proxy.gitbook.site/sites/site_foo/hello/world',
-                    extraPath: '',
-                    primary: true,
-                },
-            ],
-        });
-    });
 });
 
 describe('normalizeURL', () => {

packages/gitbook-v2/src/lib/data/urls.ts

@@ -1,5 +1,3 @@
-import { isProxyRootRequest } from '../proxy';
-
 /**
  * For a given GitBook URL, return a list of alternative URLs that could be matched against to lookup the content.
  * The approach is optimized to aim at reusing cached lookup results as much as possible.
@@ -41,11 +39,6 @@ export function getURLLookupAlternatives(input: URL) {
             return;
         }
 
-        // We don't want to push the url if it is the root proxy URL (either https://proxy.gitbook.site or https://proxy.gitbook.site/sites)
-        if (isProxyRootRequest(adding)) {
-            return;
-        }
-
         alternatives.push({
             url: adding.toString(),
             extraPath,

packages/gitbook-v2/src/lib/data/visitor.ts

@@ -1,6 +1,6 @@
 import { withLeadingSlash, withTrailingSlash } from '@/lib/paths';
-import { getProxyRequestIdentifier, isProxyRequest } from '@/lib/proxy';
 import type { PublishedSiteContent } from '@gitbook/api';
+import { getProxyRequestIdentifier, isProxyRequest } from '@v2/lib/proxy';
 
 /**
  * Get the appropriate base path for the visitor authentication cookie.