diff --git a/.gitignore b/.gitignore
index 966a1f4e..da691ffa 100644
--- a/.gitignore
+++ b/.gitignore
@@ -35,3 +35,5 @@ static/data/bibItems/
 !/content/en/history/bibliography/_index.md
 !/content/en/history/bibliography/intake/
 !/content/en/history/bibliography/intake/**
+!/content/en/history/bibliography/zotero-resources/
+!/content/en/history/bibliography/zotero-resources/**
diff --git a/content/en/history/bibliography/zotero-resources/_index.md b/content/en/history/bibliography/zotero-resources/_index.md
new file mode 100644
index 00000000..d9a42968
--- /dev/null
+++ b/content/en/history/bibliography/zotero-resources/_index.md
@@ -0,0 +1,252 @@
+---
+title: "Zotero Type Mapping Reference"
+description: "How Interlisp Zotero bibliography types map to CSL JSON and Schema.org vocabulary"
+type: docs
+toc_hide: false
+---
+
+## Purpose
+
+This page documents how bibliography entry types are classified and mapped through the processing pipeline. It serves as a reference for:
+
+- **Metadata creators** contributing to the Interlisp Zotero group who want to understand how their entries will be categorized
+- **Developers** working on the bibliography processing system who need to know current type support
+- **Data consumers** using the JSON-LD output who need to understand what schema.org types represent Interlisp bibliography entries
+
+To recommend a new title for inclusion in the bibliography, please see the [Interlisp Bibliography Intake Guide](history/bibliography/intake).  It explains how to recommend new bibliography items and provides a link to the appropriate form.
+
+The mapping chain flows through three formats:
+
+```
+Zotero Item Type → CSL JSON Type → Schema.org @type
+```
+
+Each format serves a different purpose:
+
+- **Zotero Item Type**: Classification used within Zotero (the source system)
+- **CSL JSON Type**: Standardized format for citation metadata (intermediate processing format)
+- **Schema.org @type**: Structured data markup for web search engines and semantic web consumers (output format)
+
+A Zotero item type maps to exactly one CSL JSON type. The CSL JSON type is what the rest of the pipeline sees, and it is the value recorded as `item_type` in each bibliography entry's front matter.
+
+---
+
+## Type Reference Table
+
+| Zotero Item Type | CSL Type | Schema.org @type | additionalType | genre | Notes |
+|---|---|---|---|---|---|
+| **Journal Article** | `article-journal` | `ScholarlyArticle` | — | — | Peer-reviewed journal articles, conference proceedings in journals |
+| **Magazine Article** | `article-magazine` | `Article` | — | — | Magazine and trade publication articles |
+| **Newspaper Article** | `article` | `Article` | — | — | Newspaper articles and news items |
+| **Book** | `book` | `Book` | — | — | Books and monographs |
+| **Book Section** | `chapter` | `Chapter` | — | — | Chapters or sections within books |
+| **Conference Paper** | `paper-conference` | `ScholarlyArticle` | — | — | Papers presented at conferences (when not in proceedings) |
+| **Report** | `report` | `Report` | the entry's report type | — | Technical reports, working papers, government documents |
+| **Thesis** | `thesis` | `Thesis` | — | — | Master's theses, dissertations, doctoral theses |
+| **Patent** | `patent` | `CreativeWork` | `"Patent"` | — | Patents and patent applications |
+| **Blog Post** | `post-weblog` | `BlogPosting` | — | — | Blog posts and web log entries |
+| **Webpage** | `webpage` | `WebPage` | — | — | General web pages and websites |
+| **Encyclopedia Entry** | `entry-encyclopedia` | `Article` | — | — | Encyclopedia and reference work entries |
+| **Film** | `motion_picture` | `VideoObject` | — | — | Films, videos, and visual media |
+| **Email** | `personal_communication` | `Message` | — | — | Personal communications, emails, letters |
+| **Computer Program** | `software` | `SoftwareSourceCode` | — | — | Software, source code repositories, applications, tools. The Type field names the programming language and maps to `programmingLanguage`; publisher, when present, maps to `publisher`. |
+| **Document** | `document` | `CreativeWork` | `"TechnicalDocumentation"` | the entry's Type, if set | Technical manuals, guides, user documentation, software docs, specifications. Publisher, when present, maps to `publisher`. |
+| **Document** with Type `Transcript` | `document` | `CreativeWork` | `"Transcript"` | `"Transcript"` | Oral history interviews, recorded interviews, media transcripts |
+| **Document** with Type `Newsletter` | `document` | `CreativeWork` | `"TechnicalDocumentation"` | `"Newsletter"` | Newsletters, bulletins, and serial publications stored as documents |
+| **Standard** | `standard` | `CreativeWork` | `"Standard"` | — (Type → `isPartOf`) | Technical standards, specifications, protocols, standards documents. The Type field names the standard's series (`isPartOf` → `CreativeWorkSeries`); the standard number maps to an `identifier`. |
+
+### Legend
+
+- **Zotero Item Type**: The classification used in Zotero's item type selector
+- **CSL Type**: The type value in CSL JSON output from Zotero API
+- **Schema.org @type**: The `@type` field in generated JSON-LD
+- **additionalType**: Optional `additionalType` field in JSON-LD for additional classification
+- **genre**: Optional `genre` field in JSON-LD for the entry's genre
+
+---
+
+## Type Categories and Use Cases
+
+### Publishing Types (Peer-Reviewed and Published)
+
+These types are for published, citable research and writing:
+
+- **Journal Article** (`article-journal`): Peer-reviewed journal papers, conference proceedings published in journals
+- **Magazine Article** (`article-magazine`): Trade magazines, popular science magazines
+- **Newspaper Article** (`article`): Newspaper articles and news publications
+- **Conference Paper** (`paper-conference`): Conference proceedings and papers
+- **Book** (`book`): Published books and monographs
+- **Book Section** (`chapter`): Chapters within books
+- **Thesis** (`thesis`): Academic theses and dissertations
+
+### Technical and Professional Types
+
+- **Report** (`report`): Technical reports, working papers, government reports, internal documentation
+- **Patent** (`patent`): Patents and patent applications
+- **Encyclopedia Entry** (`entry-encyclopedia`): Reference works and encyclopedia entries
+- **Standard** (`standard`): Technical standards, protocols, standardization documents
+
+### Documentary Types
+
+- **Document** (`document`): Broad category for technical documentation, user guides, specifications, manuals
+  - The Zotero **Type** field distinguishes subcategories within this item type. For an oral-history interview — a written document recording a conversation between an interviewer and an interviewee — set the Type field to `Transcript`. Its schema.org mapping is `additionalType: "Transcript"` with `genre: "Transcript"`.
+  - Other Type values are carried through to the Schema.org `genre` property. For example, a document with a Type of `Newsletter` maps to `genre: "Newsletter"`.
+- **Standard** (`standard`): The Zotero **Type** field names the standard's series or designation (for example, `Xerox System Integration Standard`), which maps to `isPartOf` → `CreativeWorkSeries`. The entry's `@type` is `CreativeWork` with `additionalType: "Standard"`, and the standard number is emitted as a `PropertyValue` identifier.
+
+### Digital and Media Types
+
+- **Webpage** (`webpage`): Web pages, online resources, digital articles
+- **Blog Post** (`post-weblog`): Blog entries and web logs
+- **Film** (`motion_picture`): Videos, films, recorded presentations, documentaries
+- **Computer Program** (`software`): Software repositories, source code, applications, development tools. The Zotero **Type** field names the programming language, which maps to the Schema.org `programmingLanguage` property.
+
+### Personal Communication
+
+- **Email** (`personal_communication`): Emails, letters, personal correspondence
+
+---
+
+## For Content Creators
+
+### Choosing the Right Type
+
+When adding an entry to the Interlisp Zotero group:
+
+1. **Select the most specific Zotero item type** that matches your entry
+   - Use `Journal Article` for peer-reviewed journal papers
+   - Use `Conference Paper` for conference proceedings (not in a journal)
+   - Use `Report` for technical reports and internal documentation
+   - Use `Document` only when no other type fits (broad catch-all)
+
+2. **Fill in the Type field** for the item types that use it
+   - `Document`: the kind of document. Use `Transcript` for an oral-history interview.
+   - `Standard`: the standard's series or designation
+   - `Computer Program`: the programming language
+
+3. **Verify your schema.org mapping** by checking this reference table
+
+### Example: Choosing Between Report and Document
+
+| Aspect | Report | Document |
+|--------|--------|----------|
+| **Best for** | Published technical reports, working papers | User manuals, specifications, guides |
+| **Publisher info available** | Usually yes | Often no |
+| **Formal publication** | Yes, often | Rarely |
+| **Organization issuing** | Clear (government, company, academic) | May be vague |
+| **Use when** | Official documentation with publication date | In-house documentation, unpublished guides |
+
+---
+
+## For Developers
+
+### Processing Pipeline
+
+The bibliography processing pipeline:
+
+1. **Fetches data** from the Zotero API (v3) for group 2914042
+2. **Extracts** the Zotero itemType and the CSL JSON type
+3. **Generates markdown frontmatter** via `bibSplit.pl` (uses the CSL type)
+4. **Generates JSON-LD** via the `bibliography-json-ld.html` partial (maps the CSL type to schema.org)
+5. **Publishes** markdown files and embedded JSON-LD to the website
+
+The CSL JSON type is the entry's type of record. The Zotero **Type** field is a separate thing: it is a generic classification field whose meaning depends on the item type, and Zotero's CSL export maps it to the CSL `genre` field. It never names the entry's type.
+
+### Current Type Handling
+
+See `layouts/_partials/bibliography-json-ld.html` for the active type mappings:
+
+```go
+{{- if eq $itemType "article-journal" -}}{{- $schemaType = "ScholarlyArticle" -}}
+{{- else if eq $itemType "book" -}}{{- $schemaType = "Book" -}}
+{{- else if eq $itemType "chapter" -}}{{- $schemaType = "Chapter" -}}
+// ... etc
+```
+
+### Adding New Types
+
+To add a type:
+
+1. Add a type handler in `scripts/bibSplit.pl` (the `$type` branch chain, line ~146) so the pipeline emits it
+2. Add the @type mapping in `layouts/_partials/bibliography-json-ld.html` (line ~25)
+3. Add an `additionalType` assignment if the type needs further refinement (line ~124)
+4. Add a test fixture under `tests/fixtures/bibliography/` and register its slug in `tests/conftest.py`
+5. Add a test class in `tests/test_bibliography_jsonld.py`
+6. Update this reference table and `docs/bibliography-schema.md`
+
+### Known Issues
+
+See `docs/bibliography-schema.md` for known issues and limitations in bibliography processing.
+
+---
+
+## Schema.org Vocabulary Notes
+
+### CreativeWork Hierarchy
+
+Several types map to the generic `CreativeWork` in schema.org:
+
+- `patent` → `CreativeWork` (with `additionalType: "Patent"`)
+- `document` → `CreativeWork` (with `additionalType: "TechnicalDocumentation"`)
+- `document` with a `Transcript` type → `CreativeWork` (with `additionalType: "Transcript"`)
+- `standard` → `CreativeWork` (with `additionalType: "Standard"`)
+
+This hierarchy allows search engines to understand that these are creative works while providing additional specificity through `additionalType`.
+
+### Why Not More Specific Types?
+
+Schema.org has no native types for:
+- Generic "documents"
+- Transcripts (unless linked to media)
+- Technical standards (as standalone documents)
+- General software (though `SoftwareSourceCode` is specific)
+
+Using `CreativeWork` with `additionalType` is the recommended schema.org pattern for these cases. Schema.org's `additionalType` documentation permits text values "sparingly, for cases where useful information can be added without their being an appropriate schema to reference", with the class label following the schema.org style guide.
+
+### The genre Property
+
+Schema.org's `genre` property ("Genre of the creative work") is the natural home for an entry's genre, and it is where the Zotero **Type** field is carried for `Document` entries. Both are used together for transcripts: `additionalType` states that the work is a transcript, while `genre` records the classification in schema.org's first-class slot.
+
+The Zotero **Type** field is generic, so its meaning depends on the item type, and so does its schema.org destination:
+
+| Zotero item type | Type field contains | Expressed in schema.org as |
+|---|---|---|
+| `Document` | the kind of document, e.g. `Transcript` | `genre`; `additionalType` is always set (`TechnicalDocumentation`, or `Transcript`) |
+| `Standard` | the standard's series or designation | `isPartOf` → `CreativeWorkSeries` |
+| `Computer Program` | the programming language | `programmingLanguage` |
+| `Report` | the report type | `additionalType` |
+| `Thesis` | the degree type | not currently mapped |
+| `Webpage` | the kind of site, e.g. `Blog` | not currently mapped (`website_type` is frontmatter only) |
+
+---
+
+## Troubleshooting
+
+### Entry Not Appearing with Expected Type
+
+1. **Check CSL JSON output**: Run `scripts/update_bibliography.sh` and examine the raw JSON for your entry's `type` field
+2. **Verify mapping**: Check that the CSL type appears in the table above
+3. **Check the Type field**: The CSL type is authoritative. A `type` value that looks like a genre word (for example `Transcript` or `Newsletter`) rather than a CSL type means the merge-precedence defect in `bib-fns.jq` (`semiflatten`) has regressed — the Zotero **Type** field must never overwrite the CSL type
+4. **Report missing type**: If type is in CSL JSON but not in table, file an issue
+
+### JSON-LD Validation Errors
+
+1. **Use Google Structured Data Testing Tool** to validate: https://search.google.com/structured-data/testing-tool
+2. **Check schema.org** for @type requirements: https://schema.org/
+3. **Review generated HTML** in browser DevTools (JSON-LD is embedded in `<script type="application/ld+json">`)
+
+---
+
+## References
+
+- [Zotero Item Types](https://www.zotero.org/support/kb/item_types)
+- [CSL JSON Schema](https://citeproc-js.readthedocs.io/en/latest/csl-json/markup.html)
+- [Schema.org Types](https://schema.org/Thing)
+- [Schema.org CreativeWork](https://schema.org/CreativeWork)
+- [Schema.org additionalType](https://schema.org/additionalType)
+- [Schema.org genre](https://schema.org/genre)
+- [Structured Data Best Practices](https://developers.google.com/search/docs/beginner/structured-data)
+
+## Related Documentation
+
+- [Interlisp Bibliography Intake Guide](../intake/) – How to recommend a new bibliography item
+- `docs/bibliography-schema.md` – Technical details of the bibliography processing system (repository source)
diff --git a/layouts/_partials/bibliography-json-ld.html b/layouts/_partials/bibliography-json-ld.html
index e353ed8d..9b39f679 100644
--- a/layouts/_partials/bibliography-json-ld.html
+++ b/layouts/_partials/bibliography-json-ld.html
@@ -35,6 +35,8 @@
 {{- else if eq $itemType "motion_picture"         -}}{{- $schemaType = "VideoObject"        -}}
 {{- else if eq $itemType "entry-encyclopedia"     -}}{{- $schemaType = "Article"            -}}
 {{- else if eq $itemType "personal_communication" -}}{{- $schemaType = "Message"            -}}
+{{- else if eq $itemType "document"               -}}{{- $schemaType = "CreativeWork"       -}}
+{{- else if eq $itemType "standard"               -}}{{- $schemaType = "CreativeWork"       -}}
 {{- else if eq $itemType "software"               -}}{{- $schemaType = "SoftwareSourceCode" -}}
 {{- end -}}
 
@@ -142,6 +144,39 @@
   {{- end -}}
 {{- end -}}
 
+{{- /* ── Document / Standard / Software: genre-driven refinement ─────── */ -}}
+{{- $genre := .Params.genre | default "" | strings.TrimSpace | lower -}}
+
+{{- if eq $itemType "document" -}}
+  {{- if eq $genre "transcript" -}}
+    {{- $ld = merge $ld (dict "additionalType" "Transcript" "genre" "Transcript") -}}
+  {{- else -}}
+    {{- $ld = merge $ld (dict "additionalType" "TechnicalDocumentation") -}}
+    {{- with .Params.genre -}}{{- $ld = merge $ld (dict "genre" .) -}}{{- end -}}
+  {{- end -}}
+{{- end -}}
+
+{{- if eq $itemType "standard" -}}
+  {{- $ld = merge $ld (dict "additionalType" "Standard") -}}
+  {{- with .Params.genre -}}
+    {{- $ld = merge $ld (dict "isPartOf" (dict "@type" "CreativeWorkSeries" "name" .)) -}}
+  {{- end -}}
+  {{- with .Params.standard_number -}}
+    {{- $ld = merge $ld (dict "identifier" (dict "@type" "PropertyValue" "propertyID" "standard-number" "value" .)) -}}
+  {{- end -}}
+{{- end -}}
+
+{{- if eq $itemType "software" -}}
+  {{- with .Params.genre -}}{{- $ld = merge $ld (dict "programmingLanguage" .) -}}{{- end -}}
+{{- end -}}
+
+{{- /* ── Publisher for types that carry it ───────────────────────────── */ -}}
+{{- if or (eq $itemType "document") (eq $itemType "standard") (eq $itemType "software") -}}
+  {{- with .Params.publisher -}}
+    {{- $ld = merge $ld (dict "publisher" (dict "@type" "Organization" "name" .)) -}}
+  {{- end -}}
+{{- end -}}
+
 {{- /* ── Journal / Magazine article ────────────────────────────────────── */ -}}
 {{- if or (eq $itemType "article-journal") (eq $itemType "article-magazine") -}}
   {{- with .Params.publication_title -}}
diff --git a/layouts/bibliography/single.html b/layouts/bibliography/single.html
index 7f6a0a9b..37d64cfe 100644
--- a/layouts/bibliography/single.html
+++ b/layouts/bibliography/single.html
@@ -94,10 +94,10 @@ <h1>{{ .Title }}</h1>
         {{ with .Params.publisher }}
             <p><strong>Publisher:</strong> {{ . }}</p>
         {{ end }}
-        {{ with .Params.reportType }}
+        {{ with .Params.report_type }}
             <p><strong>Report Type:</strong> {{ . }}</p>
         {{ end }}
-        {{ with .Params.reportNumber }}
+        {{ with .Params.report_number }}
             <p><strong>Report Number:</strong> {{ . }}</p>
         {{ end }}
     {{- end -}}
@@ -187,6 +187,42 @@ <h1>{{ .Title }}</h1>
             <p><strong>Encyclopedia Title:</strong> {{ . }}</p>
         {{ end }}
     {{- end -}}
+    {{- if eq .Params.item_type "document" }}
+        {{ with .Params.genre }}
+            <p><strong>Document Type:</strong> {{ . }}</p>
+        {{ end }}
+        {{ with .Params.publisher }}
+            <p><strong>Publisher:</strong> {{ . }}</p>
+        {{ end }}
+        {{ with .Params.place }}
+            <p><strong>Place:</strong> {{ . }}</p>
+        {{ end }}
+    {{- end -}}
+    {{- if eq .Params.item_type "standard" }}
+        {{ with .Params.genre }}
+            <p><strong>Series:</strong> {{ . }}</p>
+        {{ end }}
+        {{ with .Params.standard_number }}
+            <p><strong>Standard Number:</strong> {{ . }}</p>
+        {{ end }}
+        {{ with .Params.standard_version }}
+            <p><strong>Version:</strong> {{ . }}</p>
+        {{ end }}
+        {{ with .Params.publisher }}
+            <p><strong>Publisher:</strong> {{ . }}</p>
+        {{ end }}
+        {{ with .Params.place }}
+            <p><strong>Place:</strong> {{ . }}</p>
+        {{ end }}
+    {{- end -}}
+    {{- if eq .Params.item_type "software" }}
+        {{ with .Params.genre }}
+            <p><strong>Programming Language:</strong> {{ . }}</p>
+        {{ end }}
+        {{ with .Params.publisher }}
+            <p><strong>Publisher:</strong> {{ . }}</p>
+        {{ end }}
+    {{- end -}}
   </div>
   <p>
     {{- if .Params.url_source -}}
diff --git a/scripts/bib-fns.jq b/scripts/bib-fns.jq
index 1ba4d41d..97922d00 100644
--- a/scripts/bib-fns.jq
+++ b/scripts/bib-fns.jq
@@ -145,11 +145,25 @@ def getNeededUrls:  # assumes that array of all current items is the input
 #     | $x - ($x - y)
 #   end;
   
+# The CSL JSON block is the authoritative citation record; the Zotero `data`
+# block is metadata.  Merging with `.data` on the right let a populated Zotero
+# field silently overwrite the CSL one:
+#
+#   * data.type    -> Zotero's generic "Type" field (UI label "Type"), which
+#                     Zotero's CSL export maps to `genre`.  It is NOT the CSL
+#                     type, and it overwrote `csljson.type`.
+#   * data.version -> Zotero's *record revision counter*, not citation data.
+#                     It overwrote `csljson.version` (edition / standard
+#                     version) and leaked into all 380 records.
+#
+# Merge so CSL JSON wins, and drop the record revision entirely.
 def semiflatten:  # assumes that only one item is the input
     . as $item
-  | (keys - ["csljson","data"]) as $topKeys
-  | ((.csljson // {}) * .data) as $inner
-  | (($inner | keys) - ["key","version"]) as $innerKeys
+  | (.csljson // {}) as $csl
+  | (.data // {} | del(.version)) as $data
+  | (keys - ["csljson","data","version"]) as $topKeys
+  | ($data * $csl) as $inner
+  | (($inner | keys) - ["key"]) as $innerKeys
   | (  ($topKeys | map(. as $tKey | {"key": $tKey, "value": ($item | getpath([$tKey]))}))
      + ($innerKeys | map(. as $iKey | {"key": $iKey, "value": ($inner | getpath([$iKey]))})) )
   | from_entries;
diff --git a/scripts/bibSplit.pl b/scripts/bibSplit.pl
index d5cefcea..22640e43 100755
--- a/scripts/bibSplit.pl
+++ b/scripts/bibSplit.pl
@@ -116,6 +116,7 @@ sub sanitize_text {
   my $conferenceName = defined $obj->{conferenceName} ? qq{"$obj->{conferenceName}"} : '""';
   my $encyclopediaTitle = defined $obj->{encyclopediaTitle} ? qq{"$obj->{encyclopediaTitle}"} : '""';
   my $filingDate = defined $obj->{filingDate} ? qq{"$obj->{filingDate}"} : '""';
+  my $genre = defined $obj->{genre} ? qq{"$obj->{genre}"} : '""';
   my $issue = defined $obj->{issue} ? qq{"$obj->{issue}"} : '""';
   my $issueDate = defined $obj->{issueDate} ? qq{"$obj->{issueDate}"} : '""';
   my $issuingAuthority = defined $obj->{issuingAuthority} ? qq{"$obj->{issuingAuthority}"} : '""';
@@ -132,6 +133,8 @@ sub sanitize_text {
   my $series = defined $obj->{series} ? qq{"$obj->{series}"} : '""';
   my $seriesNumber = defined $obj->{seriesNumber} ? qq{"$obj->{seriesNumber}"} : '""';
   my $seriesTitle = defined $obj->{seriesTitle} ? qq{"$obj->{seriesTitle}"} : '""';
+  my $standardNumber = defined $obj->{number} ? qq{"$obj->{number}"} : '""';
+  my $standardVersion = defined $obj->{version} ? qq{"$obj->{version}"} : '""';
   my $studio = defined $obj->{studio} ? qq{"$obj->{studio}"} : '""';
   my $university = defined $obj->{university} ? qq{"$obj->{university}"} : '""';
   my $videoRecordingFormat = defined $obj->{videoRecordingFormat} ? qq{"$obj->{videoRecordingFormat}"} : '""';
@@ -166,6 +169,12 @@ sub sanitize_text {
   $extraFields = "website_title: $websiteTitle\nwebsite_type: $websiteType\n";
   } elsif ($type eq 'entry-encyclopedia') {
     $extraFields = "encyclopedia_title: $encyclopediaTitle\n";
+  } elsif ($type eq 'document') {
+    $extraFields = "genre: $genre\npublisher: $publisher\nplace: $place\n";
+  } elsif ($type eq 'standard') {
+    $extraFields = "genre: $genre\npublisher: $publisher\nplace: $place\nstandard_number: $standardNumber\nstandard_version: $standardVersion\n";
+  } elsif ($type eq 'software') {
+    $extraFields = "genre: $genre\npublisher: $publisher\n";
   } else {
     print STDERR "Warning: unhandled type \"$type\" for key \"$key\"\n";
   }
diff --git a/scripts/update_bibliography.sh b/scripts/update_bibliography.sh
index 2e27a367..9768e77a 100755
--- a/scripts/update_bibliography.sh
+++ b/scripts/update_bibliography.sh
@@ -172,7 +172,7 @@ while true; do
             rawItemsFile=true
             shift
             ;;
-        -d|--debug)
+        -d|--debugfiles)
             debugFiles=true
             shift
             ;;
diff --git a/tests/conftest.py b/tests/conftest.py
index b90beda7..5278747a 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -49,6 +49,9 @@
     "ztest-software",
     "ztest-encyclopedia",
     "ztest-message",
+    "ztest-document",
+    "ztest-transcript",
+    "ztest-standard",
     "ztest-no-urls",
 )
 
diff --git a/tests/fixtures/bibliography/ZTEST-DOCUMENT.md b/tests/fixtures/bibliography/ZTEST-DOCUMENT.md
new file mode 100644
index 00000000..56ee23a9
--- /dev/null
+++ b/tests/fixtures/bibliography/ZTEST-DOCUMENT.md
@@ -0,0 +1,22 @@
+---
+title: "Test Document"
+date: 1998-07-04
+readabledate: 1998-07-04
+type: bibliography
+item_type: document
+authors:
+  - "Writer, Test"
+editors:
+abstract: |
+  A test abstract for a document entry used by automated test fixtures.
+
+genre: ""
+publisher: "Test Documentation Office"
+place: ""
+
+tags:
+url_source: "https://example.com/document"
+zotero_url: "https://www.zotero.org/groups/test/items/ZTESTDOC"
+
+lastmod: 2023-09-01T00:00:00Z
+---
diff --git a/tests/fixtures/bibliography/ZTEST-REPORT.md b/tests/fixtures/bibliography/ZTEST-REPORT.md
index 9cad7896..e425c4c5 100644
--- a/tests/fixtures/bibliography/ZTEST-REPORT.md
+++ b/tests/fixtures/bibliography/ZTEST-REPORT.md
@@ -11,6 +11,8 @@ abstract: |
   A test abstract for a technical report used by automated test fixtures.
 
 publisher: "Test Research Lab"
+report_type: "Test Report Type"
+report_number: "TR-2005-001"
 
 tags:
 url_source: "https://example.com/report"
diff --git a/tests/fixtures/bibliography/ZTEST-SOFTWARE.md b/tests/fixtures/bibliography/ZTEST-SOFTWARE.md
index c0ab51dc..d418e111 100644
--- a/tests/fixtures/bibliography/ZTEST-SOFTWARE.md
+++ b/tests/fixtures/bibliography/ZTEST-SOFTWARE.md
@@ -11,6 +11,8 @@ editors:
 abstract: |
   A test abstract for a software entry used by automated test fixtures.
 
+genre: "TestLang"
+
 tags:
 url_source: "https://github.com/example/test-software"
 zotero_url: "https://www.zotero.org/groups/test/items/ZTESTSOFT"
diff --git a/tests/fixtures/bibliography/ZTEST-STANDARD.md b/tests/fixtures/bibliography/ZTEST-STANDARD.md
new file mode 100644
index 00000000..da9502e0
--- /dev/null
+++ b/tests/fixtures/bibliography/ZTEST-STANDARD.md
@@ -0,0 +1,23 @@
+---
+title: "Test Character Code Standard"
+date: 1990-06-01
+readabledate: 1990-06
+type: bibliography
+item_type: standard
+authors:
+editors:
+abstract: |
+  A test abstract for a standard entry used by automated test fixtures.
+
+genre: "Test System Integration Standard"
+publisher: "Test Standards Institute"
+place: "Testville, CA, USA"
+standard_number: "TSTD 059003"
+standard_version: "2.0"
+
+tags:
+url_source: "https://example.com/standard"
+zotero_url: "https://www.zotero.org/groups/test/items/ZTESTSTD"
+
+lastmod: 2023-09-03T00:00:00Z
+---
diff --git a/tests/fixtures/bibliography/ZTEST-TRANSCRIPT.md b/tests/fixtures/bibliography/ZTEST-TRANSCRIPT.md
new file mode 100644
index 00000000..8b32a967
--- /dev/null
+++ b/tests/fixtures/bibliography/ZTEST-TRANSCRIPT.md
@@ -0,0 +1,22 @@
+---
+title: "Test Oral History Transcript"
+date: 2020-02-17
+readabledate: 2020-02-17
+type: bibliography
+item_type: document
+authors:
+  - "Interviewee, Test"
+editors:
+abstract: |
+  A test abstract for a transcript entry used by automated test fixtures.
+
+genre: "Transcript"
+publisher: "Test Oral History Institute"
+place: ""
+
+tags:
+url_source: "https://example.com/transcript"
+zotero_url: "https://www.zotero.org/groups/test/items/ZTESTTRANS"
+
+lastmod: 2023-09-02T00:00:00Z
+---
diff --git a/tests/test_bibliography_jsonld.py b/tests/test_bibliography_jsonld.py
index 0bb5803f..18dc5fe7 100644
--- a/tests/test_bibliography_jsonld.py
+++ b/tests/test_bibliography_jsonld.py
@@ -39,6 +39,9 @@
     ZTEST-SOFTWARE.md     software              → SoftwareSourceCode
     ZTEST-ENCYCLOPEDIA.md entry-encyclopedia    → Article
     ZTEST-MESSAGE.md      personal_communication → Message
+    ZTEST-DOCUMENT.md     document              → CreativeWork (+TechnicalDocumentation)
+    ZTEST-TRANSCRIPT.md   document (Transcript) → CreativeWork (+Transcript)
+    ZTEST-STANDARD.md     standard              → CreativeWork (+Standard)
     ZTEST-NO-URLS.md      report (no URLs)      → edge-case fixture
 
 Usage
@@ -416,6 +419,15 @@ def test_base_fields(self):
     def test_publisher(self):
         _assert_org(self.ld["publisher"], "Test Research Lab")
 
+    def test_report_type_additional_type(self):
+        assert self.ld["additionalType"] == "Test Report Type"
+
+    def test_report_number_identifier(self):
+        ident = self.ld["identifier"]
+        assert ident["@type"] == "PropertyValue"
+        assert ident["propertyID"] == "report-number"
+        assert ident["value"] == "TR-2005-001"
+
     def test_author(self):
         authors = self.ld["author"]
         assert len(authors) == 1
@@ -557,7 +569,8 @@ class TestSoftwareSourceCode:
     """software → SoftwareSourceCode.  Fixture: ZTEST-SOFTWARE.md
 
     Also exercises the single-name (no comma) author edge case via the
-    "Singularity" entry, which must produce only a ``name`` key.
+    "Singularity" entry, which must produce only a ``name`` key, and the
+    Zotero "Type" field (``genre``) surfacing as ``programmingLanguage``.
     """
 
     @pytest.fixture(autouse=True)
@@ -567,6 +580,10 @@ def ld(self):
     def test_base_fields(self):
         _assert_base(self.ld, "SoftwareSourceCode", "Test Software")
 
+    def test_programming_language_from_genre(self):
+        """Zotero's Type field (genre) becomes programmingLanguage."""
+        assert self.ld["programmingLanguage"] == "TestLang"
+
     def test_author_count(self):
         assert len(self.ld["author"]) == 2
 
@@ -616,6 +633,98 @@ def test_author(self):
         _assert_person(authors[0], "Test Sender", family="Sender", given="Test")
 
 
+class TestDocument:
+    """document (no genre) → CreativeWork + additionalType TechnicalDocumentation.
+    Fixture: ZTEST-DOCUMENT.md
+    """
+
+    @pytest.fixture(autouse=True)
+    def ld(self):
+        self.ld = _load_jsonld("ztest-document")
+
+    def test_base_fields(self):
+        _assert_base(self.ld, "CreativeWork", "Test Document")
+
+    def test_additional_type_is_technical_documentation(self):
+        assert self.ld["additionalType"] == "TechnicalDocumentation"
+
+    def test_no_genre(self):
+        """An empty genre must not emit a genre key."""
+        assert "genre" not in self.ld
+
+    def test_publisher(self):
+        _assert_org(self.ld["publisher"], "Test Documentation Office")
+
+    def test_author(self):
+        authors = self.ld["author"]
+        assert len(authors) == 1
+        _assert_person(authors[0], "Test Writer", family="Writer", given="Test")
+
+
+class TestTranscript:
+    """document + genre Transcript → CreativeWork + additionalType Transcript.
+    Fixture: ZTEST-TRANSCRIPT.md
+    """
+
+    @pytest.fixture(autouse=True)
+    def ld(self):
+        self.ld = _load_jsonld("ztest-transcript")
+
+    def test_base_fields(self):
+        _assert_base(self.ld, "CreativeWork", "Test Oral History Transcript")
+
+    def test_additional_type_is_transcript(self):
+        assert self.ld["additionalType"] == "Transcript"
+
+    def test_genre_is_transcript(self):
+        assert self.ld["genre"] == "Transcript"
+
+    def test_publisher(self):
+        _assert_org(self.ld["publisher"], "Test Oral History Institute")
+
+    def test_not_technical_documentation(self):
+        """The transcript refinement must replace, not duplicate, the default."""
+        assert self.ld["additionalType"] != "TechnicalDocumentation"
+
+
+class TestStandard:
+    """standard → CreativeWork + additionalType Standard.
+    Fixture: ZTEST-STANDARD.md
+
+    The Zotero Type field (genre) names the standard's series and maps to
+    isPartOf → CreativeWorkSeries; the standard number becomes a PropertyValue
+    identifier.
+    """
+
+    @pytest.fixture(autouse=True)
+    def ld(self):
+        self.ld = _load_jsonld("ztest-standard")
+
+    def test_base_fields(self):
+        _assert_base(self.ld, "CreativeWork", "Test Character Code Standard")
+
+    def test_additional_type_is_standard(self):
+        assert self.ld["additionalType"] == "Standard"
+
+    def test_is_part_of_creative_work_series(self):
+        series = self.ld["isPartOf"]
+        assert series["@type"] == "CreativeWorkSeries"
+        assert series["name"] == "Test System Integration Standard"
+
+    def test_standard_number_identifier(self):
+        ident = self.ld["identifier"]
+        assert ident["@type"] == "PropertyValue"
+        assert ident["propertyID"] == "standard-number"
+        assert ident["value"] == "TSTD 059003"
+
+    def test_publisher(self):
+        _assert_org(self.ld["publisher"], "Test Standards Institute")
+
+    def test_genre_is_not_top_level(self):
+        """For standards the genre becomes isPartOf, not a top-level genre."""
+        assert "genre" not in self.ld
+
+
 class TestCollectionPage:
     """The bibliography section index emits CollectionPage + ItemList JSON-LD."""
 
diff --git a/tests/test_bibliography_page.py b/tests/test_bibliography_page.py
new file mode 100644
index 00000000..54185f3f
--- /dev/null
+++ b/tests/test_bibliography_page.py
@@ -0,0 +1,81 @@
+"""
+tests/test_bibliography_page.py
+===============================
+Validates the ``div.bibliography-meta`` block rendered by
+``layouts/bibliography/single.html`` for the entry types added by the
+bibliography-types implementation (``document``, ``standard``, ``software``)
+and for the ``report`` key fix.
+
+``test_bibliography_jsonld.py`` covers the structured-data contract; this
+module checks that the same frontmatter values are visible on the page.  The
+session-scoped ``hugo_build`` fixture in ``conftest.py`` builds the
+``--environment testing`` site, so all assertions run against the ``ZTEST-*``
+fixtures and never touch production content.
+"""
+
+from __future__ import annotations
+
+import re
+
+import pytest
+
+from conftest import BIB_PUBLIC
+
+pytestmark = pytest.mark.usefixtures("hugo_build")
+
+
+def _meta_text(slug: str) -> str:
+    """Return the entry's metadata block as whitespace-normalised plain text."""
+    path = BIB_PUBLIC / slug / "index.html"
+    assert path.is_file(), f"missing built page: {path}"
+    html = path.read_text(encoding="utf-8")
+    match = re.search(r'<div class="bibliography-meta">(.*?)</div>', html, re.S)
+    assert match, f"no bibliography-meta block in {path}"
+    return re.sub(r"\s+", " ", re.sub(r"<[^>]+>", " ", match.group(1))).strip()
+
+
+@pytest.mark.parametrize(
+    ("slug", "expected"),
+    [
+        # Document with no Zotero Type: publisher only, no genre line.
+        ("ztest-document", ("Publisher: Test Documentation Office",)),
+        # Transcript: the genre is surfaced as the document type.
+        (
+            "ztest-transcript",
+            (
+                "Document Type: Transcript",
+                "Publisher: Test Oral History Institute",
+            ),
+        ),
+        # Standard: series, number, version, publisher and place all render.
+        (
+            "ztest-standard",
+            (
+                "Series: Test System Integration Standard",
+                "Standard Number: TSTD 059003",
+                "Version: 2.0",
+                "Publisher: Test Standards Institute",
+                "Place: Testville, CA, USA",
+            ),
+        ),
+        # Software: Zotero Type becomes the programming language.
+        ("ztest-software", ("Programming Language: TestLang",)),
+        # Report: regression guard for the snake_case key fix.
+        (
+            "ztest-report",
+            (
+                "Report Type: Test Report Type",
+                "Report Number: TR-2005-001",
+            ),
+        ),
+    ],
+)
+def test_metadata_block(slug: str, expected: tuple[str, ...]) -> None:
+    text = _meta_text(slug)
+    for fragment in expected:
+        assert fragment in text, f"{slug}: expected {fragment!r} in {text!r}"
+
+
+def test_document_without_genre_omits_type_line() -> None:
+    """An empty ``genre`` must not render an empty 'Document Type' line."""
+    assert "Document Type:" not in _meta_text("ztest-document")
diff --git a/tests/test_content_integrity.py b/tests/test_content_integrity.py
index 1d627224..35edf954 100644
--- a/tests/test_content_integrity.py
+++ b/tests/test_content_integrity.py
@@ -63,6 +63,7 @@
     "entry-encyclopedia",
     "personal_communication",
     "document",
+    "standard",
     "manuscript",
     "hearing",
     "artwork",
@@ -73,7 +74,6 @@
     "legal_case",
     "newspaper-article",
     "dictionary-entry",
-    "Xerox System Integration Standard",
 })