chore: remove benchmark-commands spec/plan docs now that work is complete

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Fix: apply final-review fix wave (safety guard, date spread, MariaDB explain, history fields, memory footprint, minors)
2026-07-30 23:55:59 +00:00 · 2026-07-30 13:43:01 -07:00 · 2026-07-30 13:33:28 -07:00 · 2026-07-30 11:20:14 -07:00 · 2026-07-30 11:07:33 -07:00 · 2026-07-30 10:53:02 -07:00
36 changed files with 1447 additions and 449 deletions
@@ -0,0 +1,187 @@
+---
+name: paperless-benchmarking
+description: Use when profiling paperless-ngx performance, running `manage.py benchmark`, investigating a slow query or endpoint, or deciding whether a profiling finding should become a permanent registered scenario. Covers command reference, the fork/merge-back branch workflow for perf investigations, and how to read query-plan output.
+---
+
+# Paperless-ngx Benchmarking
+
+This repo has a built-in benchmarking/profiling tool: `manage.py benchmark`, in
+the `paperless_benchmark` Django app. It replaces ad hoc standalone scripts —
+use it instead of writing new one-off seed/timing scripts.
+
+## Command reference
+
+```
+manage.py benchmark seed --tier {home,medium,large} [--reset --yes-i-know-this-wipes-the-database] [--seed N]
+manage.py benchmark run --repeat 5 [--label baseline]
+manage.py benchmark profile <scenario_name> [--repeat 5] [--explain]
+manage.py benchmark list-scenarios
+```
+
+- **`seed`** builds a realistic dataset at one of three scales: `home` (500
+  documents — fast, use this for iteration), `medium` (20,000 — the default
+  when `--tier` is omitted; a multi-minute seed), `large` (360,000 — matches
+  the scale reported in real large-install bug reports; slow, only use it
+  when a finding needs confirming at real scale). `--reset` wipes any
+  previously-seeded benchmark data first — but it is destructive and
+  irreversible: it deletes **all** users, **all** groups, and **all**
+  documents/tags/correspondents/document types/storage paths in the target
+  database, not just benchmark-created rows. Only run it against a disposable
+  benchmark database, never a real install. Because of that, `--reset` also
+  requires passing `--yes-i-know-this-wipes-the-database` in the same
+  invocation, or the command raises an error and does nothing. Omit both
+  flags if you want to layer more data onto an existing seed instead. `seed`
+  creates two named users, `perf_target` (mixed owned/shared documents,
+  realistic guardian permission grants) and `perf_admin` (superuser), plus a
+  general user/group pool with realistic permission-row ratios.
+- **`run`** times the 3 built-in API endpoint benchmarks
+  (`/api/documents/`, `/api/documents/?page_size=50`, `/api/tags/?page_size=100000`) for both
+  `perf_target` and `perf_admin`, reporting min/median/max wall-clock and SQL
+  query count. Requires `seed` to have already run — it reuses that data, it
+  does not seed its own.
+- **`profile`** times one named scenario from the registry (see
+  `list-scenarios`) via best-of-N repeat timing and SQL query count, against
+  `perf_target`. `--explain` additionally captures and prints the query plan:
+  real `EXPLAIN ANALYZE` execution stats on PostgreSQL/MariaDB, or
+  `EXPLAIN QUERY PLAN` (plan only, no real timing/row counts — clearly labeled
+  as such) on SQLite. Like `run`, `profile` requires `seed` to have already
+  run — it does not seed its own data either.
+- Every `run`/`profile` invocation appends a JSON line to
+  `benchmark_results/history.jsonl` at the repo root (local-only, gitignored —
+  never commit this file). Use it to compare a `before`/`after` pair across
+  two invocations without hand-copying numbers.
+- Full chain example: `seed --reset` once, then `run` and `profile` as many
+  times as you want against that same seeded data — no need to reseed between
+  them.
+
+## Adding a new scenario
+
+A "scenario" is a named, registered query/operation that `profile` can time
+and explain. To add one, edit `src/paperless_benchmark/scenarios.py`: write a
+`_<name>_run(user)` function (returns whatever `run_profile` should time) and
+optionally a `_<name>_queryset(user)` function (returns the `QuerySet` for
+`--explain` to analyze), then `register(Scenario(name=..., describe=...,
+run=..., queryset_for_explain=...))` at module level. Both functions receive
+the already-seeded `perf_target` user — they should not seed their own data.
+
+## Branch workflow
+
+`tools/benchmark-management-commands` is a **long-lived tooling branch**, not
+a feature branch that gets merged and closed:
+
+1. It is periodically brought up to date with `dev` (merge `dev` into it) so
+   the tooling doesn't drift from the schema/codebase it profiles. Do this
+   before starting a new investigation if it's been a while since the last
+   sync.
+2. **Every performance investigation forks its own branch from
+   `tools/benchmark-management-commands`** (not from `dev`). Do the
+   investigation there: write throwaway profiling code, try fixes, capture
+   before/after numbers.
+3. **That investigation branch never merges into `dev` or production.** Its
+   only job is to produce evidence and, optionally, a reusable scenario.
+4. If the investigation turns up a scenario worth keeping permanently (see
+   "When to graduate a scenario" below), open a PR that adds **just that
+   scenario** back into `tools/benchmark-management-commands` — not the rest
+   of the investigation branch's throwaway code.
+5. Any actual production fix the investigation motivates (e.g. an ORM query
+   change) goes into its own normal feature branch off `dev`, following the
+   project's regular contribution process — profiling evidence informs that
+   PR's description, but the profiling code itself does not travel with it.
+
+## Reading query-plan output
+
+- **PostgreSQL** `EXPLAIN ANALYZE`: look for `Seq Scan` on a large table
+  (missing index), a large gap between `rows=N` (planner's estimate) and the
+  actual row count in parentheses (stale statistics or a bad cardinality
+  estimate), and nested-loop joins driven by an outer relation with many
+  rows (usually the N+1 pattern this tool exists to catch).
+- **MariaDB**: verified against a real MariaDB 12.3 container that MariaDB
+  does NOT accept MySQL 8.0.18+'s `EXPLAIN ANALYZE` syntax (it's a 1064
+  syntax error) -- `capture_explain()` instead runs MariaDB's own
+  `ANALYZE <statement>` form (no `EXPLAIN` keyword), which returns a
+  tabular plan with real per-row execution columns: `rows` (estimate) vs.
+  `r_rows` (actual), and `filtered` vs. `r_filtered`. A large gap between
+  `rows` and `r_rows`, or `type: ALL` (full table scan) on a large table,
+  are the signals to look for -- the same underlying concerns as Postgres's
+  `Seq Scan`/estimate-vs-actual gap, just in MariaDB's column-based output
+  instead of Postgres's nested-tree text format.
+- **SQLite** `EXPLAIN QUERY PLAN`: no real timing/row-count data, only the
+  chosen access path (`SCAN` vs `SEARCH`, which index if any). Useful for
+  confirming an index is even being considered, not for judging real-world
+  cost — corroborate any SQLite finding against Postgres/MariaDB before
+  trusting it, since planner behavior differs meaningfully between them.
+- Compare query **count**, not just timing, between before/after: a fix that
+  keeps the same wall-clock time but drops query count from O(n) to O(1) is
+  still a real, durable improvement — timing alone is noisy and
+  environment-dependent, query count is not.
+
+## Cleaning up after an interrupted run
+
+If a `seed`/`run`/`profile` invocation gets killed mid-run (Ctrl-C, `kill -9`,
+a timed-out SSH session, etc.), check whether it left anything behind before
+trusting the next benchmark's numbers. This was verified for real: a
+`benchmark seed --tier large --reset ...` was started against both a fresh
+PostgreSQL 18 container and a fresh MariaDB 12.3 container and `kill -9`'d a
+few seconds into document seeding. In both cases, the database-side
+connection disappeared immediately -- no stuck backend, no lingering query,
+no held lock was observed in either backend once the killed process's PID
+was confirmed gone. That said, this was one interruption point (mid
+bulk-seed, between chunks); a run killed mid-query, or a driver/network
+hiccup that doesn't cleanly close the socket, could behave differently, so
+still check before trusting a number if any run in the session was
+interrupted:
+
+- **PostgreSQL**: look for leftover connections against the benchmark
+  database:
+
+  ```sql
+  SELECT pid, state, query, query_start
+  FROM pg_stat_activity
+  WHERE datname = current_database() AND pid <> pg_backend_pid();
+  ```
+
+  If a stuck backend shows up, clear it with:
+
+  ```sql
+  SELECT pg_terminate_backend(pid)
+  FROM pg_stat_activity
+  WHERE datname = current_database() AND pid <> pg_backend_pid();
+  ```
+
+- **MariaDB**: look for leftover connections/queries:
+
+  ```sql
+  SHOW FULL PROCESSLIST;
+  ```
+
+  If a stuck connection shows up (anything other than your current admin
+  session), clear it with:
+
+  ```sql
+  KILL <id>;
+  ```
+
+A stray connection left running concurrently with a subsequent benchmark run
+would add real, contaminating load (extra queries competing for the same
+rows, possibly held locks slowing the next run's timings) -- cheap to rule
+out, expensive to silently trust a number that was actually measured
+alongside a zombie connection.
+
+## When to graduate a one-off finding into a permanent scenario
+
+Register a scenario (rather than leaving it as throwaway code on the
+investigation branch) when **both** are true:
+
+- The query pattern is one this codebase is likely to regress on again (e.g.
+  it involves a permission-check join, a bulk operation, or anything else
+  with an easy-to-reintroduce N+1) — not a one-time fluke specific to this
+  investigation.
+- Re-running it later, against a fresh seed, would still produce a
+  meaningful signal (it doesn't depend on investigation-specific throwaway
+  data or a fix that's already permanently landed and can't regress the same
+  way).
+
+If a finding doesn't meet both bars, keep it as disposable code on the
+investigation branch and let the branch's evidence (captured in the PR
+description of whatever production fix it motivates) be the permanent
+record instead.
@@ -115,3 +115,6 @@ celerybeat-schedule*

 # Git worktree local folder
 .worktrees
+
+# Benchmark tooling output (local only, never committed)
+/benchmark_results/
@@ -1849,7 +1849,7 @@
        </context-group>
        <context-group purpose="location">
          <context context-type="sourcefile">src/app/components/common/custom-fields-query-dropdown/custom-fields-query-dropdown.component.html</context>
-          <context context-type="linenumber">159</context>
+          <context context-type="linenumber">154</context>
        </context-group>
        <context-group purpose="location">
          <context context-type="sourcefile">src/app/components/common/filterable-dropdown/filterable-dropdown.component.html</context>
@@ -3972,11 +3972,11 @@
        </context-group>
        <context-group purpose="location">
          <context context-type="sourcefile">src/app/components/common/custom-fields-query-dropdown/custom-fields-query-dropdown.component.html</context>
-          <context context-type="linenumber">101</context>
+          <context context-type="linenumber">96</context>
        </context-group>
        <context-group purpose="location">
          <context context-type="sourcefile">src/app/components/common/custom-fields-query-dropdown/custom-fields-query-dropdown.component.html</context>
-          <context context-type="linenumber">107</context>
+          <context context-type="linenumber">102</context>
        </context-group>
      </trans-unit>
      <trans-unit id="3800326155195149498" datatype="html">
@@ -3987,11 +3987,11 @@
        </context-group>
        <context-group purpose="location">
          <context context-type="sourcefile">src/app/components/common/custom-fields-query-dropdown/custom-fields-query-dropdown.component.html</context>
-          <context context-type="linenumber">102</context>
+          <context context-type="linenumber">97</context>
        </context-group>
        <context-group purpose="location">
          <context context-type="sourcefile">src/app/components/common/custom-fields-query-dropdown/custom-fields-query-dropdown.component.html</context>
-          <context context-type="linenumber">108</context>
+          <context context-type="linenumber">103</context>
        </context-group>
      </trans-unit>
      <trans-unit id="7551700625201096185" datatype="html">
@@ -4002,14 +4002,14 @@
        </context-group>
        <context-group purpose="location">
          <context context-type="sourcefile">src/app/components/common/custom-fields-query-dropdown/custom-fields-query-dropdown.component.html</context>
-          <context context-type="linenumber">124</context>
+          <context context-type="linenumber">119</context>
        </context-group>
      </trans-unit>
      <trans-unit id="3184700926171002527" datatype="html">
        <source>Any</source>
        <context-group purpose="location">
          <context context-type="sourcefile">src/app/components/common/custom-fields-query-dropdown/custom-fields-query-dropdown.component.html</context>
-          <context context-type="linenumber">157</context>
+          <context context-type="linenumber">152</context>
        </context-group>
        <context-group purpose="location">
          <context context-type="sourcefile">src/app/components/common/filterable-dropdown/filterable-dropdown.component.html</context>
@@ -4020,21 +4020,21 @@
        <source>Not</source>
        <context-group purpose="location">
          <context context-type="sourcefile">src/app/components/common/custom-fields-query-dropdown/custom-fields-query-dropdown.component.html</context>
-          <context context-type="linenumber">162</context>
+          <context context-type="linenumber">157</context>
        </context-group>
      </trans-unit>
      <trans-unit id="6548676277933116532" datatype="html">
        <source>Add query</source>
        <context-group purpose="location">
          <context context-type="sourcefile">src/app/components/common/custom-fields-query-dropdown/custom-fields-query-dropdown.component.html</context>
-          <context context-type="linenumber">181</context>
+          <context context-type="linenumber">176</context>
        </context-group>
      </trans-unit>
      <trans-unit id="5599577087865387184" datatype="html">
        <source>Add expression</source>
        <context-group purpose="location">
          <context context-type="sourcefile">src/app/components/common/custom-fields-query-dropdown/custom-fields-query-dropdown.component.html</context>
-          <context context-type="linenumber">184</context>
+          <context context-type="linenumber">179</context>
        </context-group>
      </trans-unit>
      <trans-unit id="6312759212949884929" datatype="html">
@@ -182,7 +182,7 @@
                    container="body" triggers="mouseenter:mouseleave" popoverClass="popover-slim">
                    <i-bs class="me-2" name="stack"></i-bs><span><ng-container i18n>Attributes</ng-container></span>
                  </a>
-                  @if (!slimSidebarEnabled && canSaveSettings) {
+                  @if (!slimSidebarEnabled) {
                    <button
                      type="button"
                      class="btn btn-link btn-sm text-muted p-0 me-3 attributes-expand-btn"
@@ -68,11 +68,6 @@
    ></ng-select>
  } @else if (getCustomFieldByID(atom.field)?.data_type === CustomFieldDataType.DocumentLink) {
    <pngx-input-document-link [(ngModel)]="atom.value" class="w-25 form-select doc-link-select p-0" placeholder="Search docs..." i18n-placeholder [minimal]="true"></pngx-input-document-link>
-  } @else if (getCustomFieldByID(atom.field)?.data_type === CustomFieldDataType.Monetary) {
-    <input class="w-25 form-control rounded-end" type="text" inputmode="decimal"
-      [ngModel]="atom.value"
-      (ngModelChange)="setMonetaryValue(atom, $event)"
-      [disabled]="disabled">
  } @else {
    <input class="w-25 form-control rounded-end" type="text" [(ngModel)]="atom.value" [disabled]="disabled">
  }
@@ -1,6 +1,5 @@
 import { provideHttpClient, withInterceptorsFromDi } from '@angular/common/http'
 import { provideHttpClientTesting } from '@angular/common/http/testing'
-import { LOCALE_ID } from '@angular/core'
 import { ComponentFixture, TestBed } from '@angular/core/testing'
 import { FormsModule, ReactiveFormsModule } from '@angular/forms'
 import { NgbDropdownModule } from '@ng-bootstrap/ng-bootstrap'
@@ -42,12 +41,6 @@ const customFields = [
      ],
    },
  },
-  {
-    id: 3,
-    name: 'Test Monetary Field',
-    data_type: CustomFieldDataType.Monetary,
-    extra_data: { default_currency: 'EUR' },
-  },
 ]

 describe('CustomFieldsQueryDropdownComponent', () => {
@@ -68,7 +61,6 @@ describe('CustomFieldsQueryDropdownComponent', () => {
      providers: [
        provideHttpClient(withInterceptorsFromDi()),
        provideHttpClientTesting(),
-        { provide: LOCALE_ID, useValue: 'de' },
      ],
    }).compileComponents()

@@ -158,22 +150,6 @@ describe('CustomFieldsQueryDropdownComponent', () => {
    expect(options2).toEqual([])
  })

-  it('should normalize localized monetary comparison values', () => {
-    const atom = new CustomFieldQueryAtom([3, 'exact', null])
-
-    component.setMonetaryValue(atom, '1.234,56')
-
-    expect(atom.value).toEqual('1234.56')
-  })
-
-  it('should preserve API-formatted monetary comparison values', () => {
-    const atom = new CustomFieldQueryAtom([3, 'exact', null])
-
-    component.setMonetaryValue(atom, '1234.56')
-
-    expect(atom.value).toEqual('1234.56')
-  })
-
  it('should remove an element from the selection model', () => {
    const expression = new CustomFieldQueryExpression()
    const atom = new CustomFieldQueryAtom()
@@ -1,14 +1,9 @@
-import {
-  getLocaleNumberSymbol,
-  NgTemplateOutlet,
-  NumberSymbol,
-} from '@angular/common'
+import { NgTemplateOutlet } from '@angular/common'
 import {
  Component,
  EventEmitter,
  inject,
  Input,
-  LOCALE_ID,
  Output,
  QueryList,
  signal,
@@ -217,7 +212,6 @@ export class CustomFieldQueriesModel {
 })
 export class CustomFieldsQueryDropdownComponent extends LoadingComponentWithPermissions {
  protected customFieldsService = inject(CustomFieldsService)
-  private readonly locale = inject(LOCALE_ID)

  public CustomFieldQueryComponentType = CustomFieldQueryElementType
  public CustomFieldQueryOperator = CustomFieldQueryOperator
@@ -382,18 +376,4 @@ export class CustomFieldsQueryDropdownComponent extends LoadingComponentWithPerm
    }
    return []
  }
-
-  setMonetaryValue(atom: CustomFieldQueryAtom, value: string) {
-    // Normalize the decimal symbol e.g. . vs , by locale
-    const decimalSymbol = getLocaleNumberSymbol(
-      this.locale,
-      NumberSymbol.Decimal
-    )
-    if (decimalSymbol !== '.' && value.includes(decimalSymbol)) {
-      const groupSymbol = getLocaleNumberSymbol(this.locale, NumberSymbol.Group)
-      value = value.split(groupSymbol).join('').split(decimalSymbol).join('.')
-    }
-
-    atom.value = value
-  }
 }
@@ -51,8 +51,8 @@
      *pngxIfPermissions="{ action: PermissionAction.Add, type: activeManagementList.permissionType }">
      <i-bs name="plus-circle" class="me-1"></i-bs><ng-container i18n>Create</ng-container>
    </button>
-  } @else if (customFieldsActive) {
-    <button type="button" class="btn btn-sm btn-outline-primary" (click)="addCustomField()"
+  } @else if (activeCustomFields) {
+    <button type="button" class="btn btn-sm btn-outline-primary" (click)="activeCustomFields.editField()"
      *pngxIfPermissions="{ action: PermissionAction.Add, type: PermissionType.CustomField }">
      <i-bs name="plus-circle" class="me-1"></i-bs><ng-container i18n>Add Field</ng-container>
    </button>
@@ -18,7 +18,6 @@ import {
  DocumentAttributesComponent,
  DocumentAttributesSectionKind,
 } from './document-attributes.component'
-import { CustomFieldsComponent } from './custom-fields/custom-fields.component'
 import { ManagementListComponent } from './management-list/management-list.component'

@Component({
@@ -208,29 +207,6 @@ describe('DocumentAttributesComponent', () => {
    expect(component.activeSection.kind).toBe(
      DocumentAttributesSectionKind.CustomFields
    )
-    const customFields = Object.create(CustomFieldsComponent.prototype)
-    customFields.editField = jest.fn()
-    component.activeOutlet = {
-      componentInstance: customFields,
-    } as any
-    expect(component.activeCustomFields).toBe(customFields)
-
-    component.addCustomField()
-    expect(customFields.editField).toHaveBeenCalled()
-  })
-
-  it('should show the add field button before the custom fields instance is available', async () => {
-    jest.spyOn(permissionsService, 'currentUserCan').mockReturnValue(true)
-
-    fixture.detectChanges()
-    component.activeNavID.set(2)
-    await fixture.whenStable()
-
-    expect(component.activeCustomFields).toBeNull()
-    expect(
-      fixture.nativeElement.querySelector(
-        'pngx-page-header .btn-outline-primary'
-      )?.textContent
-    ).toContain('Add Field')
+    expect(component.activeCustomFields).toBeDefined()
  })
 })
@@ -163,17 +163,12 @@ export class DocumentAttributesComponent implements OnInit, OnDestroy {
  }

  get activeCustomFields(): CustomFieldsComponent | null {
-    if (!this.customFieldsActive) return null
+    if (this.activeSection?.kind !== DocumentAttributesSectionKind.CustomFields)
+      return null
    const instance = this.activeOutlet?.componentInstance
    return instance instanceof CustomFieldsComponent ? instance : null
  }

-  get customFieldsActive(): boolean {
-    return (
-      this.activeSection?.kind === DocumentAttributesSectionKind.CustomFields
-    )
-  }
-
  get activeTabLabel(): string {
    return this.activeSection?.label ?? ''
  }
@@ -229,10 +224,6 @@ export class DocumentAttributesComponent implements OnInit, OnDestroy {
    this.router.navigate(['attributes', nextSection])
  }

-  addCustomField(): void {
-    this.activeCustomFields?.editField(null)
-  }
-
  private getDefaultNavID(): DocumentAttributesNavIDs | null {
    return this.visibleSections[0]?.id ?? null
  }
@@ -57,7 +57,9 @@ from paperless.models import ArchiveFileGenerationChoices
 from paperless.parsers import ParserContext
 from paperless.parsers import ParserProtocol
 from paperless.parsers.registry import get_parser_registry
-from paperless.parsers.utils import pdf_born_digital_text
+from paperless.parsers.utils import PDF_TEXT_MIN_LENGTH
+from paperless.parsers.utils import extract_pdf_text
+from paperless.parsers.utils import is_tagged_pdf

 LOGGING_NAME: Final[str] = "paperless.consumer"

@@ -136,45 +138,53 @@ def should_produce_archive(

    # Must produce a PDF so the frontend can display the original format at all.
    if parser.requires_pdf_rendition:
-        _log.debug("Archive: yes - parser requires PDF rendition for frontend display")
+        _log.debug("Archive: yes — parser requires PDF rendition for frontend display")
        return True

    # Parser cannot produce an archive (e.g. TextDocumentParser).
    if not parser.can_produce_archive:
-        _log.debug("Archive: no - parser cannot produce archives")
+        _log.debug("Archive: no — parser cannot produce archives")
        return False

    generation = OcrConfig().archive_file_generation

    if generation == ArchiveFileGenerationChoices.ALWAYS:
-        _log.debug("Archive: yes - ARCHIVE_FILE_GENERATION=always")
+        _log.debug("Archive: yes — ARCHIVE_FILE_GENERATION=always")
        return True
    if generation == ArchiveFileGenerationChoices.NEVER:
-        _log.debug("Archive: no - ARCHIVE_FILE_GENERATION=never")
+        _log.debug("Archive: no — ARCHIVE_FILE_GENERATION=never")
        return False

    # auto: produce archives for scanned/image documents; skip for born-digital PDFs.
    if mime_type.startswith("image/"):
-        _log.debug("Archive: yes - image document, ARCHIVE_FILE_GENERATION=auto")
+        _log.debug("Archive: yes — image document, ARCHIVE_FILE_GENERATION=auto")
        return True
    if mime_type == "application/pdf":
-        text, born_digital = pdf_born_digital_text(document_path, log=_log)
-        text_length = len(text) if text else 0
-        if born_digital:
+        text = extract_pdf_text(document_path)
+        has_text = text is not None and len(text) > 0
+        if has_text and is_tagged_pdf(document_path):
            _log.debug(
-                "Archive: no - born-digital PDF (text_length=%d),"
+                "Archive: no — born-digital PDF (structure tags detected),"
                " ARCHIVE_FILE_GENERATION=auto",
-                text_length,
            )
            return False
+        if text is None or len(text) <= PDF_TEXT_MIN_LENGTH:
+            _log.debug(
+                "Archive: yes — scanned PDF (text_length=%d ≤ %d),"
+                " ARCHIVE_FILE_GENERATION=auto",
+                len(text) if text else 0,
+                PDF_TEXT_MIN_LENGTH,
+            )
+            return True
        _log.debug(
-            "Archive: yes - scanned/textless PDF (text_length=%d),"
+            "Archive: no — born-digital PDF (text_length=%d > %d),"
            " ARCHIVE_FILE_GENERATION=auto",
-            text_length,
+            len(text),
+            PDF_TEXT_MIN_LENGTH,
        )
-        return True
+        return False
    _log.debug(
-        "Archive: no - MIME type %r not eligible for auto archive generation",
+        "Archive: no — MIME type %r not eligible for auto archive generation",
        mime_type,
    )
    return False
@@ -61,7 +61,7 @@ class Command(PaperlessCommand):
        )
        table.add_column("Level", width=7, no_wrap=True)
        table.add_column("Document", min_width=20)
-        table.add_column("Issue", ratio=1, overflow="fold")
+        table.add_column("Issue", ratio=1)

        for doc_pk, doc_messages in messages.iter_messages():
            if doc_pk is not None:
@@ -39,7 +39,6 @@ from documents.search._tokenizer import ascii_fold
 from documents.search._tokenizer import autocomplete_tokens
 from documents.search._tokenizer import register_tokenizers
 from documents.utils import IterWrapper
-from documents.utils import QuerySetStream
 from documents.utils import identity

 if TYPE_CHECKING:
@@ -1036,15 +1035,14 @@ _EMPTY_VIEWER_GRANT: Final[ViewerGrant] = ViewerGrant(
 )


-class _DocumentViewerStream(QuerySetStream["Document"]):
+class _DocumentViewerStream:
    """Yield document permission data while batch-loading grants.

    Viewer permissions are fetched in batches (see
    ``_bulk_get_viewer_permissions``), but documents are yielded individually so a
    progress bar wrapped around this stream advances per document rather than
-    jumping a whole chunk at a time. ``__len__`` (inherited from
-    ``QuerySetStream``) lets the progress helper still discover the total (it
-    inspects ``QuerySet``/``Sized``).
+    jumping a whole chunk at a time. ``__len__`` lets the progress helper still
+    discover the total (it inspects ``QuerySet``/``Sized``).

    The viewer and group ids travel with each document in the yielded pair
    rather than through a separate mutable attribute, so the pairing survives
@@ -1053,11 +1051,18 @@ class _DocumentViewerStream(QuerySetStream["Document"]):
    generator in lock-step.
    """

+    def __init__(self, documents: QuerySet[Document], *, chunk_size: int) -> None:
+        self._documents = documents
+        self._chunk_size = chunk_size
+
+    def __len__(self) -> int:
+        return self._documents.count()
+
    def __iter__(self) -> Iterator[tuple[Document, ViewerGrant]]:
        # iterator(chunk_size=…) streams from a server-side cursor instead of
        # materialising the whole queryset in memory; since Django 4.1 it still
        # honours prefetch_related, running the prefetches one batch at a time.
-        documents = self._queryset.iterator(chunk_size=self._chunk_size)
+        documents = self._documents.iterator(chunk_size=self._chunk_size)
        for chunk in chunked(documents, self._chunk_size):
            grants_by_pk = _bulk_get_viewer_permissions([doc.pk for doc in chunk])
            for doc in chunk:
@@ -1329,7 +1329,7 @@ class PreConsumeTestCase(DirectoriesMixin, GetConsumerMixin, TestCase):
        with self.get_consumer(self.test_file) as c:
            c.run()
            # Verify no pre-consume script subprocess was invoked
-            # (run_subprocess may still be called by pdf_born_digital_text via pdftotext)
+            # (run_subprocess may still be called by _extract_text_for_archive_check)
            script_calls = [
                call
                for call in m.call_args_list
@@ -1354,7 +1354,7 @@ class PreConsumeTestCase(DirectoriesMixin, GetConsumerMixin, TestCase):
                    self.assertTrue(m.called)

                    # Find the call that invoked the pre-consume script
-                    # (run_subprocess may also be called by pdf_born_digital_text via pdftotext)
+                    # (run_subprocess may also be called by _extract_text_for_archive_check)
                    script_call = next(
                        call
                        for call in m.call_args_list
@@ -134,32 +134,60 @@ class TestShouldProduceArchive:
        assert should_produce_archive(parser, mime, Path("/tmp/doc")) is expected

    @pytest.mark.parametrize(
-        ("born_digital", "expected"),
+        ("extracted_text", "expected"),
        [
-            pytest.param(True, False, id="born-digital-skips-archive"),
-            pytest.param(False, True, id="not-born-digital-produces-archive"),
+            pytest.param(
+                "This is a born-digital PDF with lots of text content. " * 10,
+                False,
+                id="born-digital-long-text-skips-archive",
+            ),
+            pytest.param(None, True, id="no-text-scanned-produces-archive"),
+            pytest.param("tiny", True, id="short-text-treated-as-scanned"),
        ],
    )
    def test_auto_pdf_archive_decision(
        self,
        mocker: MockerFixture,
        settings,
-        born_digital: bool,  # noqa: FBT001
+        extracted_text: str | None,
        expected: bool,  # noqa: FBT001
    ) -> None:
-        """Archive decision tracks pdf_born_digital_text()'s verdict exactly.
-
-        should_produce_archive() defers entirely to pdf_born_digital_text()
-        for the has-real-text decision, so both callers of that predicate
-        (this function and RasterisedDocumentParser.parse()) always agree.
-        """
        settings.ARCHIVE_FILE_GENERATION = "auto"
-        mocker.patch(
-            "documents.consumer.pdf_born_digital_text",
-            return_value=("some text", born_digital),
-        )
+        mocker.patch("documents.consumer.is_tagged_pdf", return_value=False)
+        mocker.patch("documents.consumer.extract_pdf_text", return_value=extracted_text)
        parser = _parser_instance(can_produce=True, requires_rendition=False)
        assert (
            should_produce_archive(parser, "application/pdf", Path("/tmp/doc.pdf"))
            is expected
        )
+
+    def test_tagged_pdf_skips_archive_in_auto_mode(
+        self,
+        mocker: MockerFixture,
+        settings,
+    ) -> None:
+        """Tagged PDFs (e.g. Word exports) with real text are treated as born-digital, even below PDF_TEXT_MIN_LENGTH."""
+        settings.ARCHIVE_FILE_GENERATION = "auto"
+        mocker.patch("documents.consumer.is_tagged_pdf", return_value=True)
+        mocker.patch("documents.consumer.extract_pdf_text", return_value="tiny")
+        parser = _parser_instance(can_produce=True, requires_rendition=False)
+        assert (
+            should_produce_archive(parser, "application/pdf", Path("/tmp/doc.pdf"))
+            is False
+        )
+
+    def test_tagged_pdf_without_text_produces_archive(
+        self,
+        mocker: MockerFixture,
+        settings,
+    ) -> None:
+        """A tagged PDF with no actual extractable text (e.g. some scanner firmware) is not
+        trusted as born-digital — the tag alone must not bypass OCR."""
+        settings.ARCHIVE_FILE_GENERATION = "auto"
+        mocker.patch("documents.consumer.is_tagged_pdf", return_value=True)
+        mocker.patch("documents.consumer.extract_pdf_text", return_value=None)
+        parser = _parser_instance(can_produce=True, requires_rendition=False)
+        assert (
+            should_produce_archive(parser, "application/pdf", Path("/tmp/doc.pdf"))
+            is True
+        )
@@ -1,35 +0,0 @@
-import pytest_mock
-
-from documents.utils import QuerySetStream
-
-
-class TestQuerySetStream:
-    def test_len_and_iter_delegate_to_streaming_queryset_methods(
-        self,
-        mocker: pytest_mock.MockerFixture,
-    ) -> None:
-        """
-        GIVEN:
-            - A mock queryset
-        WHEN:
-            - A QuerySetStream wrapping it is measured and iterated
-        THEN:
-            - len() uses count() (not a materializing len()), and iteration
-              uses .iterator(chunk_size=...) (not plain iteration, which
-              would materialize the whole queryset, plus any prefetch
-              caches, into Django's own result cache at once)
-        """
-        mock_queryset = mocker.MagicMock()
-        mock_queryset.count.return_value = 42
-        mock_queryset.iterator.return_value = iter(["row-1", "row-2"])
-        streamed = QuerySetStream(mock_queryset, chunk_size=1000)
-
-        assert len(streamed) == 42
-        assert list(streamed) == ["row-1", "row-2"]
-        # count.call_count isn't asserted exactly: list()'s own size-hint
-        # optimization calls len(streamed) again internally, on top of the
-        # explicit len() call above -- both legitimately delegate to
-        # count(), so only the delegation itself (not the call count) is
-        # the thing being verified here.
-        mock_queryset.count.assert_called_with()
-        mock_queryset.iterator.assert_called_once_with(chunk_size=1000)
@@ -3,24 +3,16 @@ import logging
 import shutil
 from collections.abc import Callable
 from collections.abc import Iterable
-from collections.abc import Iterator
 from os import utime
 from pathlib import Path
 from subprocess import CompletedProcess
 from subprocess import run
-from typing import TYPE_CHECKING
-from typing import Generic
 from typing import TypeVar

 from django.conf import settings
 from PIL import Image

-if TYPE_CHECKING:
-    from django.db.models import Model
-    from django.db.models import QuerySet
-
 _T = TypeVar("_T")
-_M = TypeVar("_M", bound="Model")

 # A function that wraps an iterable — typically used to inject a progress bar.
 IterWrapper = Callable[[Iterable[_T]], Iterable[_T]]
@@ -31,40 +23,6 @@ def identity(iterable: Iterable[_T]) -> Iterable[_T]:
    return iterable


-class QuerySetStream(Generic[_M]):
-    """Stream a QuerySet via .iterator(chunk_size=...) instead of
-    materializing it (plus any prefetch caches) all at once, while still
-    supporting len() via count() so a progress bar wrapped around this
-    (e.g. via IterWrapper) shows a real total instead of falling back to
-    indeterminate.
-
-    Plain QuerySet iteration (``for row in queryset:``) is not lazy: Django
-    fetches every matching row in one query and caches the fully-hydrated
-    result in the queryset's own ``_result_cache`` before yielding the
-    first item -- wrapping that in a progress bar or any other iterable
-    adapter doesn't change this, since none of them alter how the
-    underlying queryset produces items. ``.iterator(chunk_size=...)`` is
-    the specific Django API that bypasses ``_result_cache`` and streams
-    from a server-side cursor instead, discarding each chunk once consumed
-    (and, since Django 4.1, still honours ``prefetch_related``, running the
-    prefetches one batch at a time rather than for the whole queryset).
-
-    Subclass to layer additional per-batch work on top (see
-    ``documents.search._backend._DocumentViewerStream``) by overriding
-    ``__iter__`` -- ``__len__`` and the constructor are inherited for free.
-    """
-
-    def __init__(self, queryset: "QuerySet[_M]", *, chunk_size: int) -> None:
-        self._queryset = queryset
-        self._chunk_size = chunk_size
-
-    def __len__(self) -> int:
-        return self._queryset.count()
-
-    def __iter__(self) -> Iterator[_M]:
-        return iter(self._queryset.iterator(chunk_size=self._chunk_size))
-
-
 def _coerce_to_path(
    source: Path | str,
    dest: Path | str,
@@ -3,6 +3,7 @@ from __future__ import annotations
 import importlib.resources
 import logging
 import os
+import re
 import shutil
 import tempfile
 from pathlib import Path
@@ -24,9 +25,9 @@ from paperless.config import OcrConfig
 from paperless.models import CleanChoices
 from paperless.models import ModeChoices
 from paperless.models import OutputTypeChoices
+from paperless.parsers.utils import PDF_TEXT_MIN_LENGTH
 from paperless.parsers.utils import extract_pdf_text
-from paperless.parsers.utils import is_born_digital_text
-from paperless.parsers.utils import post_process_text
+from paperless.parsers.utils import is_tagged_pdf
 from paperless.parsers.utils import read_file_handle_unicode_errors
 from paperless.version import __full_version_str__

@@ -509,10 +510,10 @@ class RasterisedDocumentParser:

        if mime_type == "application/pdf":
            text_original = self.extract_text(None, document_path)
-            original_has_text = is_born_digital_text(
-                text_original,
-                document_path,
-                log=self.log,
+            has_text = text_original is not None and len(text_original) > 0
+            original_has_text = has_text and (
+                is_tagged_pdf(document_path, log=self.log)
+                or len(text_original) > PDF_TEXT_MIN_LENGTH
            )
        else:
            text_original = None
@@ -657,3 +658,17 @@ class RasterisedDocumentParser:
                    f"No text was found in {document_path}, the content will be empty.",
                )
                self.text = ""
+
+
+def post_process_text(text: str | None) -> str | None:
+    if not text:
+        return None
+
+    collapsed_spaces = re.sub(r"([^\S\r\n]+)", " ", text)
+    no_leading_whitespace = re.sub(r"([\n\r]+)([^\S\n\r]+)", "\\1", collapsed_spaces)
+    no_trailing_whitespace = re.sub(r"([^\S\n\r]+)$", "", no_leading_whitespace)
+
+    # TODO: this needs a rework
+    # replace \0 prevents issues with saving to postgres.
+    # text may contain \0 when this character is present in PDF files.
+    return no_trailing_whitespace.strip().replace("\0", " ")
@@ -111,88 +111,6 @@ def extract_pdf_text(
        return None


-def post_process_text(text: str | None) -> str | None:
-    """Normalize extracted PDF/OCR text: collapse whitespace, strip padding.
-
-    Returns ``None`` for ``None`` or whitespace-only input, so callers can
-    treat "no text" and "only layout padding" the same way.
-    """
-    if not text:
-        return None
-
-    collapsed_spaces = re.sub(r"([^\S\r\n]+)", " ", text)
-    no_leading_whitespace = re.sub(r"([\n\r]+)([^\S\n\r]+)", "\\1", collapsed_spaces)
-    no_trailing_whitespace = re.sub(r"([^\S\n\r]+)$", "", no_leading_whitespace)
-
-    # replace \0 prevents issues with saving to postgres.
-    # text may contain \0 when this character is present in PDF files.
-    result = no_trailing_whitespace.strip().replace("\0", " ")
-    return result or None
-
-
-def is_born_digital_text(
-    text: str | None,
-    path: Path,
-    log: logging.Logger | None = None,
-) -> bool:
-    """Decide whether already-extracted, normalized PDF text counts as born-digital.
-
-    This is the single source of truth for "does this PDF already have real
-    text", used both to decide whether to produce an archive file and to
-    decide whether OCR can be skipped. Both decisions must agree, or a
-    tagged-but-textless PDF can end up with no archive AND a forced OCR pass
-    (see GH #13387): raw ``pdftotext -layout`` output can be non-empty
-    (whitespace/form-feed padding) even when there is no real content, so
-    *text* must already be normalized via :func:`post_process_text`, not the
-    raw extraction.
-
-    Parameters
-    ----------
-    text:
-        The normalized extracted text (or ``None``) to evaluate.
-    path:
-        Absolute path to the PDF file, used for the tagged-PDF check.
-    log:
-        Logger for warnings.  Falls back to the module-level logger when omitted.
-
-    Returns
-    -------
-    bool
-        Whether the PDF counts as born-digital (has real text, and is either
-        tagged or exceeds ``PDF_TEXT_MIN_LENGTH``).
-    """
-    if not text:
-        return False
-    return is_tagged_pdf(path, log=log) or len(text) > PDF_TEXT_MIN_LENGTH
-
-
-def pdf_born_digital_text(
-    path: Path,
-    log: logging.Logger | None = None,
-) -> tuple[str | None, bool]:
-    """Extract a PDF's text and decide whether it should be treated as born-digital.
-
-    Convenience wrapper around :func:`is_born_digital_text` for callers that
-    don't already have the PDF's text extracted (e.g. the archive-generation
-    decision, which runs before any parser has touched the file).
-
-    Parameters
-    ----------
-    path:
-        Absolute path to the PDF file.
-    log:
-        Logger for warnings.  Falls back to the module-level logger when omitted.
-
-    Returns
-    -------
-    tuple[str | None, bool]
-        The normalized extracted text (or ``None``), and whether the PDF
-        counts as born-digital.
-    """
-    text = post_process_text(extract_pdf_text(path, log=log))
-    return text, is_born_digital_text(text, path, log=log)
-
-
 def read_file_handle_unicode_errors(
    filepath: Path,
    log: logging.Logger | None = None,
@@ -150,6 +150,7 @@ INSTALLED_APPS = [
    "drf_spectacular",
    "drf_spectacular_sidecar",
    "treenode",
+    "paperless_benchmark.apps.PaperlessBenchmarkConfig",
    *env_apps,
 ]

@@ -36,23 +36,6 @@ def samples_dir() -> Path:
    return (Path(__file__).parent / "samples").resolve()


-@pytest.fixture(scope="session")
-def tagged_no_text_pdf_file(samples_dir: Path) -> Path:
-    """Path to a tagged PDF whose only "text" is pdftotext layout padding.
-
-    Reproduces GH #13387: ``/MarkInfo /Marked true`` is set, but the only
-    extractable content is a form-feed byte, not real text. Lives here
-    rather than in parsers/conftest.py so both parser tests and
-    paperless/tests/test_parser_utils.py can use it.
-
-    Returns
-    -------
-    Path
-        Absolute path to ``tesseract/tagged-but-no-text.pdf``.
-    """
-    return samples_dir / "tesseract" / "tagged-but-no-text.pdf"
-
-
@pytest.fixture(autouse=True)
 def clean_registry() -> Generator[None, None, None]:
    """Reset the parser registry before and after every test.
@@ -21,7 +21,7 @@ from documents.parsers import run_convert
 from paperless.models import ModeChoices
 from paperless.parsers import ParserProtocol
 from paperless.parsers.tesseract import RasterisedDocumentParser
-from paperless.parsers.utils import is_tagged_pdf
+from paperless.parsers.tesseract import post_process_text

 if TYPE_CHECKING:
    from pathlib import Path
@@ -151,6 +151,36 @@ class TestRasterisedDocumentParserLifecycle:
        assert tempdir is not None and not tempdir.exists()


+# ---------------------------------------------------------------------------
+# post_process_text
+# ---------------------------------------------------------------------------
+
+
+class TestPostProcessText:
+    @pytest.mark.parametrize(
+        ("source", "expected"),
+        [
+            pytest.param(
+                "simple     string",
+                "simple string",
+                id="collapse-spaces",
+            ),
+            pytest.param(
+                "simple    newline\n   testing string",
+                "simple newline\ntesting string",
+                id="preserve-newline",
+            ),
+            pytest.param(
+                "utf-8   строка с пробелами в конце  ",  # noqa: RUF001
+                "utf-8 строка с пробелами в конце",  # noqa: RUF001
+                id="utf8-trailing-spaces",
+            ),
+        ],
+    )
+    def test_post_process_text(self, source: str, expected: str) -> None:
+        assert post_process_text(source) == expected
+
+
 # ---------------------------------------------------------------------------
 # Page count
 # ---------------------------------------------------------------------------
@@ -880,25 +910,25 @@ class TestSkipArchive:
        self,
        mocker: MockerFixture,
        tesseract_parser: RasterisedDocumentParser,
-        tagged_no_text_pdf_file: Path,
+        tesseract_samples_dir: Path,
    ) -> None:
        """
        GIVEN:
-            - A real PDF that reports itself as tagged (/MarkInfo /Marked
-              true) but whose only pdftotext output is layout padding (a
-              lone form-feed byte), not real text (see GitHub issue #13387,
-              originally reported against #13349's tagged-PDF handling)
+            - A PDF that reports itself as tagged (/MarkInfo /Marked true) but
+              has no actual extractable text (some scanner firmware produces
+              this — see GitHub issue #13349)
            - Mode: auto, produce_archive=False
        WHEN:
            - Document is parsed
        THEN:
            - The tag alone is not trusted as "has text"; OCRmyPDF still runs
        """
-        assert is_tagged_pdf(tagged_no_text_pdf_file) is True
        tesseract_parser.settings.mode = ModeChoices.AUTO
+        mocker.patch("paperless.parsers.tesseract.is_tagged_pdf", return_value=True)
+        mocker.patch.object(tesseract_parser, "extract_text", return_value=None)
        mock_ocr = mocker.patch("ocrmypdf.ocr")
        tesseract_parser.parse(
-            tagged_no_text_pdf_file,
+            tesseract_samples_dir / "multi-page-images.pdf",
            "application/pdf",
            produce_archive=False,
        )
@@ -4,18 +4,10 @@ from __future__ import annotations

 import codecs
 from pathlib import Path
-from typing import TYPE_CHECKING
-
-import pytest

 from paperless.parsers.utils import is_tagged_pdf
-from paperless.parsers.utils import pdf_born_digital_text
-from paperless.parsers.utils import post_process_text
 from paperless.parsers.utils import read_file_handle_unicode_errors

-if TYPE_CHECKING:
-    from pytest_mock import MockerFixture
-
 SAMPLES = Path(__file__).parent / "samples" / "tesseract"


@@ -68,105 +60,3 @@ class TestIsTaggedPdf:
        bad = tmp_path / "bad.pdf"
        bad.write_bytes(b"not a pdf")
        assert is_tagged_pdf(bad) is False
-
-
-class TestPostProcessText:
-    @pytest.mark.parametrize(
-        ("source", "expected"),
-        [
-            pytest.param(
-                "simple     string",
-                "simple string",
-                id="collapse-spaces",
-            ),
-            pytest.param(
-                "simple    newline\n   testing string",
-                "simple newline\ntesting string",
-                id="preserve-newline",
-            ),
-            pytest.param(
-                "utf-8   строка с пробелами в конце  ",  # noqa: RUF001
-                "utf-8 строка с пробелами в конце",  # noqa: RUF001
-                id="utf8-trailing-spaces",
-            ),
-            pytest.param(None, None, id="none-input"),
-            pytest.param("", None, id="empty-string"),
-            pytest.param("   \n\x0c  \n ", None, id="whitespace-and-formfeed-only"),
-        ],
-    )
-    def test_post_process_text(
-        self,
-        source: str | None,
-        expected: str | None,
-    ) -> None:
-        assert post_process_text(source) == expected
-
-
-class TestPdfBornDigitalText:
-    """Regression coverage for GH #13387.
-
-    should_produce_archive() and RasterisedDocumentParser.parse() must agree
-    on whether a PDF has real text, so both go through this one function.
-    """
-
-    @pytest.mark.parametrize(
-        ("extracted", "tagged", "expected_text", "expected_born_digital"),
-        [
-            pytest.param("tiny", True, "tiny", True, id="tagged-with-real-text"),
-            pytest.param("tiny", False, "tiny", False, id="untagged-below-min-length"),
-            pytest.param(
-                "x" * 51,
-                False,
-                "x" * 51,
-                True,
-                id="untagged-above-min-length",
-            ),
-            pytest.param(None, True, None, False, id="tagged-but-no-text"),
-        ],
-    )
-    def test_born_digital_decision(
-        self,
-        mocker: MockerFixture,
-        tmp_path: Path,
-        extracted: str | None,
-        tagged: bool,  # noqa: FBT001
-        expected_text: str | None,
-        expected_born_digital: bool,  # noqa: FBT001
-    ) -> None:
-        """
-        GIVEN:
-            - A PDF whose pdftotext output and /MarkInfo tag status vary
-        WHEN:
-            - pdf_born_digital_text() is called
-        THEN:
-            - The normalized text and born-digital verdict match; the tag
-              alone never counts as "has text"
-        """
-        mocker.patch(
-            "paperless.parsers.utils.extract_pdf_text",
-            return_value=extracted,
-        )
-        mocker.patch("paperless.parsers.utils.is_tagged_pdf", return_value=tagged)
-        text, born_digital = pdf_born_digital_text(tmp_path / "doc.pdf")
-        assert text == expected_text
-        assert born_digital is expected_born_digital
-
-    def test_tagged_but_textless_pdf_is_not_born_digital(
-        self,
-        tagged_no_text_pdf_file: Path,
-    ) -> None:
-        """
-        GIVEN:
-            - A real PDF that is tagged (/MarkInfo /Marked true) but whose
-              only "text" is layout padding (a stray form-feed byte)
-        WHEN:
-            - pdf_born_digital_text() is called with no mocking
-        THEN:
-            - The normalized text is None and the PDF is not treated as
-              born-digital. The raw, unnormalized pdftotext output is
-              non-empty for this file, which is exactly what caused the
-              archive decision to disagree with the OCR decision in #13387.
-        """
-        text, born_digital = pdf_born_digital_text(tagged_no_text_pdf_file)
-        assert text is None
-        assert born_digital is False
@@ -14,7 +14,6 @@ from filelock import Timeout
 from documents.models import Document
 from documents.models import PaperlessTask
 from documents.utils import IterWrapper
-from documents.utils import QuerySetStream
 from documents.utils import identity
 from paperless.config import AIConfig
 from paperless_ai.db import db_connection_released
@@ -33,11 +32,6 @@ logger = logging.getLogger("paperless_ai.indexing")
 RAG_NUM_OUTPUT = 512
 RAG_CHUNK_OVERLAP = 200

-# update_llm_index(): row count per .iterator() batch when streaming
-# documents for a rebuild/update via QuerySetStream, matching
-# _DocumentViewerStream's chunk size in documents/search/_backend.py.
-_INDEX_STREAM_CHUNK_SIZE = 1000
-

 def queue_llm_index_update_if_needed(*, rebuild: bool, reason: str) -> bool:
    # NOTE: The check-then-enqueue sequence below is non-atomic (TOCTOU): two
@@ -391,9 +385,7 @@ def update_llm_index(
        if rebuild or not store.table_exists():
            logger.info("Rebuilding LLM index.")
            store.drop_table()
-            for document in iter_wrapper(
-                QuerySetStream(documents, chunk_size=_INDEX_STREAM_CHUNK_SIZE),
-            ):
+            for document in iter_wrapper(documents):
                nodes = build_document_node(document, chunk_size=chunk_size)
                _embed_nodes(nodes, embed_model)
                store.add(nodes)
@@ -406,9 +398,7 @@ def update_llm_index(
            )
            existing = store.get_modified_times()
            changed = 0
-            for document in iter_wrapper(
-                QuerySetStream(scoped_documents, chunk_size=_INDEX_STREAM_CHUNK_SIZE),
-            ):
+            for document in iter_wrapper(scoped_documents):
                doc_id = str(document.id)
                if existing.get(doc_id) == document.modified.isoformat():
                    continue
@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+from django.utils.translation import gettext_lazy as _
+
+
+class PaperlessBenchmarkConfig(AppConfig):
+    name = "paperless_benchmark"
+
+    verbose_name = _("Paperless benchmark")
@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from django.db import connection
+
+if TYPE_CHECKING:
+    from django.db.models import QuerySet
+
+
+def _reset_table_names() -> list[str]:
+    from guardian.models import GroupObjectPermission
+    from guardian.models import UserObjectPermission
+
+    from documents.models import Correspondent
+    from documents.models import Document
+    from documents.models import DocumentType
+    from documents.models import StoragePath
+    from documents.models import Tag
+
+    return [
+        Document.tags.through._meta.db_table,
+        Document._meta.db_table,
+        Tag._meta.db_table,
+        Correspondent._meta.db_table,
+        DocumentType._meta.db_table,
+        StoragePath._meta.db_table,
+        UserObjectPermission._meta.db_table,
+        GroupObjectPermission._meta.db_table,
+    ]
+
+
+def _delete_all_users_and_groups() -> None:
+    # ASSUMPTION: this tool assumes a disposable benchmark database, never
+    # point it at a real install. This deletes EVERY user and group in the
+    # database (not just benchmark-created ones) -- there is no way to
+    # distinguish "real" users from seeded ones, so this is only safe against
+    # a database that exists solely to run this benchmarking tool. The
+    # `benchmark seed --reset` CLI path requires an explicit
+    # `--yes-i-know-this-wipes-the-database` flag before reaching here; do
+    # not remove that guard.
+    from django.contrib.auth import get_user_model
+    from django.contrib.auth.models import Group
+
+    get_user_model().objects.all().delete()
+    Group.objects.all().delete()
+
+
+def _reset_postgresql() -> None:
+    tables = _reset_table_names()
+    with connection.cursor() as cursor:
+        cursor.execute(f"TRUNCATE TABLE {', '.join(tables)} RESTART IDENTITY CASCADE;")
+    _delete_all_users_and_groups()
+
+
+def _reset_mariadb() -> None:
+    # MariaDB's TRUNCATE has no CASCADE clause and refuses to truncate a
+    # table referenced by a foreign key while checks are enabled, so
+    # checks are disabled for the duration of the reset.
+    tables = _reset_table_names()
+    with connection.cursor() as cursor:
+        cursor.execute("SET FOREIGN_KEY_CHECKS = 0;")
+        try:
+            for table in tables:
+                cursor.execute(f"TRUNCATE TABLE {table};")
+        finally:
+            cursor.execute("SET FOREIGN_KEY_CHECKS = 1;")
+    _delete_all_users_and_groups()
+
+
+def _reset_sqlite() -> None:
+    from documents.models import Correspondent
+    from documents.models import Document
+    from documents.models import DocumentType
+    from documents.models import StoragePath
+    from documents.models import Tag
+
+    Document.global_objects.all().delete()
+    Tag.objects.all().delete()
+    Correspondent.objects.all().delete()
+    DocumentType.objects.all().delete()
+    StoragePath.objects.all().delete()
+    _delete_all_users_and_groups()
+
+
+def reset_benchmark_data() -> None:
+    """
+    Remove all previously-seeded benchmark data (documents, tags,
+    correspondents, document types, storage paths, guardian permission
+    rows, users, and groups) so a fresh `benchmark seed` run starts
+    from an empty slate. Dispatches per-backend because TRUNCATE syntax
+    and cascade behavior differ across the 3 supported databases.
+    """
+    if connection.vendor == "postgresql":
+        _reset_postgresql()
+    elif connection.vendor == "mysql":
+        # MariaDB also reports vendor == "mysql" under Django's mysql backend.
+        _reset_mariadb()
+    else:
+        _reset_sqlite()
+
+
+def capture_explain(queryset: QuerySet) -> str:
+    """
+    Return the query plan for `queryset` using the current backend's
+    explain facility. PostgreSQL supports `EXPLAIN ANALYZE {sql}` (real
+    execution stats). MariaDB does NOT accept that syntax -- verified
+    against a real MariaDB 12.3 container: `EXPLAIN ANALYZE {sql}` raises a
+    1064 syntax error, while MariaDB's own `ANALYZE {sql}` form (no
+    `EXPLAIN` keyword) works and returns real per-row execution stats
+    (`r_rows`, `r_filtered`, etc. columns) -- this is MariaDB's
+    EXPLAIN-ANALYZE-equivalent, distinct from MySQL 8.0.18+'s
+    `EXPLAIN ANALYZE` syntax, which MariaDB does not implement. SQLite only
+    supports EXPLAIN QUERY PLAN (the chosen plan, not real timing/row
+    counts) -- that output is clearly labeled rather than silently looking
+    equivalent to the other two backends' output.
+    """
+    sql, params = queryset.query.sql_with_params()
+    with connection.cursor() as cursor:
+        if connection.vendor == "postgresql":
+            cursor.execute(f"EXPLAIN ANALYZE {sql}", params)
+            return "\n".join(str(row[0]) for row in cursor.fetchall())
+        if connection.vendor == "mysql":
+            # MariaDB also reports vendor == "mysql" under Django's mysql
+            # backend. Unlike MySQL 8.0.18+, MariaDB has no `EXPLAIN
+            # ANALYZE` syntax -- its equivalent is `ANALYZE <statement>`.
+            cursor.execute(f"ANALYZE {sql}", params)
+            columns = [c[0] for c in cursor.description]
+            header = " | ".join(columns)
+            rows = "\n".join(
+                " | ".join(str(c) for c in row) for row in cursor.fetchall()
+            )
+            return f"{header}\n{rows}"
+        cursor.execute(f"EXPLAIN QUERY PLAN {sql}", params)
+        rows = "\n".join(" | ".join(str(c) for c in row) for row in cursor.fetchall())
+        return f"(plan only -- no execution stats on SQLite)\n{rows}"
@@ -0,0 +1,81 @@
+# src/paperless_benchmark/endpoints.py
+from __future__ import annotations
+
+import statistics
+import time
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from django.contrib.auth.models import User
+    from rest_framework.test import APIClient
+
+ENDPOINTS: tuple[tuple[str, str], ...] = (
+    ("documents_default", "/api/documents/"),
+    ("documents_page50", "/api/documents/?page_size=50"),
+    ("tags_all", "/api/tags/?page_size=100000"),
+)
+
+
+@dataclass(frozen=True, slots=True)
+class EndpointTiming:
+    user_label: str
+    endpoint_name: str
+    query_count: int
+    min_ms: float
+    median_ms: float
+    max_ms: float
+
+
+def _timed_requests(client: APIClient, url: str, n: int) -> list[float]:
+    times = []
+    for _ in range(n):
+        t0 = time.perf_counter()
+        resp = client.get(url)
+        t1 = time.perf_counter()
+        if resp.status_code != 200:
+            raise RuntimeError(
+                f"GET {url} -> {resp.status_code}: {resp.content[:300]!r}",
+            )
+        times.append(t1 - t0)
+    return times
+
+
+def _query_count(client: APIClient, url: str) -> int:
+    from django.db import connection
+    from django.test.utils import CaptureQueriesContext
+
+    with CaptureQueriesContext(connection) as ctx:
+        resp = client.get(url)
+    if resp.status_code != 200:
+        raise RuntimeError(f"GET {url} -> {resp.status_code}: {resp.content[:300]!r}")
+    return len(ctx.captured_queries)
+
+
+def run_endpoint_benchmarks(
+    *,
+    perf_target: User,
+    perf_admin: User,
+    repeat: int,
+) -> list[EndpointTiming]:
+    from rest_framework.test import APIClient
+
+    results: list[EndpointTiming] = []
+    for user_label, user in (("target", perf_target), ("admin", perf_admin)):
+        client = APIClient()
+        client.force_authenticate(user=user)
+        for name, url in ENDPOINTS:
+            client.get(url)  # warm-up request, not counted
+            qcount = _query_count(client, url)
+            times_ms = [t * 1000 for t in _timed_requests(client, url, repeat)]
+            results.append(
+                EndpointTiming(
+                    user_label=user_label,
+                    endpoint_name=name,
+                    query_count=qcount,
+                    min_ms=min(times_ms),
+                    median_ms=statistics.median(times_ms),
+                    max_ms=max(times_ms),
+                ),
+            )
+    return results
@@ -0,0 +1,56 @@
+# src/paperless_benchmark/harness.py
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+from typing import Generic
+from typing import TypeVar
+
+from django.db import connection
+from django.test.utils import CaptureQueriesContext
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+T = TypeVar("T")
+
+
+@dataclass(frozen=True, slots=True)
+class ProfileResult(Generic[T]):
+    best_seconds: float
+    all_seconds: tuple[float, ...]
+    query_count: int
+    result: T
+
+
+def run_profile(fn: Callable[[], T], *, repeat: int = 5) -> ProfileResult[T]:
+    """
+    Call `fn` `repeat` times, capturing wall-clock time for every call and
+    the SQL query count for the final call. Returns the best (minimum)
+    time across all repeats, since the first call(s) can be skewed by
+    connection warm-up or cold caches.
+    """
+    if repeat < 1:
+        raise ValueError("repeat must be >= 1")
+
+    all_seconds: list[float] = []
+    result: T | None = None
+    query_count = 0
+    for i in range(repeat):
+        with CaptureQueriesContext(connection) as ctx:
+            start = time.perf_counter()
+            result = fn()
+            all_seconds.append(time.perf_counter() - start)
+        if i == repeat - 1:
+            query_count = len(ctx.captured_queries)
+    # Purely a type-narrowing aid for the type checker: the `repeat < 1`
+    # guard above already turns the one case that could leave `result`
+    # unset into a clear ValueError, so this is unreachable in practice.
+    assert result is not None
+    return ProfileResult(
+        best_seconds=min(all_seconds),
+        all_seconds=tuple(all_seconds),
+        query_count=query_count,
+        result=result,
+    )
@@ -0,0 +1,222 @@
+# src/paperless_benchmark/management/commands/benchmark.py
+from __future__ import annotations
+
+from typing import Any
+
+from django.core.management.base import BaseCommand
+from django.core.management.base import CommandError
+from django.core.management.base import CommandParser
+
+
+class Command(BaseCommand):
+    help = "Seed, run, and profile paperless-ngx performance benchmarks."
+
+    def add_arguments(self, parser: CommandParser) -> None:
+        parser.add_argument(
+            "action",
+            choices=["seed", "run", "profile", "list-scenarios"],
+            help="Which benchmark action to perform.",
+        )
+        parser.add_argument(
+            "scenario",
+            nargs="?",
+            default=None,
+            help="Scenario name (required for `profile`; see `list-scenarios`).",
+        )
+        parser.add_argument(
+            "--tier",
+            choices=["home", "medium", "large"],
+            default="medium",
+            help="Dataset scale tier for `seed` (default: medium).",
+        )
+        parser.add_argument(
+            "--reset",
+            action="store_true",
+            default=False,
+            help="For `seed`: truncate existing benchmark data first.",
+        )
+        parser.add_argument(
+            "--yes-i-know-this-wipes-the-database",
+            action="store_true",
+            default=False,
+            help=(
+                "Required alongside --reset: confirms you understand `seed "
+                "--reset` deletes ALL users, ALL groups, and ALL documents/"
+                "tags/correspondents/document types/storage paths in this "
+                "database, not just benchmark-created ones."
+            ),
+        )
+        parser.add_argument(
+            "--seed",
+            type=int,
+            default=42,
+            help="RNG seed for reproducible datasets (default: 42).",
+        )
+        parser.add_argument(
+            "--repeat",
+            type=int,
+            default=5,
+            help="Number of timed repetitions for `run`/`profile` (default: 5).",
+        )
+        parser.add_argument(
+            "--label",
+            default="baseline",
+            help="Free-text tag for a `run`, printed and recorded in history only.",
+        )
+        parser.add_argument(
+            "--explain",
+            action="store_true",
+            default=False,
+            help="For `profile`: also capture and print the query plan.",
+        )
+
+    def handle(self, *args: Any, **options: Any) -> None:
+        action = options["action"]
+        if action == "seed":
+            self._handle_seed(options)
+        elif action == "run":
+            self._handle_run(options)
+        elif action == "profile":
+            self._handle_profile(options)
+        else:
+            self._handle_list_scenarios()
+
+    def _handle_seed(self, options: dict[str, Any]) -> None:
+        from paperless_benchmark.db import reset_benchmark_data
+        from paperless_benchmark.seeding import seed_benchmark_dataset
+
+        if options["reset"]:
+            if not options["yes_i_know_this_wipes_the_database"]:
+                raise CommandError(
+                    "--reset requires --yes-i-know-this-wipes-the-database. "
+                    "This deletes ALL users, ALL groups, and ALL documents, "
+                    "tags, correspondents, document types, and storage paths "
+                    "in this database -- not just benchmark-created ones. "
+                    "Only run this against a disposable benchmark database, "
+                    "never a real install. Re-run with "
+                    "--reset --yes-i-know-this-wipes-the-database to proceed.",
+                )
+            self.stdout.write("Resetting existing benchmark data...")
+            reset_benchmark_data()
+
+        data = seed_benchmark_dataset(options["tier"], seed=options["seed"])
+        self.stdout.write(
+            self.style.SUCCESS(
+                f"Seeded tier={options['tier']!r}: {data.documents} documents, "
+                f"{len(data.users)} users, {len(data.groups)} groups.",
+            ),
+        )
+
+    def _handle_run(self, options: dict[str, Any]) -> None:
+        from django.contrib.auth import get_user_model
+        from django.db import connection
+
+        from documents.models import Document
+        from paperless_benchmark.endpoints import run_endpoint_benchmarks
+        from paperless_benchmark.results import append_history
+
+        user_model = get_user_model()
+        try:
+            perf_target = user_model.objects.get(username="perf_target")
+            perf_admin = user_model.objects.get(username="perf_admin")
+        except user_model.DoesNotExist as e:
+            raise CommandError(
+                "No benchmark dataset found. Run `manage.py benchmark seed` first.",
+            ) from e
+
+        db_vendor = connection.vendor
+        document_count = Document.objects.count()
+
+        results = run_endpoint_benchmarks(
+            perf_target=perf_target,
+            perf_admin=perf_admin,
+            repeat=options["repeat"],
+        )
+
+        self.stdout.write(f"# label={options['label']} repeat={options['repeat']}")
+        self.stdout.write(
+            f"{'user':7s} {'endpoint':20s} {'queries':>8s} "
+            f"{'min_ms':>9s} {'median_ms':>10s} {'max_ms':>9s}",
+        )
+        for r in results:
+            self.stdout.write(
+                f"{r.user_label:7s} {r.endpoint_name:20s} {r.query_count:8d} "
+                f"{r.min_ms:9.1f} {r.median_ms:10.1f} {r.max_ms:9.1f}",
+            )
+            append_history(
+                {
+                    "mode": "run",
+                    "label": options["label"],
+                    "user": r.user_label,
+                    "endpoint": r.endpoint_name,
+                    "query_count": r.query_count,
+                    "min_ms": r.min_ms,
+                    "median_ms": r.median_ms,
+                    "max_ms": r.max_ms,
+                    "db_vendor": db_vendor,
+                    "document_count": document_count,
+                },
+            )
+
+    def _handle_profile(self, options: dict[str, Any]) -> None:
+        from django.contrib.auth import get_user_model
+        from django.db import connection
+
+        from documents.models import Document
+        from paperless_benchmark.db import capture_explain
+        from paperless_benchmark.harness import run_profile
+        from paperless_benchmark.results import append_history
+        from paperless_benchmark.scenarios import get as get_scenario
+
+        if not options["scenario"]:
+            raise CommandError(
+                "`profile` requires a scenario name; see `list-scenarios`.",
+            )
+
+        scenario = get_scenario(options["scenario"])
+
+        user_model = get_user_model()
+        try:
+            perf_target = user_model.objects.get(username="perf_target")
+        except user_model.DoesNotExist as e:
+            raise CommandError(
+                "No benchmark dataset found. Run `manage.py benchmark seed` first.",
+            ) from e
+
+        profile = run_profile(
+            lambda: scenario.run(perf_target),
+            repeat=options["repeat"],
+        )
+        self.stdout.write(
+            f"{scenario.name}: best={profile.best_seconds:.4f}s "
+            f"queries={profile.query_count}",
+        )
+
+        if options["explain"]:
+            if scenario.queryset_for_explain is not None:
+                plan = capture_explain(scenario.queryset_for_explain(perf_target))
+                self.stdout.write(plan)
+            else:
+                self.stdout.write(
+                    self.style.WARNING(
+                        f"--explain was requested but scenario {scenario.name!r} "
+                        "does not support it (no queryset_for_explain); skipping.",
+                    ),
+                )
+
+        append_history(
+            {
+                "mode": "profile",
+                "scenario": scenario.name,
+                "best_seconds": profile.best_seconds,
+                "query_count": profile.query_count,
+                "db_vendor": connection.vendor,
+                "document_count": Document.objects.count(),
+            },
+        )
+
+    def _handle_list_scenarios(self) -> None:
+        from paperless_benchmark.scenarios import all_scenarios
+
+        for scenario in all_scenarios():
+            self.stdout.write(f"{scenario.name}: {scenario.describe}")
@@ -0,0 +1,39 @@
+# src/paperless_benchmark/results.py
+from __future__ import annotations
+
+import json
+import subprocess
+from datetime import UTC
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+RESULTS_DIR = Path(__file__).resolve().parent.parent.parent / "benchmark_results"
+
+
+def _current_git_ref() -> str:
+    result = subprocess.run(
+        ["git", "rev-parse", "--short", "HEAD"],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    return result.stdout.strip() or "unknown"
+
+
+def append_history(entry: dict[str, Any], *, code_ref: str | None = None) -> None:
+    """
+    Append one line to benchmark_results/history.jsonl -- a local-only,
+    append-only, cross-session record of every `benchmark run`/`profile`
+    invocation. Unlike a single overwritten snapshot file, this survives
+    across sessions so a benchmarking effort picked back up days later has
+    a full timeline instead of only the most recent result.
+    """
+    RESULTS_DIR.mkdir(exist_ok=True)
+    record = {
+        "timestamp": datetime.now(UTC).isoformat(),
+        "code_ref": code_ref or _current_git_ref(),
+        **entry,
+    }
+    with (RESULTS_DIR / "history.jsonl").open("a") as f:
+        f.write(json.dumps(record) + "\n")
@@ -0,0 +1,110 @@
+# src/paperless_benchmark/scenarios.py
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+from typing import Any
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from django.contrib.auth.models import User
+    from django.db.models import QuerySet
+
+
+@dataclass(frozen=True, slots=True)
+class Scenario:
+    name: str
+    describe: str
+    run: Callable[[User], Any]
+    queryset_for_explain: Callable[[User], QuerySet] | None = None
+
+
+_SCENARIOS: dict[str, Scenario] = {}
+
+
+def register(scenario: Scenario) -> None:
+    _SCENARIOS[scenario.name] = scenario
+
+
+def get(name: str) -> Scenario:
+    from django.core.management.base import CommandError
+
+    try:
+        return _SCENARIOS[name]
+    except KeyError:
+        available = ", ".join(sorted(_SCENARIOS)) or "(none registered)"
+        raise CommandError(
+            f"Unknown benchmark scenario {name!r}. Available: {available}",
+        ) from None
+
+
+def all_scenarios() -> tuple[Scenario, ...]:
+    return tuple(_SCENARIOS.values())
+
+
+def _guardian_visibility_query_run(user: User) -> list[int]:
+    from documents.models import Document
+    from documents.permissions import get_objects_for_user_owner_aware
+
+    return list(
+        get_objects_for_user_owner_aware(
+            user,
+            "documents.view_document",
+            Document,
+        ).values_list("id", flat=True),
+    )
+
+
+def _guardian_visibility_query_queryset(user: User) -> QuerySet:
+    from documents.models import Document
+    from documents.permissions import get_objects_for_user_owner_aware
+
+    return get_objects_for_user_owner_aware(user, "documents.view_document", Document)
+
+
+register(
+    Scenario(
+        name="guardian_visibility_query",
+        describe=(
+            "Document-visibility queryset for a user with mixed owned/shared "
+            "documents -- exercises documents.permissions."
+            "get_objects_for_user_owner_aware's guardian permission join."
+        ),
+        run=_guardian_visibility_query_run,
+        queryset_for_explain=_guardian_visibility_query_queryset,
+    ),
+)
+
+
+def _permitted_document_ids_run(user: User) -> list[int]:
+    from documents.models import Document
+    from documents.permissions import permitted_document_ids
+
+    return list(
+        Document.objects.filter(id__in=permitted_document_ids(user)).values_list(
+            "id",
+            flat=True,
+        ),
+    )
+
+
+def _permitted_document_ids_queryset(user: User) -> QuerySet:
+    from documents.models import Document
+    from documents.permissions import permitted_document_ids
+
+    return Document.objects.filter(id__in=permitted_document_ids(user))
+
+
+register(
+    Scenario(
+        name="permitted_document_ids",
+        describe=(
+            "Document-visibility query built from documents.permissions."
+            "permitted_document_ids -- the resolved-ID-set alternative to "
+            "guardian_visibility_query, for side-by-side comparison."
+        ),
+        run=_permitted_document_ids_run,
+        queryset_for_explain=_permitted_document_ids_queryset,
+    ),
+)
@@ -0,0 +1,445 @@
+# src/paperless_benchmark/seeding.py
+from __future__ import annotations
+
+import datetime
+import random
+import time
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+from typing import Literal
+
+if TYPE_CHECKING:
+    from django.contrib.auth.models import Group
+    from django.contrib.auth.models import User
+
+Tier = Literal["home", "medium", "large"]
+
+CHUNK_SIZE = 5_000
+
+MIME_TYPES = (
+    "application/pdf",
+    "image/png",
+    "image/jpeg",
+    "text/plain",
+)
+
+# Ownership split for documents, mirroring the shape used in the #11950
+# perf-benchmark dataset (owned-by-target / owned-by-other / unowned).
+OWNED_BY_TARGET_FRACTION = 0.60
+OWNED_BY_OTHER_FRACTION = 0.30
+# remainder (0.10) is unowned
+
+# Of documents owned by "other" users, the fraction explicitly shared
+# (view, or view+change) with perf_target via guardian permissions --
+# this is what exercises the get_user_can_change() per-row N+1 that the
+# `run` endpoint benchmarks measure.
+SHARED_WITH_TARGET_FRACTION = 0.5
+SHARED_WITH_CHANGE_FRACTION = 0.5
+
+# Guardian permission-row ratios measured from a real install (discussion
+# #13276): 1,414 user-perm rows / 27,232 group-perm rows over 12,000
+# documents. Layered across ALL owned documents for the general user/group
+# pool (not just perf_target's shares), so `profile` scenarios exercise a
+# realistic permission-join shape for arbitrary users, not only perf_target.
+USER_PERM_ROWS_PER_DOC = 1_414 / 12_000
+GROUP_PERM_ROWS_PER_DOC = 27_232 / 12_000
+
+
+@dataclass(frozen=True, slots=True)
+class _TierCounts:
+    documents: int
+    tags: int
+    correspondents: int
+    document_types: int
+    storage_paths: int
+    other_users: int
+    groups: int
+    tags_per_doc: tuple[int, int]
+
+
+TIERS: dict[Tier, _TierCounts] = {
+    "home": _TierCounts(
+        documents=500,
+        tags=20,
+        correspondents=10,
+        document_types=8,
+        storage_paths=5,
+        other_users=3,
+        groups=2,
+        tags_per_doc=(1, 3),
+    ),
+    "medium": _TierCounts(
+        documents=20_000,
+        tags=100,
+        correspondents=300,
+        document_types=50,
+        storage_paths=20,
+        other_users=10,
+        groups=5,
+        tags_per_doc=(2, 6),
+    ),
+    "large": _TierCounts(
+        documents=360_000,
+        tags=1_000,
+        correspondents=5_000,
+        document_types=300,
+        storage_paths=50,
+        other_users=25,
+        groups=10,
+        tags_per_doc=(3, 7),
+    ),
+}
+
+
+def log(msg: str) -> None:
+    print(f"[{time.strftime('%H:%M:%S')}] {msg}", flush=True)  # noqa: T201
+
+
+@dataclass(frozen=True, slots=True)
+class SeededData:
+    """
+    Summary of a completed seed run. `documents`/`tags`/`correspondents`/
+    `document_types`/`storage_paths` are counts, not the seeded ORM
+    instances: at the `large` tier (360,000 documents) holding every
+    instance in memory simultaneously is a real risk for zero benefit, since
+    no caller consumes anything but the counts. `perf_target`/`perf_admin`/
+    `users`/`groups` stay as real objects -- at most ~26 users/12 groups even
+    at `large` tier, and small enough to be useful to a future caller.
+    """
+
+    perf_target: User
+    perf_admin: User
+    users: tuple[User, ...]
+    groups: tuple[Group, ...]
+    documents: int
+    tags: int
+    correspondents: int
+    document_types: int
+    storage_paths: int
+
+
+def _grant_model_level_permissions(user: User) -> None:
+    """
+    Grant perf_target Django model-level view/add/change permissions on
+    Document and Tag, on top of the per-object guardian grants seeding
+    creates elsewhere. DRF's PaperlessObjectPermissions checks model-level
+    permissions before guardian's object-level ones are ever consulted, so
+    without this perf_target gets a blanket 403 on /api/documents/ and
+    /api/tags/ regardless of which documents guardian says it can see.
+    """
+    from django.contrib.auth.models import Permission
+    from django.contrib.contenttypes.models import ContentType
+
+    from documents.models import Document
+    from documents.models import Tag
+
+    for model in (Document, Tag):
+        content_type = ContentType.objects.get_for_model(model)
+        codenames = [
+            f"{action}_{model._meta.model_name}" for action in ("view", "add", "change")
+        ]
+        perms = Permission.objects.filter(
+            content_type=content_type,
+            codename__in=codenames,
+        )
+        user.user_permissions.add(*perms)
+
+
+def _create_users_and_groups(
+    counts: _TierCounts,
+) -> tuple[User, User, tuple[User, ...], tuple[Group, ...]]:
+    from django.contrib.auth.models import Group
+
+    from documents.tests.factories import UserFactory
+
+    perf_target = UserFactory.create(username="perf_target")
+    _grant_model_level_permissions(perf_target)
+    perf_admin = UserFactory.create(username="perf_admin", superuser=True)
+    other_users = tuple(UserFactory.create_batch(counts.other_users))
+    groups = tuple(
+        Group.objects.create(name=f"benchmark_group_{i}") for i in range(counts.groups)
+    )
+    log(
+        f"Created users: 1 target, 1 superuser, {len(other_users)} other, "
+        f"{len(groups)} groups.",
+    )
+    return perf_target, perf_admin, other_users, groups
+
+
+def _create_lookup_tables(counts: _TierCounts):
+    from documents.models import Correspondent
+    from documents.models import DocumentType
+    from documents.models import StoragePath
+    from documents.models import Tag
+    from documents.tests.factories import CorrespondentFactory
+    from documents.tests.factories import DocumentTypeFactory
+    from documents.tests.factories import StoragePathFactory
+    from documents.tests.factories import TagFactory
+
+    tags = tuple(Tag.objects.bulk_create(TagFactory.build_batch(counts.tags)))
+    correspondents = tuple(
+        Correspondent.objects.bulk_create(
+            CorrespondentFactory.build_batch(counts.correspondents),
+        ),
+    )
+    document_types = tuple(
+        DocumentType.objects.bulk_create(
+            DocumentTypeFactory.build_batch(counts.document_types),
+        ),
+    )
+    storage_paths = tuple(
+        StoragePath.objects.bulk_create(
+            StoragePathFactory.build_batch(counts.storage_paths),
+        ),
+    )
+    log(
+        f"Created {len(tags)} tags, {len(correspondents)} correspondents, "
+        f"{len(document_types)} document types, {len(storage_paths)} storage paths.",
+    )
+    return tags, correspondents, document_types, storage_paths
+
+
+def _assign_owner(rng: random.Random, perf_target: User, other_users: tuple[User, ...]):
+    roll = rng.random()
+    if roll < OWNED_BY_TARGET_FRACTION:
+        return perf_target, "target"
+    if roll < OWNED_BY_TARGET_FRACTION + OWNED_BY_OTHER_FRACTION:
+        return rng.choice(other_users), "other"
+    return None, "unowned"
+
+
+def _seed_documents(
+    rng: random.Random,
+    counts: _TierCounts,
+    tags,
+    correspondents,
+    document_types,
+    storage_paths,
+    perf_target,
+    other_users,
+) -> tuple[int, list[int]]:
+    """
+    Bulk-create `counts.documents` documents in chunks. Returns the total
+    document count plus a lightweight list of pks for documents that ended
+    up with an owner (target or other) -- that's all
+    `_grant_general_permissions` needs to sample from, so full `Document`
+    instances aren't accumulated across chunks (a real memory concern at the
+    `large` tier's 360,000 documents).
+    """
+    from django.contrib.auth.models import Permission
+    from django.contrib.contenttypes.models import ContentType
+    from guardian.models import UserObjectPermission
+
+    from documents.models import Document
+    from documents.tests.factories import DocumentFactory
+
+    tag_ids = [t.pk for t in tags]
+    correspondent_ids = [c.pk for c in correspondents]
+    document_type_ids = [d.pk for d in document_types]
+    storage_path_ids = [s.pk for s in storage_paths]
+
+    doc_content_type = ContentType.objects.get_for_model(Document)
+    view_perm = Permission.objects.get(
+        codename="view_document",
+        content_type=doc_content_type,
+    )
+    change_perm = Permission.objects.get(
+        codename="change_document",
+        content_type=doc_content_type,
+    )
+    through_model = Document.tags.through
+
+    document_count = 0
+    owned_document_pks: list[int] = []
+    remaining = counts.documents
+    while remaining > 0:
+        chunk_n = min(CHUNK_SIZE, remaining)
+        remaining -= chunk_n
+
+        batch = []
+        owner_buckets = []
+        for _ in range(chunk_n):
+            doc = DocumentFactory.build(
+                mime_type=rng.choice(MIME_TYPES),
+                page_count=rng.randint(1, 30),
+                correspondent_id=(
+                    rng.choice(correspondent_ids)
+                    if correspondent_ids and rng.random() < 0.8
+                    else None
+                ),
+                document_type_id=(
+                    rng.choice(document_type_ids)
+                    if document_type_ids and rng.random() < 0.6
+                    else None
+                ),
+                storage_path_id=(
+                    rng.choice(storage_path_ids)
+                    if storage_path_ids and rng.random() < 0.8
+                    else None
+                ),
+                # Document.created is a plain DateField (default: today).
+                # Leaving it unset would give every seeded document the same
+                # date, collapsing Document's ("-created",) ordering index
+                # into a single-valued sort key -- spread it over a
+                # realistic multi-year window instead.
+                created=datetime.date.today()
+                - datetime.timedelta(days=rng.randint(0, 365 * 3)),
+            )
+            owner, bucket = _assign_owner(rng, perf_target, other_users)
+            doc.owner_id = owner.pk if owner else None
+            batch.append(doc)
+            owner_buckets.append(bucket)
+
+        created = Document.objects.bulk_create(batch, batch_size=CHUNK_SIZE)
+
+        through_rows = []
+        for doc in created:
+            k = rng.randint(*counts.tags_per_doc)
+            for tag_id in rng.sample(tag_ids, min(k, len(tag_ids))):
+                through_rows.append(through_model(document_id=doc.pk, tag_id=tag_id))
+        if through_rows:
+            through_model.objects.bulk_create(through_rows, batch_size=CHUNK_SIZE)
+
+        perm_rows = []
+        for doc, bucket in zip(created, owner_buckets, strict=True):
+            if bucket == "unowned":
+                continue
+            owned_document_pks.append(doc.pk)
+
+            if bucket != "other":
+                continue
+            if rng.random() >= SHARED_WITH_TARGET_FRACTION:
+                continue
+            perm_rows.append(
+                UserObjectPermission(
+                    permission=view_perm,
+                    content_type=doc_content_type,
+                    object_pk=str(doc.pk),
+                    user=perf_target,
+                ),
+            )
+            if rng.random() < SHARED_WITH_CHANGE_FRACTION:
+                perm_rows.append(
+                    UserObjectPermission(
+                        permission=change_perm,
+                        content_type=doc_content_type,
+                        object_pk=str(doc.pk),
+                        user=perf_target,
+                    ),
+                )
+        if perm_rows:
+            UserObjectPermission.objects.bulk_create(perm_rows, batch_size=CHUNK_SIZE)
+
+        document_count += len(created)
+        log(f"  {document_count}/{counts.documents} documents seeded")
+
+    return document_count, owned_document_pks
+
+
+def _grant_general_permissions(
+    rng: random.Random,
+    owned_document_pks: list[int],
+    users,
+    groups,
+) -> None:
+    """
+    Layer realistic (issue #13276-derived) guardian permission-row ratios
+    across owned documents for the general user/group pool, so `profile`
+    scenarios exercise the same permission-join shape regardless of which
+    user they check visibility for (not just perf_target).
+    """
+    from django.contrib.auth.models import Permission
+    from django.contrib.contenttypes.models import ContentType
+    from guardian.models import GroupObjectPermission
+    from guardian.models import UserObjectPermission
+
+    from documents.models import Document
+
+    if not owned_document_pks or not users:
+        return
+
+    doc_content_type = ContentType.objects.get_for_model(Document)
+    view_perm = Permission.objects.get(
+        codename="view_document",
+        content_type=doc_content_type,
+    )
+
+    n_user_perms = round(len(owned_document_pks) * USER_PERM_ROWS_PER_DOC)
+    n_group_perms = (
+        round(len(owned_document_pks) * GROUP_PERM_ROWS_PER_DOC) if groups else 0
+    )
+
+    user_rows = [
+        UserObjectPermission(
+            permission=view_perm,
+            content_type=doc_content_type,
+            object_pk=str(rng.choice(owned_document_pks)),
+            user=rng.choice(users),
+        )
+        for _ in range(n_user_perms)
+    ]
+    if user_rows:
+        UserObjectPermission.objects.bulk_create(
+            user_rows,
+            batch_size=CHUNK_SIZE,
+            ignore_conflicts=True,
+        )
+
+    group_rows = [
+        GroupObjectPermission(
+            permission=view_perm,
+            content_type=doc_content_type,
+            object_pk=str(rng.choice(owned_document_pks)),
+            group=rng.choice(groups),
+        )
+        for _ in range(n_group_perms)
+    ]
+    if group_rows:
+        GroupObjectPermission.objects.bulk_create(
+            group_rows,
+            batch_size=CHUNK_SIZE,
+            ignore_conflicts=True,
+        )
+
+    log(f"  Granted {len(user_rows)} user perms, {len(group_rows)} group perms.")
+
+
+def seed_benchmark_dataset(tier: Tier, *, seed: int = 42) -> SeededData:
+    """
+    Build a benchmark dataset at the given scale tier: a named perf_target
+    (mixed owned/shared documents) and perf_admin (superuser) for endpoint
+    benchmarking, plus a general user/group pool with realistic guardian
+    permission-row ratios for profile scenarios.
+    """
+    counts = TIERS[tier]
+    rng = random.Random(seed)
+
+    log(f"Seeding tier={tier!r}")
+    perf_target, perf_admin, other_users, groups = _create_users_and_groups(counts)
+    tags, correspondents, document_types, storage_paths = _create_lookup_tables(counts)
+    document_count, owned_document_pks = _seed_documents(
+        rng,
+        counts,
+        tags,
+        correspondents,
+        document_types,
+        storage_paths,
+        perf_target,
+        other_users,
+    )
+    all_users = (perf_target, *other_users)
+    _grant_general_permissions(rng, owned_document_pks, all_users, groups)
+
+    log(f"Done. {document_count} documents seeded for tier={tier!r}.")
+
+    return SeededData(
+        perf_target=perf_target,
+        perf_admin=perf_admin,
+        users=all_users,
+        groups=groups,
+        documents=document_count,
+        tags=len(tags),
+        correspondents=len(correspondents),
+        document_types=len(document_types),
+        storage_paths=len(storage_paths),
+    )
Author	SHA1	Message	Date
stumpylogandClaude Sonnet 5	cfb9125d9e	chore: remove benchmark-commands spec/plan docs now that work is complete Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-07-30 13:43:01 -07:00
stumpylogandClaude Sonnet 5	fa2d7f660b	Fix: apply final-review fix wave (safety guard, date spread, MariaDB explain, history fields, memory footprint, minors) Final whole-branch review before this tooling branch settles: add a required --yes-i-know-this-wipes-the-database confirmation flag ahead of --reset (it deletes ALL users/groups/documents in the target DB, not just benchmark-created ones); spread seeded documents' created dates over a 3-year window instead of leaving them all on one default date; fix capture_explain() to use MariaDB's ANALYZE syntax instead of Postgres-only EXPLAIN ANALYZE (verified against real MariaDB 12.3 -- the old code was a silent 1064 syntax error); record db_vendor/document_count in run/profile history entries; shrink SeededData's memory footprint at scale by returning counts instead of full ORM instance tuples; and a handful of minor fixes (storage_path assignment, --explain warning instead of silent no-op, harness.py repeat<1 guard, type annotations). All changes verified against real Postgres and MariaDB containers on the VM, not just SQLite. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-07-30 13:33:28 -07:00
stumpylogandClaude Sonnet 5	2712c3fe48	Fix: correct /api/tags/ endpoint URL in benchmarking skill The skill documentation stated that run benchmarks /api/tags/ but src/paperless_benchmark/endpoints.py actually uses /api/tags/?page_size=100000. Update the skill's Command reference section to match the actual endpoint definition. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-07-30 11:20:14 -07:00
stumpylog	684c4ef392	docs(benchmark): add paperless-benchmarking skill	2026-07-30 11:07:33 -07:00
stumpylog	410e440bd6	fix(benchmark): fully clear users/groups on reset, grant perf_target model perms	2026-07-30 10:53:02 -07:00
stumpylogandClaude Sonnet 5	ef9ee435e8	docs: add Task 10 (quirk fixes) and Task 11 (skill) to benchmark plan Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-07-30 10:44:34 -07:00
stumpylog	5d8287f120	fix(benchmark): reuse seeded data in profile instead of reseeding _handle_profile unconditionally called seed_benchmark_dataset every run, colliding with an IntegrityError against data seeded by a prior seed/profile call. Look up the existing perf_target user instead, matching _handle_run's already-correct pattern, and raise a CommandError pointing at `seed` if no dataset exists. Scenario.run/queryset_for_explain now take a User directly instead of a SeededData, since only data.users[0] (perf_target) was ever used. profile no longer seeds, so it drops the --tier dependency: the printed line and history entry no longer include a tier/(tier=...) suffix, and --tier's help text now only mentions `seed`.	2026-07-30 10:15:12 -07:00
stumpylog	acfdafbff9	feat(benchmark): add manage.py benchmark command (seed/run/profile/list-scenarios)	2026-07-30 09:52:21 -07:00
stumpylog	cd02cfe02c	feat(benchmark): add pluggable profile-scenario registry	2026-07-30 08:31:14 -07:00
stumpylog	ff9cde7f9c	feat(benchmark): add timed API endpoint scenarios	2026-07-30 07:49:05 -07:00
stumpylogandClaude Sonnet 5	259731074c	docs: add implementation plan for benchmark management commands Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-07-30 07:16:32 -07:00
stumpylog	02aaf9b3a2	feat(benchmark): add local JSONL results history log	2026-07-29 14:58:11 -07:00
stumpylog	8a34385199	feat(benchmark): add tiered dataset seeding	2026-07-29 14:17:52 -07:00
stumpylog	3e8656a3ed	feat(benchmark): add per-backend reset and explain helpers	2026-07-29 13:27:39 -07:00
stumpylog	8ec322f9aa	feat(benchmark): add run_profile timing harness	2026-07-29 12:29:53 -07:00
stumpylogandClaude Sonnet 5	22e4be1548	feat(benchmark): scaffold paperless_benchmark app Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-07-29 12:11:53 -07:00
stumpylogandClaude Sonnet 5	17e0b70da5	docs: add design spec for benchmark management commands Merges the standalone run_benchmarks.py/seed_benchmark_data.py scripts and the tools/profiling branch's Postgres-only harness into one cross-backend `manage.py benchmark` command suite. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-07-29 11:15:28 -07:00