Read-Only Document Distribution

Lectern

Every document, exactly as published.

Explore Features

Screenshots

See It in Action

Lectern Library view — a hero-card grid of documents with a collection tree sidebar

Library — every document in the corpus, hero-card grid, collection tree, type badges, and dates

Lectern Library view — a hero-card grid of documents with a collection tree sidebar
Library
Lectern document viewer showing a rendered artifact with version picker and download controls
Document Viewer
Lectern search results page showing full-text search matches across the document corpus
Search

Features

Read Anything. Rewrite Nothing.

Lectern is the fleet's secure distribution surface for finished AVIAN/Renkara documents — HTML artifacts, Markdown, and PDFs served in artifact format to authenticated renkara-auth users, from a locked-down S3 bucket, with a per-view audit trail. Publishing happens only from the founder's workstation via CLI or MCP. The reader app has no write path and no edit affordance, anywhere, by design.

The Three Laws

Read-Only, Immutable, Byte-Identical

  • Zero Write Path on the Reader Surface

    No content-mutation endpoint, no edit/upload/annotate affordance — anywhere in the UI, under any framing. Publishing lives exclusively behind an admin-key-gated API reachable only from the founder's workstation.

  • Content-Addressed, Immutable Versions

    Every version's storage key is derived from its own sha256 hash. S3 objects are never overwritten; versions are append-only. A document is retired, never deleted — there is no hard-delete anywhere in the lifecycle.

  • Byte-Identical Artifact Passthrough

    HTML artifacts are served exactly as published, sha256-verified against the source. Lectern never “fixes,” reformats, or rewrites a published file — fidelity is structural, not a promise.

Secure by Construction

Sandboxed Rendering, Full Audit Trail

  • Blob-Sandboxed Artifact Viewer

    Every document renders inside an <iframe sandbox="allow-scripts"> built from a Blob URL — never allow-same-origin. The same containment model claude.ai uses for artifacts: scripts run, but with zero access to the reader's token, cookies, or parent DOM.

  • renkara-auth Single Sign-On

    Every reader signs in through the fleet's shared OIDC provider. There is no separate Lectern account and no separate password to manage.

  • Audience-Restricted Access

    Documents and whole collection subtrees can be scoped to a named audience. One shared visibility predicate governs the catalog, search, and content fetch alike — there's no separate code path for a restriction to leak through.

  • Per-View Audit Trail

    Every content view, raw download, and search query writes an attributed, append-only audit event — who read what, and when, queryable by any admin.

Built to Be Read

Self-Contained Artifacts, Real Search

  • Self-Contained Rendering

    Markdown renders to a fully self-contained artifact: inlined CSS, Pygments-highlighted code in both themes, embedded images, and client-side Mermaid diagrams — zero external requests at view time.

  • Full-Text Search

    Postgres full-text search across every visible document's title, tags, and extracted body text — not just filenames.

  • Collection Tree & Deep Links

    Browse a nested collection hierarchy in a drawer sidebar, or jump straight to any document via a stable /d/<slug> link.

  • Hero Thumbnails

    Every Library card carries a real screenshot of its document, captured automatically in headless Chromium the moment it publishes.

  • Light and Dark Mode

    The reader, and every rendered artifact inside it, follows the app's theme — the viewer stamps the active theme into the document before it ever renders.

Publishing — Workstation Only

One Write Path, Fully Auditable

  • CLI & MCP Publishing

    lectern_publish.py and the MCP tool suite are the only ways content enters the system — both are thin wrappers over the identical admin API, so the two lanes can never drift apart.

  • Idempotent Corpus Sync

    Re-running a sync against an unchanged source reports 100% unchanged. Nothing republishes, and no new version is created, unless the content actually changed.

  • Rollback, Retire, Restore

    Every mutation is reversible without ever deleting a version row or an S3 object — point the current version at an older one, retire a document from the catalog, or restore it, all non-destructively.

Integration

MCP Server — 38 Tools

  • Health & Ops (4 tools)

    Liveness, structured subsystem diagnostics, storage stats, and recent sync/publish-run status — without leaving the AI assistant.

  • Reading & Search (9 tools)

    Browse the collection tree, list and fetch documents, pull rendered content or plain-text extracts, and run full-text search — the same corpus a human sees in the reader.

  • Publishing & Governance (17 tools)

    Publish single files or whole batches, retire/restore/rollback, manage collections and audiences, and mint share links — the complete write surface, admin-key gated.

  • Audit & Integrity (5 tools)

    Query the access log, pull per-document view analytics, re-hash S3 against the registry to catch drift, and rebuild the search index — all from a Claude Code session.

  • Admin Reporting UI

    Read-only History and Analytics pages, visible only to admins, backed by the exact same query logic as the CLI/MCP lane — the browser and the machine can never see different numbers.

Accessibility

Built for Everyone

  • WCAG 2.1 AA Compliance

    4.5:1 contrast for body text, 3:1 for large text and UI components, in both light and dark themes.

  • Keyboard Navigation

    Every interaction reachable via keyboard. Logical tab order, visible focus indicators, Escape-to-dismiss for modals.

  • Screen Reader Support

    VoiceOver, NVDA, and JAWS tested. Semantic HTML, ARIA labels, live regions for dynamic updates.

  • Reduced Motion

    Respects prefers-reduced-motion. Usable at 200% zoom. Touch targets meet 44x44 minimum.

How It Works

Publish, Sign In, Read, Audit

  1. Step 1: Publish

    The founder runs the CLI or an MCP tool from the workstation. Content is rendered, hashed, and uploaded to a private, KMS-encrypted S3 bucket — the only write path in the whole system.

  2. Step 2: Sign In

    A renkara-auth user logs in through the fleet's shared OIDC flow. No separate Lectern account, no separate password.

  3. Step 3: Read

    The catalog, search, and every document respect audience restrictions. Content streams through the API into a sandboxed Blob-URL iframe — never inline in the app's own DOM.

  4. Step 4: Audit

    Every view, download, and search is recorded as an attributed, append-only event, queryable by any admin through the reporting UI or the MCP tools.

Technical Specifications

Under the Hood

  • Backend

    • FastAPI (Python 3.12), SQLAlchemy 2.0 async
    • PostgreSQL registry, append-only schema enforced by a database trigger
    • Postgres full-text search over extracted document text
    • S3 content store, KMS-encrypted, IAM-identity access only (no bucket policy)

  • Frontend

    • React 19, TypeScript, Vite 8
    • @avian/design-system, canonical AppShell
    • Sandboxed <iframe> artifact viewer built from a Blob URL
    • Light and dark mode, mobile-safe down to 375px

  • Security

    • RS256 JWT verification via renkara-auth JWKS (Valkey-cached)
    • Constant-time admin-key comparison for the publishing API
    • Rate limiting on content, search, and admin endpoints
    • Structured, append-only audit log — view/download/search/share-link events

  • Integrations

    • MCP server — 38 tools (Streamable HTTP + stdio bridge)
    • Renders Markdown, HTML artifacts, and PDFs
    • Vendored Mermaid diagrams, Pygments dual-theme code highlighting
    • Registered fleet-wide through Roost as lectern

Development

100% Built by Claude

Every tool in the Renkara fleet was built by Claude (Anthropic) working alongside a single human supervisor. Every line of code, every test, every deployment: AI-authored with human direction. The leverage factor across the fleet runs in the 20x–50x range, with individual sessions regularly exceeding 100x.

See the daily leverage records for per-task numbers across the full build history.