66 KiB

Raw Blame History

Prerender-Snapshot Implementation Plan

For agentic workers: REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (- [ ]) syntax for tracking.

Goal: Post-Detailseiten unter https://joerg-lohrer.de/<d-tag>/ werden zur Build-Zeit zu statischem HTML mit OG-/Twitter-/JSON-LD-Tags prerendered, auf Basis eines Deno-Snapshot-Tools, das die Post-Daten aus den Relays in JSON-Artefakte schreibt.

Architecture: Drei entkoppelte Stufen — publish bleibt unverändert; ein neues snapshot/-Modul (Deno) liest Events von den Relays und schreibt JSON; SvelteKit prerendert die Detail-Routen aus diesen JSON-Dateien. Frische Nostr-first-Posts fallen weiter über adapter-static-fallback: 'index.html' auf Runtime-Hydration.

Tech Stack: Deno (@std/path, @std/yaml, nostr-tools, applesauce-relay, rxjs), SvelteKit 2 mit adapter-static, marked + isomorphic-dompurify + highlight.js, Vitest (jsdom + node), bash + lftp für Deploy.

Spec: docs/superpowers/specs/2026-04-21-prerender-snapshot-design.md.

Migrations-Strategie: Sechs entkoppelte Etappen, jede einzeln getestet, einzeln committed, einzeln rollback-bar. Reihenfolge ist Pflicht — frühere Etappen sind Vorbedingung für spätere.

Etappe 1 — `renderMarkdown` Node-kompatibel

Heute wirft renderMarkdown hart, wenn window === undefined. Der SvelteKit-Build läuft in Node — die Funktion muss dort funktionieren, ohne dass die Browser-Variante kaputtgeht.

Task 1.1: Failing Node-Test für renderMarkdown

Files:

Test: app/src/lib/render/markdown.node.test.ts (neu)
Step 1.1.1: Test schreiben

// app/src/lib/render/markdown.node.test.ts
// @vitest-environment node
import { describe, it, expect } from 'vitest';
import { renderMarkdown } from './markdown';

describe('renderMarkdown (Node-Kontext)', () => {
  it('rendert einfaches Markdown im Node-Build ohne window', () => {
    const html = renderMarkdown('# Hallo\n\nWelt mit *Kursiv* und [Link](https://example.com)');
    expect(html).toContain('<h1');
    expect(html).toContain('Hallo');
    expect(html).toContain('<em>Kursiv</em>');
    expect(html).toContain('href="https://example.com"');
  });

  it('sanitisiert XSS-Versuche', () => {
    const html = renderMarkdown('<script>alert(1)</script>\n\nText');
    expect(html).not.toContain('<script');
    expect(html).toContain('Text');
  });

  it('hebt code-blocks mit highlight.js hervor', () => {
    const html = renderMarkdown('```ts\nconst x: number = 1;\n```');
    expect(html).toContain('class="hljs');
    expect(html).toContain('language-ts');
  });
});

Step 1.1.2: Test laufen lassen → muss fehlschlagen

Run: cd app && npx vitest run src/lib/render/markdown.node.test.ts Expected: FAIL — entweder mit renderMarkdown: DOM-Kontext erforderlich oder mit ReferenceError zu window/document.

Step 1.1.3: Commit Test-Datei

git add app/src/lib/render/markdown.node.test.ts
git commit -m "test: failing node-test fuer renderMarkdown

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"

Task 1.2: isomorphic-dompurify einführen

Files:

Modify: app/package.json
Modify: app/src/lib/render/markdown.ts
Step 1.2.1: Dependency installieren

cd app && npm install isomorphic-dompurify

Erwartung: isomorphic-dompurify landet unter dependencies in package.json.

Step 1.2.2: markdown.ts umstellen

Komplette neue Fassung von app/src/lib/render/markdown.ts:

import { Marked } from 'marked';
import DOMPurify from 'isomorphic-dompurify';
import hljs from 'highlight.js/lib/core';
import javascript from 'highlight.js/lib/languages/javascript';
import bash from 'highlight.js/lib/languages/bash';
import typescript from 'highlight.js/lib/languages/typescript';
import json from 'highlight.js/lib/languages/json';

hljs.registerLanguage('javascript', javascript);
hljs.registerLanguage('js', javascript);
hljs.registerLanguage('typescript', typescript);
hljs.registerLanguage('ts', typescript);
hljs.registerLanguage('bash', bash);
hljs.registerLanguage('sh', bash);
hljs.registerLanguage('json', json);

const markedInstance = new Marked({
  breaks: true,
  gfm: true,
  renderer: {
    code({ text, lang }) {
      const language = lang && hljs.getLanguage(lang) ? lang : undefined;
      const highlighted = language
        ? hljs.highlight(text, { language }).value
        : hljs.highlightAuto(text).value;
      const cls = language ? ` language-${language}` : '';
      return `<pre><code class="hljs${cls}">${highlighted}</code></pre>`;
    }
  }
});

export function renderMarkdown(md: string): string {
  const raw = markedInstance.parse(md, { async: false }) as string;
  return DOMPurify.sanitize(raw);
}

Step 1.2.3: Node-Test laufen lassen → muss passen

Run: cd app && npx vitest run src/lib/render/markdown.node.test.ts Expected: PASS — alle drei Test-Cases grün.

Step 1.2.4: Bestehende Tests laufen lassen → keine Regression

Run: cd app && npm run test:unit Expected: alle Tests grün, inklusive der Browser/jsdom-Cases (die wegen isomorphic-dompurify automatisch im Browser auf das DOMPurify-Browser-Backend zurückfallen).

Step 1.2.5: TypeScript-Check

Run: cd app && npm run check Expected: 0 errors, 0 warnings.

Step 1.2.6: Commit

git add app/package.json app/package-lock.json app/src/lib/render/markdown.ts
git commit -m "feat(render): renderMarkdown auf isomorphic-dompurify umgestellt

Funktioniert jetzt sowohl in Browser/jsdom als auch in Node (SvelteKit-Build).
Schritt 1 der prerender-snapshot-migration. Verhalten in der SPA unveraendert.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"

Etappe 2 — Snapshot-Modul (Deno)

Neues Verzeichnis snapshot/ als Geschwister zu publish/. Liest Events von Relays, schreibt JSON. Keine Änderung an SPA in dieser Etappe.

Task 2.1: Modul-Skelett mit deno.jsonc

Files:

Create: snapshot/deno.jsonc
Create: snapshot/.gitignore
Create: snapshot/README.md
Step 2.1.1: deno.jsonc anlegen

{
  "tasks": {
    "snapshot": "deno run --env-file=../.env.local --allow-env --allow-read --allow-write --allow-net src/cli.ts",
    "test": "deno test --allow-env --allow-read --allow-write --allow-net",
    "fmt": "deno fmt",
    "lint": "deno lint"
  },
  "imports": {
    "@std/yaml": "jsr:@std/yaml@^1.0.5",
    "@std/cli": "jsr:@std/cli@^1.0.6",
    "@std/fs": "jsr:@std/fs@^1.0.4",
    "@std/path": "jsr:@std/path@^1.0.6",
    "@std/testing": "jsr:@std/testing@^1.0.3",
    "@std/assert": "jsr:@std/assert@^1.0.6",
    "@std/encoding": "jsr:@std/encoding@^1.0.5",
    "nostr-tools": "npm:nostr-tools@^2.10.4",
    "applesauce-relay": "npm:applesauce-relay@^2.0.0",
    "rxjs": "npm:rxjs@^7.8.1"
  },
  "fmt": {
    "lineWidth": 100,
    "indentWidth": 2,
    "semiColons": false,
    "singleQuote": true
  },
  "lint": {
    "rules": {
      "tags": ["recommended"]
    }
  }
}

Step 2.1.2: .gitignore anlegen

output/
.last-snapshot.json

Step 2.1.3: README.md anlegen

# snapshot/

Liest die `kind:30023`-Events des Site-Autors von den Read-Relays und
schreibt sie als JSON-Artefakte für den SvelteKit-Prerender-Schritt.
Kein Live-Proxy: Relays werden nur zur Build-Zeit befragt.

Spec: [`../docs/superpowers/specs/2026-04-21-prerender-snapshot-design.md`](../docs/superpowers/specs/2026-04-21-prerender-snapshot-design.md)

## Nutzung

```sh
cd snapshot
deno task snapshot                    # default
deno task snapshot --out ./output     # alternatives Ziel
deno task snapshot --min-events 20    # Schwelle
deno task snapshot --allow-shrink     # Drop-Check aus

Erwartet diese Env-Vars (aus ../.env.local):

AUTHOR_PUBKEY_HEX (64 hex chars)
BOOTSTRAP_RELAY (wss-URL)


- [ ] **Step 2.1.4: Commit Skelett**

```bash
git add snapshot/deno.jsonc snapshot/.gitignore snapshot/README.md
git commit -m "feat(snapshot): modul-skelett

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"

Task 2.2: Config-Modul mit Tests

Files:

Create: snapshot/src/core/config.ts
Test: snapshot/tests/config.test.ts
Step 2.2.1: Failing Test

// snapshot/tests/config.test.ts
import { assertEquals, assertThrows } from '@std/assert'
import { loadConfig } from '../src/core/config.ts'

Deno.test('loadConfig liest pubkey + bootstrap relay', () => {
  Deno.env.set('AUTHOR_PUBKEY_HEX', '4fa5d1c413e2b45e10d40bf3562ab701a5331206e359c90baae0e99bfd6c6e41')
  Deno.env.set('BOOTSTRAP_RELAY', 'wss://relay.primal.net')
  const cfg = loadConfig()
  assertEquals(cfg.authorPubkeyHex, '4fa5d1c413e2b45e10d40bf3562ab701a5331206e359c90baae0e99bfd6c6e41')
  assertEquals(cfg.bootstrapRelay, 'wss://relay.primal.net')
})

Deno.test('loadConfig wirft bei fehlendem AUTHOR_PUBKEY_HEX', () => {
  Deno.env.delete('AUTHOR_PUBKEY_HEX')
  Deno.env.set('BOOTSTRAP_RELAY', 'wss://relay.primal.net')
  assertThrows(() => loadConfig(), Error, 'AUTHOR_PUBKEY_HEX')
})

Deno.test('loadConfig wirft bei ungueltigem hex', () => {
  Deno.env.set('AUTHOR_PUBKEY_HEX', 'nicht-hex')
  Deno.env.set('BOOTSTRAP_RELAY', 'wss://relay.primal.net')
  assertThrows(() => loadConfig(), Error, '64 hex')
})

Step 2.2.2: Test laufen lassen → muss fehlschlagen

Run: cd snapshot && deno test tests/config.test.ts Expected: FAIL — Modul existiert noch nicht.

Step 2.2.3: Implementation

// snapshot/src/core/config.ts
export interface Config {
  authorPubkeyHex: string
  bootstrapRelay: string
}

export function loadConfig(): Config {
  const authorPubkeyHex = Deno.env.get('AUTHOR_PUBKEY_HEX')
  const bootstrapRelay = Deno.env.get('BOOTSTRAP_RELAY')
  if (!authorPubkeyHex) throw new Error('AUTHOR_PUBKEY_HEX fehlt in env')
  if (!/^[0-9a-f]{64}$/i.test(authorPubkeyHex)) {
    throw new Error('AUTHOR_PUBKEY_HEX muss 64 hex chars sein')
  }
  if (!bootstrapRelay) throw new Error('BOOTSTRAP_RELAY fehlt in env')
  return { authorPubkeyHex, bootstrapRelay }
}

Step 2.2.4: Test → muss passen

Run: cd snapshot && deno test tests/config.test.ts Expected: PASS, 3 Tests grün.

Step 2.2.5: Commit

git add snapshot/src/core/config.ts snapshot/tests/config.test.ts
git commit -m "feat(snapshot): config-loader mit env-validierung

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"

Task 2.3: Dedup-by-d-tag mit Test

Files:

Create: snapshot/src/core/dedup.ts
Test: snapshot/tests/dedup.test.ts
Step 2.3.1: Failing Test

// snapshot/tests/dedup.test.ts
import { assertEquals } from '@std/assert'
import { dedupByDtag } from '../src/core/dedup.ts'
import type { SignedEvent } from '../src/core/types.ts'

function ev(d: string, created_at: number, id: string): SignedEvent {
  return {
    id, pubkey: 'p', created_at, kind: 30023, sig: 's', content: '',
    tags: [['d', d]],
  }
}

Deno.test('dedupByDtag behaelt das neueste event pro d-tag', () => {
  const out = dedupByDtag([
    ev('a', 100, 'a-old'),
    ev('a', 200, 'a-new'),
    ev('b', 50, 'b-only'),
  ])
  const ids = out.map((e) => e.id).sort()
  assertEquals(ids, ['a-new', 'b-only'])
})

Deno.test('dedupByDtag laesst events ohne d-tag weg', () => {
  const out = dedupByDtag([
    { id: 'x', pubkey: 'p', created_at: 1, kind: 30023, sig: 's', content: '', tags: [] },
    ev('a', 1, 'a'),
  ])
  assertEquals(out.length, 1)
  assertEquals(out[0].id, 'a')
})

Step 2.3.2: Types-Modul anlegen

// snapshot/src/core/types.ts
export interface SignedEvent {
  id: string
  pubkey: string
  created_at: number
  kind: number
  tags: string[][]
  content: string
  sig: string
}

Step 2.3.3: Implementation

// snapshot/src/core/dedup.ts
import type { SignedEvent } from './types.ts'

export function dedupByDtag(events: SignedEvent[]): SignedEvent[] {
  const byDtag = new Map<string, SignedEvent>()
  for (const ev of events) {
    const d = ev.tags.find((t) => t[0] === 'd')?.[1]
    if (!d) continue
    const existing = byDtag.get(d)
    if (!existing || ev.created_at > existing.created_at) {
      byDtag.set(d, ev)
    }
  }
  return [...byDtag.values()]
}

Step 2.3.4: Tests → grün

Run: cd snapshot && deno test tests/dedup.test.ts Expected: PASS, 2 Tests grün.

Step 2.3.5: Commit

git add snapshot/src/core/types.ts snapshot/src/core/dedup.ts snapshot/tests/dedup.test.ts
git commit -m "feat(snapshot): dedup-by-d-tag

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"

Task 2.4: NIP-09-Filter mit Test

Files:

Create: snapshot/src/core/nip09-filter.ts
Test: snapshot/tests/nip09-filter.test.ts
Step 2.4.1: Failing Test

// snapshot/tests/nip09-filter.test.ts
import { assertEquals } from '@std/assert'
import { filterDeleted } from '../src/core/nip09-filter.ts'
import type { SignedEvent } from '../src/core/types.ts'

function post(d: string, id: string): SignedEvent {
  return { id, pubkey: 'P', created_at: 1, kind: 30023, sig: 's', content: '', tags: [['d', d]] }
}
function deletion(coords: string[]): SignedEvent {
  return {
    id: 'del', pubkey: 'P', created_at: 2, kind: 5, sig: 's', content: '',
    tags: coords.map((c) => ['a', c]),
  }
}

Deno.test('filterDeleted entfernt events deren coord in einem kind:5 referenziert ist', () => {
  const out = filterDeleted(
    [post('alive', 'a'), post('dead', 'b')],
    [deletion(['30023:P:dead'])],
    'P',
  )
  assertEquals(out.map((e) => e.id), ['a'])
})

Deno.test('filterDeleted ignoriert kind:5 fremder pubkeys', () => {
  const fremde: SignedEvent = {
    ...deletion(['30023:P:alive']), pubkey: 'OTHER',
  }
  const out = filterDeleted([post('alive', 'a')], [fremde], 'P')
  assertEquals(out.length, 1)
})

Step 2.4.2: Implementation

// snapshot/src/core/nip09-filter.ts
import type { SignedEvent } from './types.ts'

export function filterDeleted(
  events: SignedEvent[],
  deletions: SignedEvent[],
  authorPubkey: string,
): SignedEvent[] {
  const deletedCoords = new Set<string>()
  for (const del of deletions) {
    if (del.kind !== 5) continue
    if (del.pubkey !== authorPubkey) continue
    for (const tag of del.tags) {
      if (tag[0] === 'a' && tag[1]) deletedCoords.add(tag[1])
    }
  }
  return events.filter((ev) => {
    const d = ev.tags.find((t) => t[0] === 'd')?.[1]
    if (!d) return true
    const coord = `${ev.kind}:${ev.pubkey}:${d}`
    return !deletedCoords.has(coord)
  })
}

Step 2.4.3: Tests → grün

Run: cd snapshot && deno test tests/nip09-filter.test.ts Expected: PASS, 2 Tests grün.

Step 2.4.4: Commit

git add snapshot/src/core/nip09-filter.ts snapshot/tests/nip09-filter.test.ts
git commit -m "feat(snapshot): NIP-09-filter

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"

Task 2.5: Plausibilitäts-Checks mit Test

Files:

Create: snapshot/src/core/checks.ts
Test: snapshot/tests/checks.test.ts
Step 2.5.1: Failing Test

// snapshot/tests/checks.test.ts
import { assertEquals, assertThrows } from '@std/assert'
import { runChecks } from '../src/core/checks.ts'

Deno.test('runChecks: weniger als 60% relays geantwortet -> hard-fail', () => {
  assertThrows(
    () => runChecks({
      relaysQueried: 5, relaysResponded: 2,
      eventCount: 27, minEvents: 1, lastKnownGoodCount: undefined,
      newDeletionsCount: 0, allowShrink: false,
    }),
    Error, 'Relay-Quorum',
  )
})

Deno.test('runChecks: event-count unter min-events -> hard-fail', () => {
  assertThrows(
    () => runChecks({
      relaysQueried: 5, relaysResponded: 5,
      eventCount: 0, minEvents: 1, lastKnownGoodCount: undefined,
      newDeletionsCount: 0, allowShrink: false,
    }),
    Error, 'min-events',
  )
})

Deno.test('runChecks: drop > 20% ohne kind:5 -> hard-fail', () => {
  assertThrows(
    () => runChecks({
      relaysQueried: 5, relaysResponded: 5,
      eventCount: 20, minEvents: 1, lastKnownGoodCount: 27,
      newDeletionsCount: 0, allowShrink: false,
    }),
    Error, 'Event-Count-Drop',
  )
})

Deno.test('runChecks: drop > 20% mit korrespondierenden kind:5 -> ok', () => {
  runChecks({
    relaysQueried: 5, relaysResponded: 5,
    eventCount: 20, minEvents: 1, lastKnownGoodCount: 27,
    newDeletionsCount: 7, allowShrink: false,
  })
})

Deno.test('runChecks: --allow-shrink umgeht drop-check', () => {
  runChecks({
    relaysQueried: 5, relaysResponded: 5,
    eventCount: 1, minEvents: 1, lastKnownGoodCount: 27,
    newDeletionsCount: 0, allowShrink: true,
  })
})

Deno.test('runChecks: erstlauf ohne cache + min-events=1 -> ok', () => {
  runChecks({
    relaysQueried: 5, relaysResponded: 5,
    eventCount: 1, minEvents: 1, lastKnownGoodCount: undefined,
    newDeletionsCount: 0, allowShrink: false,
  })
})

Step 2.5.2: Implementation

// snapshot/src/core/checks.ts
export interface CheckInput {
  relaysQueried: number
  relaysResponded: number
  eventCount: number
  minEvents: number
  lastKnownGoodCount: number | undefined
  newDeletionsCount: number
  allowShrink: boolean
}

export function runChecks(input: CheckInput): void {
  const quorum = Math.ceil(input.relaysQueried * 0.6)
  if (input.relaysResponded < quorum) {
    throw new Error(
      `Relay-Quorum nicht erreicht: ${input.relaysResponded}/${input.relaysQueried} ` +
        `(brauche mindestens ${quorum})`,
    )
  }
  if (input.eventCount < input.minEvents) {
    throw new Error(
      `Event-Count ${input.eventCount} unter min-events ${input.minEvents}`,
    )
  }
  if (input.lastKnownGoodCount !== undefined && !input.allowShrink) {
    const drop = input.lastKnownGoodCount - input.eventCount
    const dropPct = drop / input.lastKnownGoodCount
    if (dropPct > 0.2 && drop > input.newDeletionsCount) {
      throw new Error(
        `Event-Count-Drop ${drop} (${(dropPct * 100).toFixed(0)}%) gegenueber ` +
          `last-known-good ${input.lastKnownGoodCount}, ` +
          `nur ${input.newDeletionsCount} korrespondierende kind:5. ` +
          `Override mit --allow-shrink falls bewusst.`,
      )
    }
  }
}

Step 2.5.3: Tests → grün

Run: cd snapshot && deno test tests/checks.test.ts Expected: PASS, 6 Tests grün.

Step 2.5.4: Commit

git add snapshot/src/core/checks.ts snapshot/tests/checks.test.ts
git commit -m "feat(snapshot): plausibilitaets-checks (relay-quorum, drop, min-events)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"

Task 2.6: JSON-Builder pro Post mit Test

Files:

Create: snapshot/src/core/post-json.ts
Test: snapshot/tests/post-json.test.ts
Step 2.6.1: Failing Test

// snapshot/tests/post-json.test.ts
import { assertEquals } from '@std/assert'
import { buildPostJson } from '../src/core/post-json.ts'
import type { SignedEvent } from '../src/core/types.ts'

const PUBKEY = '4fa5d1c413e2b45e10d40bf3562ab701a5331206e359c90baae0e99bfd6c6e41'

function buildEvent(opts: {
  d: string
  title: string
  summary?: string
  image?: string
  publishedAt?: number
  lang?: string
  tags?: string[]
  translationCoords?: string[]
  content: string
}): SignedEvent {
  const tags: string[][] = [['d', opts.d], ['title', opts.title]]
  if (opts.summary) tags.push(['summary', opts.summary])
  if (opts.image) tags.push(['image', opts.image])
  if (opts.publishedAt) tags.push(['published_at', String(opts.publishedAt)])
  if (opts.lang) {
    tags.push(['L', 'ISO-639-1'])
    tags.push(['l', opts.lang, 'ISO-639-1'])
  }
  for (const t of opts.tags ?? []) tags.push(['t', t])
  for (const c of opts.translationCoords ?? []) tags.push(['a', c, '', 'translation'])
  return {
    id: 'event-' + opts.d, pubkey: PUBKEY, created_at: 1700000000, kind: 30023,
    sig: 'sig', content: opts.content, tags,
  }
}

Deno.test('buildPostJson: vollstaendiges event', () => {
  const ev = buildEvent({
    d: 'bibel-selfies', title: 'Bibel-Selfies', summary: 'Kurz',
    image: 'https://blossom.edufeed.org/abc.jpg',
    publishedAt: 1699000000, lang: 'de', tags: ['Bibel'],
    translationCoords: [`30023:${PUBKEY}:bible-selfies`],
    content: '# body',
  })
  const titleByDtag = new Map([['bible-selfies', 'Bible-Selfies']])
  const json = buildPostJson(ev, titleByDtag)
  assertEquals(json.slug, 'bibel-selfies')
  assertEquals(json.title, 'Bibel-Selfies')
  assertEquals(json.summary, 'Kurz')
  assertEquals(json.lang, 'de')
  assertEquals(json.tags, ['Bibel'])
  assertEquals(json.published_at, 1699000000)
  assertEquals(json.cover_image?.url, 'https://blossom.edufeed.org/abc.jpg')
  assertEquals(json.translations, [
    { lang: 'en', slug: 'bible-selfies', title: 'Bible-Selfies' },
  ])
  assertEquals(json.content_markdown, '# body')
})

Deno.test('buildPostJson: fallback summary aus content', () => {
  const ev = buildEvent({
    d: 'no-summary', title: 'X', content: 'Lorem ipsum dolor sit amet.'.repeat(20),
  })
  const json = buildPostJson(ev, new Map())
  if (!json.summary) throw new Error('summary fehlt')
  if (json.summary.length > 220) throw new Error('summary zu lang')
  if (!json.summary.endsWith('…')) throw new Error('summary ohne ellipsis')
})

Deno.test('buildPostJson: fehlt published_at -> created_at', () => {
  const ev = buildEvent({ d: 'no-pub', title: 'X', content: 'x' })
  const json = buildPostJson(ev, new Map())
  assertEquals(json.published_at, 1700000000)
})

Deno.test('buildPostJson: fehlt image -> cover_image null', () => {
  const ev = buildEvent({ d: 'no-img', title: 'X', content: 'x' })
  const json = buildPostJson(ev, new Map())
  assertEquals(json.cover_image, null)
})

Deno.test('buildPostJson: lang default de wenn keine l-tags', () => {
  const ev = buildEvent({ d: 'no-lang', title: 'X', content: 'x' })
  const json = buildPostJson(ev, new Map())
  assertEquals(json.lang, 'de')
})

Step 2.6.2: Implementation

// snapshot/src/core/post-json.ts
import { nip19 } from 'nostr-tools'
import type { SignedEvent } from './types.ts'

export interface CoverImage {
  url: string
  width?: number
  height?: number
  alt?: string
  mime?: string
}

export interface TranslationRef {
  lang: string
  slug: string
  title: string
}

export interface PostJson {
  slug: string
  event_id: string
  created_at: number
  published_at: number
  title: string
  summary: string
  lang: string
  cover_image: CoverImage | null
  content_markdown: string
  tags: string[]
  naddr: string
  habla_url: string
  translations: TranslationRef[]
}

const SUMMARY_MAX = 200

function tagValue(ev: SignedEvent, name: string): string | undefined {
  return ev.tags.find((t) => t[0] === name)?.[1]
}

function tagsAll(ev: SignedEvent, name: string): string[] {
  return ev.tags.filter((t) => t[0] === name).map((t) => t[1])
}

function deriveSummary(content: string): string {
  const flat = content.replace(/\s+/g, ' ').trim()
  if (flat.length <= SUMMARY_MAX) return flat
  const cut = flat.slice(0, SUMMARY_MAX)
  const lastSpace = cut.lastIndexOf(' ')
  const trimmed = lastSpace > SUMMARY_MAX * 0.5 ? cut.slice(0, lastSpace) : cut
  return trimmed + '…'
}

export function buildPostJson(
  ev: SignedEvent,
  titleByDtag: Map<string, string>,
): PostJson {
  const slug = tagValue(ev, 'd') ?? ''
  const title = tagValue(ev, 'title') ?? ''
  const summaryTag = tagValue(ev, 'summary')
  const summary = summaryTag && summaryTag.length > 0 ? summaryTag : deriveSummary(ev.content)
  const image = tagValue(ev, 'image')
  const publishedAtRaw = tagValue(ev, 'published_at')
  const publishedAt = publishedAtRaw ? parseInt(publishedAtRaw, 10) : ev.created_at
  const lang = ev.tags.find((t) => t[0] === 'l' && t[2] === 'ISO-639-1')?.[1] ?? 'de'

  const cover_image: CoverImage | null = image
    ? { url: image, alt: title || undefined }
    : null

  const naddr = nip19.naddrEncode({
    kind: ev.kind,
    pubkey: ev.pubkey,
    identifier: slug,
  })

  const translations: TranslationRef[] = []
  for (const tag of ev.tags) {
    if (tag[0] !== 'a') continue
    if (tag[3] !== 'translation') continue
    const coord = tag[1]
    if (!coord) continue
    const parts = coord.split(':')
    if (parts.length !== 3) continue
    const otherSlug = parts[2]
    const otherTitle = titleByDtag.get(otherSlug) ?? otherSlug
    translations.push({
      lang: lang === 'de' ? 'en' : 'de',
      slug: otherSlug,
      title: otherTitle,
    })
  }

  return {
    slug,
    event_id: ev.id,
    created_at: ev.created_at,
    published_at: publishedAt,
    title,
    summary,
    lang,
    cover_image,
    content_markdown: ev.content,
    tags: tagsAll(ev, 't'),
    naddr,
    habla_url: `https://habla.news/a/${naddr}`,
    translations,
  }
}

Step 2.6.3: Tests → grün

Run: cd snapshot && deno test tests/post-json.test.ts Expected: PASS, 5 Tests grün.

Step 2.6.4: Commit

git add snapshot/src/core/post-json.ts snapshot/tests/post-json.test.ts
git commit -m "feat(snapshot): post-json-builder mit fallback-summary

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"

Task 2.6.b: Cover-Image-HEAD-Probe

Files:

Create: snapshot/src/core/cover-probe.ts
Test: snapshot/tests/cover-probe.test.ts

Spec Algorithmus-Schritt 6: HEAD-Request auf den Cover-URL-Kandidaten; bei 200 als url schreiben, bei Fehler Warnung loggen + URL trotzdem schreiben (Blossom ist content-addressed, URL kommt zurück). Wir kapseln das als reine Funktion mit injizierbarem Fetch-Stub.

Step 2.6.b.1: Failing Test

// snapshot/tests/cover-probe.test.ts
import { assertEquals } from '@std/assert'
import { probeCover, type HeadFetcher } from '../src/core/cover-probe.ts'

Deno.test('probeCover: 200 -> reachable=true', async () => {
  const fetcher: HeadFetcher = async () => ({ ok: true, status: 200 })
  const r = await probeCover('https://blossom.example/abc.jpg', fetcher)
  assertEquals(r, { reachable: true, status: 200 })
})

Deno.test('probeCover: 404 -> reachable=false', async () => {
  const fetcher: HeadFetcher = async () => ({ ok: false, status: 404 })
  const r = await probeCover('https://blossom.example/abc.jpg', fetcher)
  assertEquals(r, { reachable: false, status: 404 })
})

Deno.test('probeCover: network error -> reachable=false', async () => {
  const fetcher: HeadFetcher = async () => {
    throw new Error('ECONNREFUSED')
  }
  const r = await probeCover('https://blossom.example/abc.jpg', fetcher)
  assertEquals(r, { reachable: false, status: 0 })
})

Step 2.6.b.2: Implementation

// snapshot/src/core/cover-probe.ts
export interface ProbeResult {
  reachable: boolean
  status: number
}

export type HeadFetcher = (url: string) => Promise<{ ok: boolean; status: number }>

export const defaultHeadFetcher: HeadFetcher = async (url) => {
  const resp = await fetch(url, { method: 'HEAD' })
  return { ok: resp.ok, status: resp.status }
}

export async function probeCover(
  url: string,
  fetcher: HeadFetcher = defaultHeadFetcher,
): Promise<ProbeResult> {
  try {
    const r = await fetcher(url)
    return { reachable: r.ok, status: r.status }
  } catch {
    return { reachable: false, status: 0 }
  }
}

Step 2.6.b.3: Tests → grün

Run: cd snapshot && deno test tests/cover-probe.test.ts Expected: PASS, 3 Tests grün.

Step 2.6.b.4: CLI um Probe-Aufruf erweitern

In snapshot/src/cli.ts nach dem postJsons-Build pro Post mit cover_image:

import { probeCover } from './core/cover-probe.ts'

// ... innerhalb main(), nach `const postJsons = filtered.map(...)`:
for (const p of postJsons) {
  if (!p.cover_image) continue
  const probe = await probeCover(p.cover_image.url)
  if (!probe.reachable) {
    console.warn(
      `snapshot: cover unreachable [${probe.status}] ${p.cover_image.url} (slug=${p.slug}) — URL wird trotzdem geschrieben`,
    )
  }
}

Step 2.6.b.5: Commit

git add snapshot/src/core/cover-probe.ts snapshot/tests/cover-probe.test.ts snapshot/src/cli.ts
git commit -m "feat(snapshot): cover-image-HEAD-probe mit warnung bei unreachable

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"

Task 2.7: Cache-/Last-known-good-Modul

Files:

Create: snapshot/src/core/cache.ts
Test: snapshot/tests/cache.test.ts
Step 2.7.1: Failing Test

// snapshot/tests/cache.test.ts
import { assertEquals } from '@std/assert'
import { join } from '@std/path'
import { readCache, writeCache, type CacheState } from '../src/core/cache.ts'

Deno.test('readCache: file fehlt -> undefined', async () => {
  const dir = await Deno.makeTempDir()
  const path = join(dir, 'cache.json')
  const cache = await readCache(path)
  assertEquals(cache, undefined)
})

Deno.test('writeCache + readCache: round-trip', async () => {
  const dir = await Deno.makeTempDir()
  const path = join(dir, 'cache.json')
  const state: CacheState = { lastKnownGoodCount: 27, deletedCoords: ['30023:P:dead'] }
  await writeCache(path, state)
  const out = await readCache(path)
  assertEquals(out, state)
})

Step 2.7.2: Implementation

// snapshot/src/core/cache.ts
export interface CacheState {
  lastKnownGoodCount: number
  deletedCoords: string[]
}

export async function readCache(path: string): Promise<CacheState | undefined> {
  try {
    const text = await Deno.readTextFile(path)
    return JSON.parse(text) as CacheState
  } catch (err) {
    if (err instanceof Deno.errors.NotFound) return undefined
    throw err
  }
}

export async function writeCache(path: string, state: CacheState): Promise<void> {
  await Deno.writeTextFile(path, JSON.stringify(state, null, 2) + '\n')
}

Step 2.7.3: Tests → grün

Run: cd snapshot && deno test tests/cache.test.ts Expected: PASS, 2 Tests grün.

Step 2.7.4: Commit

git add snapshot/src/core/cache.ts snapshot/tests/cache.test.ts
git commit -m "feat(snapshot): cache-state fuer last-known-good

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"

Task 2.8: Output-Writer (index.json + posts/.json)

Files:

Create: snapshot/src/core/output.ts
Test: snapshot/tests/output.test.ts
Step 2.8.1: Failing Test

// snapshot/tests/output.test.ts
import { assertEquals } from '@std/assert'
import { join } from '@std/path'
import { writeOutput } from '../src/core/output.ts'
import type { PostJson } from '../src/core/post-json.ts'

const samplePost: PostJson = {
  slug: 'a', event_id: 'e1', created_at: 1, published_at: 1,
  title: 'A', summary: 's', lang: 'de', cover_image: null,
  content_markdown: '# A', tags: [], naddr: 'naddr1', habla_url: 'https://habla.news/a/naddr1',
  translations: [],
}

Deno.test('writeOutput schreibt index.json + posts/<slug>.json', async () => {
  const dir = await Deno.makeTempDir()
  await writeOutput(dir, {
    generatedAt: '2026-04-28T10:00:00Z',
    authorPubkey: 'P',
    relaysQueried: ['wss://r1', 'wss://r2'],
    relaysResponded: ['wss://r1'],
    posts: [samplePost],
  })

  const indexText = await Deno.readTextFile(join(dir, 'index.json'))
  const index = JSON.parse(indexText)
  assertEquals(index.author_pubkey, 'P')
  assertEquals(index.post_count, 1)
  assertEquals(index.posts.length, 1)
  assertEquals(index.posts[0].slug, 'a')
  assertEquals(index.posts[0].title, 'A')
  assertEquals(index.posts[0].lang, 'de')

  const postText = await Deno.readTextFile(join(dir, 'posts', 'a.json'))
  const post = JSON.parse(postText)
  assertEquals(post.slug, 'a')
  assertEquals(post.content_markdown, '# A')
})

Step 2.8.2: Implementation

// snapshot/src/core/output.ts
import { ensureDir } from '@std/fs'
import { join } from '@std/path'
import type { PostJson } from './post-json.ts'

export interface OutputInput {
  generatedAt: string
  authorPubkey: string
  relaysQueried: string[]
  relaysResponded: string[]
  posts: PostJson[]
}

export async function writeOutput(outDir: string, input: OutputInput): Promise<void> {
  await ensureDir(outDir)
  await ensureDir(join(outDir, 'posts'))

  const index = {
    generated_at: input.generatedAt,
    author_pubkey: input.authorPubkey,
    relays_queried: input.relaysQueried,
    relays_responded: input.relaysResponded,
    post_count: input.posts.length,
    posts: input.posts.map((p) => ({
      slug: p.slug,
      lang: p.lang,
      created_at: p.created_at,
      title: p.title,
    })),
  }
  await Deno.writeTextFile(
    join(outDir, 'index.json'),
    JSON.stringify(index, null, 2) + '\n',
  )

  for (const post of input.posts) {
    await Deno.writeTextFile(
      join(outDir, 'posts', `${post.slug}.json`),
      JSON.stringify(post, null, 2) + '\n',
    )
  }
}

Step 2.8.3: Tests → grün

Run: cd snapshot && deno test tests/output.test.ts Expected: PASS.

Step 2.8.4: Commit

git add snapshot/src/core/output.ts snapshot/tests/output.test.ts
git commit -m "feat(snapshot): output-writer (index.json + posts/<slug>.json)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"

Task 2.9: Relay-Loader (Bootstrap + Event-Fetch)

Files:

Create: snapshot/src/core/relays.ts
Test: snapshot/tests/relays.test.ts

Diese Schicht hat einen echten externen Bestandteil (Relay-Verbindung). Wir testen nur die Logik, die den Pool orchestriert — die Pool-Calls werden via injizierter Funktion gestubbt.

Step 2.9.1: Failing Test

// snapshot/tests/relays.test.ts
import { assertEquals } from '@std/assert'
import { extractReadRelays, type RelayListLoader, loadReadRelays } from '../src/core/relays.ts'
import type { SignedEvent } from '../src/core/types.ts'

const KIND_10002: SignedEvent = {
  id: 'r', pubkey: 'P', created_at: 1, kind: 10002, sig: 's', content: '',
  tags: [
    ['r', 'wss://relay.damus.io'],
    ['r', 'wss://nos.lol', 'read'],
    ['r', 'wss://relay.write-only.example', 'write'],
  ],
}

Deno.test('extractReadRelays: ohne marker = read+write, "read" = read, "write" = nicht', () => {
  assertEquals(extractReadRelays(KIND_10002), [
    'wss://relay.damus.io',
    'wss://nos.lol',
  ])
})

Deno.test('loadReadRelays: nutzt fallback wenn kein kind:10002', async () => {
  const loader: RelayListLoader = async () => undefined
  const relays = await loadReadRelays('wss://bootstrap', 'P', loader, [
    'wss://fallback1', 'wss://fallback2',
  ])
  assertEquals(relays, ['wss://fallback1', 'wss://fallback2'])
})

Deno.test('loadReadRelays: nutzt kind:10002 wenn vorhanden', async () => {
  const loader: RelayListLoader = async () => KIND_10002
  const relays = await loadReadRelays('wss://bootstrap', 'P', loader, ['wss://fallback'])
  assertEquals(relays, ['wss://relay.damus.io', 'wss://nos.lol'])
})

Step 2.9.2: Implementation

// snapshot/src/core/relays.ts
import { Relay } from 'applesauce-relay'
import { firstValueFrom, timeout } from 'rxjs'
import type { SignedEvent } from './types.ts'

export type RelayListLoader = (
  bootstrapRelay: string,
  authorPubkey: string,
) => Promise<SignedEvent | undefined>

export const FALLBACK_READ_RELAYS = [
  'wss://relay.damus.io',
  'wss://nos.lol',
  'wss://relay.primal.net',
  'wss://relay.tchncs.de',
  'wss://relay.edufeed.org',
]

export function extractReadRelays(kind10002: SignedEvent): string[] {
  const out: string[] = []
  for (const tag of kind10002.tags) {
    if (tag[0] !== 'r' || !tag[1]) continue
    const marker = tag[2]
    if (marker === 'write') continue
    out.push(tag[1])
  }
  return out
}

export const defaultRelayListLoader: RelayListLoader = async (bootstrap, pubkey) => {
  try {
    const relay = new Relay(bootstrap)
    const ev = await firstValueFrom(
      relay.request({ kinds: [10002], authors: [pubkey], limit: 1 })
        .pipe(timeout({ first: 5_000 })),
    )
    return ev as SignedEvent
  } catch {
    return undefined
  }
}

export async function loadReadRelays(
  bootstrapRelay: string,
  authorPubkey: string,
  loader: RelayListLoader = defaultRelayListLoader,
  fallback: string[] = FALLBACK_READ_RELAYS,
): Promise<string[]> {
  const ev = await loader(bootstrapRelay, authorPubkey)
  if (!ev) return fallback
  const list = extractReadRelays(ev)
  return list.length > 0 ? list : fallback
}

export interface FetchEventsResult {
  events: SignedEvent[]
  responded: string[]
  queried: string[]
}

export type EventFetcher = (relay: string, pubkey: string) => Promise<SignedEvent[]>

export const defaultEventFetcher: EventFetcher = async (relay, pubkey) => {
  const out: SignedEvent[] = []
  const r = new Relay(relay)
  return await new Promise<SignedEvent[]>((resolve) => {
    const sub = r.request({ kinds: [30023, 5], authors: [pubkey] })
      .pipe(timeout({ first: 10_000 }))
      .subscribe({
        next: (ev) => out.push(ev as SignedEvent),
        error: () => resolve(out),
        complete: () => resolve(out),
      })
    setTimeout(() => sub.unsubscribe(), 11_000)
  })
}

export async function fetchEvents(
  relays: string[],
  authorPubkey: string,
  fetcher: EventFetcher = defaultEventFetcher,
): Promise<FetchEventsResult> {
  const results = await Promise.all(
    relays.map(async (url) => {
      try {
        const events = await fetcher(url, authorPubkey)
        return { url, ok: true as const, events }
      } catch {
        return { url, ok: false as const, events: [] as SignedEvent[] }
      }
    }),
  )
  const events: SignedEvent[] = []
  for (const r of results) events.push(...r.events)
  return {
    events,
    responded: results.filter((r) => r.ok).map((r) => r.url),
    queried: relays,
  }
}

Step 2.9.3: Tests → grün

Run: cd snapshot && deno test tests/relays.test.ts Expected: PASS, 3 Tests grün.

Step 2.9.4: Commit

git add snapshot/src/core/relays.ts snapshot/tests/relays.test.ts
git commit -m "feat(snapshot): relay-loader (kind:10002 + event-fetch)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"

Task 2.10: CLI-Entrypoint

Files:

Create: snapshot/src/cli.ts

CLI verdrahtet alle Module. Wir testen kein CLI-Parsing — das ist @std/cli-Standard. Stattdessen nutzen wir die End-to-End-Verifikation in Task 2.11.

Step 2.10.1: Implementation

// snapshot/src/cli.ts
import { parseArgs } from '@std/cli'
import { join, resolve } from '@std/path'
import { loadConfig } from './core/config.ts'
import { loadReadRelays, fetchEvents } from './core/relays.ts'
import { dedupByDtag } from './core/dedup.ts'
import { filterDeleted } from './core/nip09-filter.ts'
import { runChecks } from './core/checks.ts'
import { buildPostJson } from './core/post-json.ts'
import { writeOutput } from './core/output.ts'
import { readCache, writeCache, type CacheState } from './core/cache.ts'
import type { SignedEvent } from './core/types.ts'

async function main(): Promise<number> {
  const args = parseArgs(Deno.args, {
    string: ['out', 'cache', 'min-events'],
    boolean: ['allow-shrink'],
    default: {
      out: resolve(import.meta.dirname!, '../output'),
    },
  })
  const outDir = String(args.out)
  const cachePath = args.cache ? String(args.cache) : join(outDir, '.last-snapshot.json')
  const allowShrink = args['allow-shrink'] === true

  const cfg = loadConfig()
  const cache = await readCache(cachePath)
  const minEvents = args['min-events']
    ? parseInt(String(args['min-events']), 10)
    : cache
      ? Math.max(1, cache.lastKnownGoodCount - 2)
      : 1

  console.log('snapshot: bootstrap relay =', cfg.bootstrapRelay)
  const readRelays = await loadReadRelays(cfg.bootstrapRelay, cfg.authorPubkeyHex)
  console.log('snapshot: read relays =', readRelays.join(', '))

  const fetched = await fetchEvents(readRelays, cfg.authorPubkeyHex)
  console.log(
    `snapshot: ${fetched.responded.length}/${fetched.queried.length} relays geantwortet, ` +
      `${fetched.events.length} events roh`,
  )

  const posts: SignedEvent[] = []
  const deletions: SignedEvent[] = []
  for (const ev of fetched.events) {
    if (ev.kind === 30023) posts.push(ev)
    else if (ev.kind === 5) deletions.push(ev)
  }

  const dedupedPosts = dedupByDtag(posts)
  const filtered = filterDeleted(dedupedPosts, deletions, cfg.authorPubkeyHex)

  const previousDeletedCoords = new Set(cache?.deletedCoords ?? [])
  const newlyDeletedCount = deletions.flatMap((d) =>
    d.tags.filter((t) => t[0] === 'a' && t[1] && !previousDeletedCoords.has(t[1])).map((t) => t[1])
  ).length

  runChecks({
    relaysQueried: fetched.queried.length,
    relaysResponded: fetched.responded.length,
    eventCount: filtered.length,
    minEvents,
    lastKnownGoodCount: cache?.lastKnownGoodCount,
    newDeletionsCount: newlyDeletedCount,
    allowShrink,
  })

  const titleByDtag = new Map<string, string>()
  for (const ev of filtered) {
    const d = ev.tags.find((t) => t[0] === 'd')?.[1]
    const title = ev.tags.find((t) => t[0] === 'title')?.[1]
    if (d && title) titleByDtag.set(d, title)
  }
  const postJsons = filtered.map((ev) => buildPostJson(ev, titleByDtag))

  await writeOutput(outDir, {
    generatedAt: new Date().toISOString(),
    authorPubkey: cfg.authorPubkeyHex,
    relaysQueried: fetched.queried,
    relaysResponded: fetched.responded,
    posts: postJsons,
  })

  const allDeletedCoords = deletions.flatMap((d) =>
    d.tags.filter((t) => t[0] === 'a' && t[1]).map((t) => t[1] as string)
  )
  const newCache: CacheState = {
    lastKnownGoodCount: filtered.length,
    deletedCoords: [...new Set(allDeletedCoords)],
  }
  await writeCache(cachePath, newCache)

  console.log(`snapshot: ${filtered.length} posts geschrieben nach ${outDir}`)
  return 0
}

if (import.meta.main) {
  try {
    Deno.exit(await main())
  } catch (err) {
    console.error('snapshot: HARD-FAIL —', err instanceof Error ? err.message : String(err))
    Deno.exit(1)
  }
}

Step 2.10.2: Type-Check

Run: cd snapshot && deno check src/cli.ts Expected: 0 errors.

Step 2.10.3: Commit

git add snapshot/src/cli.ts
git commit -m "feat(snapshot): cli-entrypoint

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"

Task 2.11: End-to-End Smoke-Run gegen echte Relays

Files: keine

Step 2.11.1: Snapshot ausführen

cd snapshot && deno task snapshot

Erwartung:

Console-Output zeigt 5/5 Relays geantwortet.
27 (oder mehr) Posts gefunden.
snapshot/output/index.json existiert mit post_count >= 27.
snapshot/output/posts/bibel-selfies.json existiert mit lang: "de" und einer translations[]-Liste, die bible-selfies enthält.
snapshot/output/.last-snapshot.json existiert.
Step 2.11.2: Spot-Checks

cd snapshot
jq '.post_count, .posts[0]' output/index.json
jq '.title, .lang, .translations' output/posts/bibel-selfies.json
jq '.title, .lang, .translations' output/posts/bible-selfies.json

Erwartung:

Beide Sprachvarianten verweisen wechselseitig aufeinander.
DE-Post hat lang: "de", EN-Post hat lang: "en".
Step 2.11.3: Commit "snapshot output ist nicht im Repo"

output/ ist via .gitignore ausgeschlossen — nichts zu committen.

Etappe 3 — Snapshot in CI

Task 3.1: Workflow-Datei erweitern

Files:

Modify: .github/workflows/publish.yml
Step 3.1.1: Aktuellen Workflow lesen

cat .github/workflows/publish.yml

Step 3.1.2: Snapshot-Job ergänzen

Den existierenden Workflow um einen snapshot-Step erweitern, der vor dem SvelteKit-Build läuft. Konkrete YAML-Syntax orientiert sich am bestehenden Workflow — nach dem publish-Step kommt:

      - name: Run snapshot
        working-directory: snapshot
        env:
          AUTHOR_PUBKEY_HEX: ${{ secrets.AUTHOR_PUBKEY_HEX }}
          BOOTSTRAP_RELAY: wss://relay.primal.net
        run: deno task snapshot

(Die Build/Deploy-Etappen folgen erst in Etappe 4 — in diesem Schritt erzeugen wir nur den Snapshot, das Output verbleibt im CI-Artefakt-Cache, beeinflusst die SPA noch nicht.)

Step 3.1.3: Workflow-Lint mit actionlint (falls verfügbar)

which actionlint && actionlint .github/workflows/publish.yml || echo "actionlint nicht installiert — manuelle YAML-Validierung"

Wenn nicht verfügbar: YAML-Indent händisch prüfen.

Step 3.1.4: Commit

git add .github/workflows/publish.yml
git commit -m "ci: snapshot-job vor svelte-build

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"

Step 3.1.5: Push + Action-Run prüfen

git push origin main
gh run watch

Erwartung: Snapshot-Step grün, Output-Statistik im Log sichtbar.

Etappe 4 — Detail-Route auf Prerender umstellen

In dieser Etappe wird die SPA umgebaut: [...slug]/+page.ts lädt aus Snapshot-JSON, +page.svelte rendert daraus, <svelte:head> setzt OG-Tags, der Runtime-Fallback bleibt für Slugs außerhalb des Snapshots erhalten.

Task 4.1: SSR + Prerender für Detail-Route aktivieren

Files:

Create: app/src/routes/[...slug]/+page.ts (rewrite)

Hinweis: +layout.ts hat global ssr = false. Pro-Route-Override durch lokale Page-Optionen.

Step 4.1.1: +page.ts umschreiben

Komplette neue Fassung:

import { error, redirect } from '@sveltejs/kit'
import { parseLegacyUrl, canonicalPostPath } from '$lib/url/legacy'
import type { EntryGenerator, PageLoad } from './$types'
import { browser } from '$app/environment'

export const ssr = true
export const prerender = true
export const trailingSlash = 'always'

interface SnapshotIndex {
  posts: Array<{ slug: string; lang: string; title: string }>
}

interface PostJson {
  slug: string
  event_id: string
  created_at: number
  published_at: number
  title: string
  summary: string
  lang: string
  cover_image: { url: string; alt?: string; width?: number; height?: number; mime?: string } | null
  content_markdown: string
  tags: string[]
  naddr: string
  habla_url: string
  translations: Array<{ lang: string; slug: string; title: string }>
}

let cachedIndex: SnapshotIndex | undefined
async function readIndex(): Promise<SnapshotIndex> {
  if (cachedIndex) return cachedIndex
  const fs = await import('node:fs/promises')
  const path = await import('node:path')
  const dir = path.resolve('../snapshot/output')
  const text = await fs.readFile(path.join(dir, 'index.json'), 'utf-8')
  cachedIndex = JSON.parse(text) as SnapshotIndex
  return cachedIndex
}

async function readPost(slug: string): Promise<PostJson | undefined> {
  try {
    const fs = await import('node:fs/promises')
    const path = await import('node:path')
    const dir = path.resolve('../snapshot/output')
    const text = await fs.readFile(path.join(dir, 'posts', `${slug}.json`), 'utf-8')
    return JSON.parse(text) as PostJson
  } catch {
    return undefined
  }
}

export const entries: EntryGenerator = async () => {
  const idx = await readIndex()
  return idx.posts.map((p) => ({ slug: p.slug }))
}

export const load: PageLoad = async ({ url }) => {
  const pathname = url.pathname

  const legacyDtag = parseLegacyUrl(pathname)
  if (legacyDtag) {
    throw redirect(301, canonicalPostPath(legacyDtag))
  }

  const segments = pathname.replace(/^\/+|\/+$/g, '').split('/')
  if (segments.length !== 1 || !segments[0]) {
    throw error(404, 'Seite nicht gefunden')
  }
  const dtag = decodeURIComponent(segments[0])

  if (!browser) {
    const snapshot = await readPost(dtag)
    if (snapshot) return { dtag, snapshot }
  }

  return { dtag, snapshot: null }
}

Begründung des browser-Guards: Während des Builds läuft load in Node und liest aus snapshot/output/. Im Browser (Runtime-Hydration für nicht-prerenderte Slugs) gibt's kein Snapshot, dort fällt data.snapshot auf null, und +page.svelte lädt via Runtime-Relay-Fetch.

Step 4.1.2: Type-Check

Run: cd app && npm run check Expected: 0 errors.

Step 4.1.3: Commit

git add app/src/routes/[\.\.\.slug]/+page.ts
git commit -m "feat(spa): detail-route auf prerender + ssr=true

Lokaler override des global ssr=false. entries() liest aus
snapshot/output/index.json, load() pro-slug aus posts/<slug>.json.
runtime-fallback bleibt fuer slugs ausserhalb des snapshots.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"

Task 4.2: `+page.svelte` mit Snapshot-Rendering und OG-Tags

Files:

Modify: app/src/routes/[...slug]/+page.svelte
Step 4.2.1: Komplette neue Fassung schreiben

<script lang="ts">
  import type { NostrEvent } from '$lib/nostr/loaders'
  import { loadPost } from '$lib/nostr/loaders'
  import { AUTHOR_PUBKEY_HEX } from '$lib/nostr/config'
  import { buildHablaLink } from '$lib/nostr/naddr'
  import PostView from '$lib/components/PostView.svelte'
  import LoadingOrError from '$lib/components/LoadingOrError.svelte'
  import { renderMarkdown } from '$lib/render/markdown'
  import { t } from '$lib/i18n'
  import { get } from 'svelte/store'
  import { onMount } from 'svelte'

  let { data } = $props()
  const dtag = $derived(data.dtag)
  const snapshot = $derived(data.snapshot)

  let post: NostrEvent | null = $state(null)
  let loading = $state(false)
  let error: string | null = $state(null)

  const hablaLink = $derived(
    buildHablaLink({
      pubkey: AUTHOR_PUBKEY_HEX,
      kind: 30023,
      identifier: dtag,
    }),
  )

  const siteUrl = '__SITE_URL__'
  const canonical = $derived(`${siteUrl}/${snapshot?.slug ?? dtag}/`)
  const ogImage = $derived(
    snapshot?.cover_image?.url ?? `${siteUrl}/joerg-profil-2024.webp`,
  )
  const ogImageAlt = $derived(
    snapshot?.cover_image?.alt ?? snapshot?.title ?? 'Jörg Lohrer',
  )
  const bodyHtmlPrerendered = $derived(
    snapshot ? renderMarkdown(snapshot.content_markdown) : '',
  )

  onMount(() => {
    if (snapshot) return
    loading = true
    const currentDtag = dtag
    loadPost(currentDtag)
      .then((p) => {
        if (currentDtag !== dtag) return
        if (!p) error = get(t)('post.not_found', { values: { slug: currentDtag } })
        else post = p
      })
      .catch((e) => {
        if (currentDtag !== dtag) return
        error = e instanceof Error ? e.message : get(t)('post.unknown_error')
      })
      .finally(() => {
        if (currentDtag === dtag) loading = false
      })
  })

  const jsonLd = $derived(
    snapshot
      ? JSON.stringify({
          '@context': 'https://schema.org',
          '@type': 'Article',
          headline: snapshot.title,
          description: snapshot.summary,
          datePublished: new Date(snapshot.published_at * 1000).toISOString(),
          dateModified: new Date(snapshot.created_at * 1000).toISOString(),
          author: { '@type': 'Person', name: 'Jörg Lohrer' },
          inLanguage: snapshot.lang,
          image: ogImage,
          mainEntityOfPage: canonical,
        })
      : '',
  )
</script>

<svelte:head>
  {#if snapshot}
    <title>{snapshot.title} – Jörg Lohrer</title>
    <meta name="description" content={snapshot.summary} />
    <link rel="canonical" href={canonical} />
    <meta property="og:type" content="article" />
    <meta property="og:title" content={snapshot.title} />
    <meta property="og:description" content={snapshot.summary} />
    <meta property="og:url" content={canonical} />
    <meta property="og:locale" content={snapshot.lang === 'de' ? 'de_DE' : 'en_US'} />
    <meta property="og:image" content={ogImage} />
    <meta property="og:image:alt" content={ogImageAlt} />
    {#if snapshot.cover_image?.width}
      <meta property="og:image:width" content={String(snapshot.cover_image.width)} />
    {/if}
    {#if snapshot.cover_image?.height}
      <meta property="og:image:height" content={String(snapshot.cover_image.height)} />
    {/if}
    <meta property="article:published_time" content={new Date(snapshot.published_at * 1000).toISOString()} />
    <meta name="twitter:card" content="summary_large_image" />
    <meta name="twitter:title" content={snapshot.title} />
    <meta name="twitter:description" content={snapshot.summary} />
    <meta name="twitter:image" content={ogImage} />
    {#each snapshot.translations as alt}
      <link rel="alternate" hreflang={alt.lang} href={`${siteUrl}/${alt.slug}/`} />
    {/each}
    <link rel="alternate" hreflang="x-default" href={canonical} />
    <script type="application/ld+json">{jsonLd}</script>
  {/if}
</svelte:head>

<nav class="breadcrumb"><a href="/">{$t('post.back_to_overview')}</a></nav>

{#if snapshot}
  <article class="post">
    <h1 class="post-title">{snapshot.title}</h1>
    {#if snapshot.cover_image}
      <p class="cover">
        <img src={snapshot.cover_image.url} alt={snapshot.cover_image.alt ?? ''} />
      </p>
    {/if}
    {#if snapshot.summary}
      <p class="summary">{snapshot.summary}</p>
    {/if}
    <div class="body">{@html bodyHtmlPrerendered}</div>
  </article>
{:else}
  <LoadingOrError {loading} {error} {hablaLink} />
  {#if post}
    <PostView event={post} />
  {/if}
{/if}

<style>
  .breadcrumb {
    font-size: 0.9rem;
    margin-bottom: 1rem;
  }
  .breadcrumb a {
    color: var(--accent);
    text-decoration: none;
  }
  .breadcrumb a:hover {
    text-decoration: underline;
  }
  .post-title {
    font-size: 1.5rem;
    line-height: 1.25;
    margin: 0 0 0.4rem;
    word-wrap: break-word;
  }
  @media (min-width: 640px) {
    .post-title {
      font-size: 2rem;
      line-height: 1.2;
    }
  }
  .cover {
    max-width: 480px;
    margin: 1rem auto 1.5rem;
  }
  .cover img {
    display: block;
    width: 100%;
    height: auto;
    border-radius: 4px;
  }
  .summary {
    font-style: italic;
    color: var(--muted);
  }
  .body :global(img) {
    max-width: 100%;
    height: auto;
    border-radius: 4px;
  }
  .body :global(a) {
    color: var(--accent);
    word-break: break-word;
  }
  .body :global(pre) {
    background: var(--code-bg);
    padding: 0.8rem;
    border-radius: 4px;
    overflow-x: auto;
    font-size: 0.88em;
    max-width: 100%;
  }
  .body :global(code) {
    background: var(--code-bg);
    padding: 1px 4px;
    border-radius: 3px;
    font-size: 0.92em;
    word-break: break-word;
  }
  .body :global(pre code) {
    padding: 0;
    background: none;
    word-break: normal;
  }
  .body :global(hr) {
    border: none;
    border-top: 1px solid var(--border);
    margin: 2rem 0;
  }
  .body :global(blockquote) {
    border-left: 3px solid var(--border);
    padding: 0 0 0 1rem;
    margin: 1rem 0;
    color: var(--muted);
  }
</style>

Diese Fassung rendert auf Prerender-Pfad direkt aus dem Snapshot (inklusive <svelte:head> mit OG/Twitter/JSON-LD/hreflang) und fällt für Slugs ohne Snapshot zurück auf die alte loadPost+PostView-Logik. Reactions/Replies kommen in Task 4.3.

Step 4.2.2: Type-Check

Run: cd app && npm run check Expected: 0 errors.

Step 4.2.3: Commit

git add 'app/src/routes/[...slug]/+page.svelte'
git commit -m "feat(spa): post-detail rendert prerendered aus snapshot

Snapshot-pfad: page+head komplett aus json, mit og/twitter/jsonld/hreflang.
Runtime-fallback: falls data.snapshot null, loadPost+PostView wie bisher.
Reactions/replies kommen im naechsten task.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"

Task 4.3: Reactions, Replies, Sprach-Switcher auf Snapshot-Pfad

Files:

Modify: app/src/routes/[...slug]/+page.svelte

Snapshot-Pfad braucht weiterhin Reactions, Replies, Sprach-Switcher. Diese Komponenten existieren als wiederverwendbare Bausteine (Reactions.svelte, ReplyComposer.svelte, ReplyList.svelte, LanguageAvailability.svelte, ExternalClientLinks.svelte) und brauchen unterschiedliche Inputs.

Step 4.3.1: Snapshot-Pfad um interaktive Komponenten erweitern

Im snapshot-Block der +page.svelte (innerhalb {#if snapshot} <article>...</article>) nach <div class="body">{@html bodyHtmlPrerendered}</div> einfügen — und die nötigen Imports oben ergänzen (Reactions, ReplyComposer, ReplyList, ExternalClientLinks, sowie SignedEvent für die optimistische Reply-Liste; LanguageAvailability braucht ein NostrEvent und passt darum nicht direkt — Snapshot-Pfad rendert den Switcher inline aus snapshot.translations):

    {#if snapshot.translations.length > 0}
      <p class="lang-switch">
        {$t(snapshot.lang === 'de' ? 'lang_switch.also_in_en' : 'lang_switch.also_in_de')}
        {#each snapshot.translations as alt}
          <a href={`/${alt.slug}/`}>{alt.title}</a>
        {/each}
      </p>
    {/if}
    {#if snapshot.tags.length > 0}
      <div class="tags">
        {#each snapshot.tags as tag}
          <a class="tag" href={`/tag/${encodeURIComponent(tag)}/`}>{tag}</a>
        {/each}
      </div>
    {/if}
    <Reactions dtag={snapshot.slug} />
    <ExternalClientLinks dtag={snapshot.slug} />
    <ReplyComposer dtag={snapshot.slug} eventId={snapshot.event_id} onPublished={handlePublished} />
    <ReplyList dtag={snapshot.slug} optimistic={optimisticReplies} />

Imports ganz oben ergänzen:

  import Reactions from '$lib/components/Reactions.svelte'
  import ReplyList from '$lib/components/ReplyList.svelte'
  import ReplyComposer from '$lib/components/ReplyComposer.svelte'
  import ExternalClientLinks from '$lib/components/ExternalClientLinks.svelte'
  import type { SignedEvent } from '$lib/nostr/signer'

  let optimisticReplies: NostrEvent[] = $state([])
  function handlePublished(signed: SignedEvent) {
    optimisticReplies = [...optimisticReplies, signed as unknown as NostrEvent]
  }

I18n-Keys, die hinzukommen:

lang_switch.also_in_en (DE: „Auch auf Englisch verfügbar:")
lang_switch.also_in_de (EN: „Also available in German:")
Step 4.3.2: i18n-Messages ergänzen

Files: app/src/lib/i18n/messages/de.json, app/src/lib/i18n/messages/en.json

DE-File: Eintrag unter lang_switch ergänzen:

"lang_switch": {
  "also_in_en": "Auch auf Englisch verfügbar:",
  "also_in_de": "Also available in German:"
}

EN-File analog (Werte gleich, Key-Struktur gleich).

Hinweis: existierende lang_switch-Keys (z.B. also_in_en/also_in_de aus LanguageAvailability) — bevor neu anlegen, prüfen, ob die Strings unter den Namen schon existieren. In dem Fall den existierenden Key wiederverwenden, keine Duplikate.

grep -A 5 'lang_switch' app/src/lib/i18n/messages/de.json

Step 4.3.3: Type-Check

Run: cd app && npm run check Expected: 0 errors.

Step 4.3.4: Build lokal testen

cd snapshot && deno task snapshot
cd ../app && npm run build
ls build | head -20
ls build/bibel-selfies/index.html
grep -o 'og:title[^<]*' build/bibel-selfies/index.html
grep -o 'og:image[^<]*' build/bibel-selfies/index.html
grep -o 'application/ld+json[^<]*' build/bibel-selfies/index.html

Erwartung:

build/<slug>/index.html für jeden Snapshot-Slug existiert.
OG-Tags und JSON-LD im HTML enthalten.
Keine Build-Fehler.
Step 4.3.5: Dev-Server smoke-test

cd app && npm run dev &
sleep 3
curl -s http://localhost:5173/bibel-selfies/ | head -20
kill %1

Erwartung: HTML-Ausgabe, kein 500.

Step 4.3.6: Commit

git add 'app/src/routes/[...slug]/+page.svelte' app/src/lib/i18n/messages/
git commit -m "feat(spa): snapshot-pfad mit reactions/replies/langs/tags

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"

Task 4.4: Hosting-Test auf svelte.joerg-lohrer.de

Files: keine

Step 4.4.1: Snapshot lokal frisch ziehen

cd snapshot && deno task snapshot

Step 4.4.2: Deploy auf Entwicklungs-Subdomain

DEPLOY_TARGET=svelte ./scripts/deploy-svelte.sh

Step 4.4.3: Live-Verifikation

curl -s https://svelte.joerg-lohrer.de/bibel-selfies/ | grep -o 'og:title[^<]*'
curl -s https://svelte.joerg-lohrer.de/bibel-selfies/ | grep -o 'og:image[^<]*'
curl -s https://svelte.joerg-lohrer.de/bibel-selfies/ | grep -c 'application/ld+json'

Erwartung:

OG-Tags mit korrektem Titel.
og:image zeigt auf Blossom oder Site-Default.
Genau 1 JSON-LD-Block.
Step 4.4.4: Browser-Smoke-Test

Manuell https://svelte.joerg-lohrer.de/bibel-selfies/ im Browser öffnen, prüfen:

Post wird angezeigt.
Reactions, Replies, Sprach-Switcher funktionieren (= clientseitige Hydration läuft).
Browser-Tab-Title stimmt.
View-Source zeigt vollständigen Post-Body als HTML (= Crawler bekommt das gleiche).
Step 4.4.5: Wenn alles ok — Push für CI

git push origin main
gh run watch

Erwartung: Action grün, Snapshot+Build+Deploy auf prod-target durchgelaufen.

Etappe 5 — Runtime-Relay-Fetch in Detail-Route entfernen

Wenn Etappe 4 stabil ist, entfernen wir den Fallback-Pfad. Detail-Seite lebt dann ausschließlich vom Snapshot. Frische Nostr-first-Posts brauchen einen neuen Snapshot+Build, um zu erscheinen.

Task 5.1: Fallback-Pfad ausbauen

Files:

Modify: app/src/routes/[...slug]/+page.svelte
Modify: app/src/routes/[...slug]/+page.ts
Step 5.1.1: +page.ts — 404 für unbekannte Slugs

Komplettersatz für load:

export const load: PageLoad = async ({ url }) => {
  const pathname = url.pathname

  const legacyDtag = parseLegacyUrl(pathname)
  if (legacyDtag) {
    throw redirect(301, canonicalPostPath(legacyDtag))
  }

  const segments = pathname.replace(/^\/+|\/+$/g, '').split('/')
  if (segments.length !== 1 || !segments[0]) {
    throw error(404, 'Seite nicht gefunden')
  }
  const dtag = decodeURIComponent(segments[0])

  if (!browser) {
    const snapshot = await readPost(dtag)
    if (!snapshot) throw error(404, 'Post nicht gefunden')
    return { dtag, snapshot }
  }

  throw error(404, 'Post nicht gefunden')
}

Step 5.1.2: +page.svelte — Fallback-Pfad weg

Im <script>: loadPost, PostView, LoadingOrError, loading, error, post, onMount, hablaLink, t, get Imports und State entfernen.

Im Template: Block {:else} <LoadingOrError ... /> {#if post} <PostView ... /> {/if} entfernen, sodass nur noch der Snapshot-Pfad bleibt.

Step 5.1.3: Type-Check

Run: cd app && npm run check Expected: 0 errors. Möglicherweise rutschen jetzt unbenutzte Imports aus früheren Iterationen rein — die mit-entfernen.

Step 5.1.4: Commit

git add 'app/src/routes/[...slug]/+page.ts' 'app/src/routes/[...slug]/+page.svelte'
git commit -m "refactor(spa): runtime-fallback fuer detail-route entfernt

Detail-route lebt jetzt ausschliesslich vom snapshot. Slugs ausserhalb
des snapshots = 404. Frische nostr-first-posts erscheinen erst nach
naechstem snapshot+build-lauf.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"

Task 5.2: Live-Verifikation auf Staging und Prod

Files: keine

Step 5.2.1: Push, CI-Lauf, dann curl-Verifikation

git push origin main
gh run watch
# Nach CI-Erfolg:
curl -sI https://joerg-lohrer.de/bibel-selfies/ | head -3
curl -s https://joerg-lohrer.de/bibel-selfies/ | grep -o '<title[^<]*</title>'

Erwartung:

HTTP 200.
<title>Bibel-Selfies – Jörg Lohrer</title>.
Step 5.2.2: Social-Media-Preview-Validation

Manuelle Checks (External-Tool-Calls — keine automatisierbare Anforderung):

LinkedIn Post-Inspector: https://www.linkedin.com/post-inspector/inspect/https%3A%2F%2Fjoerg-lohrer.de%2Fbibel-selfies%2F
Mastodon-Test: Link in einer Test-Instanz posten, Preview ansehen.
Twitter Card Validator (falls noch erreichbar) oder Browser-DevTools auf "View Page Source".

Erwartung: Titel, Beschreibung, Bild korrekt.

Etappe 6 — Deploy mit `lftp mirror --delete` (optional)

Aktuelles Skript lädt jede Datei einzeln per curl hoch — gelöschte Posts und veraltete Hash-Bundles bleiben auf dem Server. Etappe 6 stellt auf lftp mirror mit Phasen-Trennung um.

Diese Etappe ist nicht-blockierend: ohne sie bleiben alte Asset-Hashes liegen (kein funktionaler Schaden, nur Müll im Webroot). Nur ausführen, wenn Lust drauf ist oder der Server-Zustand unübersichtlich wird.

Task 6.1: lftp installiert prüfen + Phasen-Skript

Files:

Modify: scripts/deploy-svelte.sh
Step 6.1.1: lftp lokal verfügbar?

which lftp || brew install lftp

Step 6.1.2: Skript-Block für Upload+Delete in zwei Phasen

Innerhalb scripts/deploy-svelte.sh, den Upload-Block (find + curl-Loop) ersetzen durch:

echo "Phase 1: Assets hochladen (ohne Delete) …"
lftp -c "
  set ssl:verify-certificate no
  set ftp:ssl-protect-data yes
  set ftp:ssl-allow yes
  set ftp:ssl-force yes
  open -u $FTP_USER,$FTP_PASS $FTP_HOST
  mirror -R --include-glob='_app/**' --include-glob='*.png' --include-glob='*.webp' --include-glob='*.jpg' --include-glob='*.svg' --include-glob='*.css' --include-glob='*.js' $BUILD_DIR $FTP_REMOTE_PATH
"

echo "Phase 2: HTML hochladen (ohne Delete) …"
lftp -c "
  set ssl:verify-certificate no
  set ftp:ssl-protect-data yes
  set ftp:ssl-allow yes
  set ftp:ssl-force yes
  open -u $FTP_USER,$FTP_PASS $FTP_HOST
  mirror -R --include-glob='*.html' $BUILD_DIR $FTP_REMOTE_PATH
"

echo "Phase 3: Obsolete Server-Dateien entfernen …"
lftp -c "
  set ssl:verify-certificate no
  set ftp:ssl-protect-data yes
  set ftp:ssl-allow yes
  set ftp:ssl-force yes
  open -u $FTP_USER,$FTP_PASS $FTP_HOST
  mirror -R --delete --only-existing --exclude-glob='.well-known/' --exclude-glob='joerg-profil*' --exclude-glob='favicon*' --exclude-glob='apple-touch*' --exclude-glob='android-chrome*' $BUILD_DIR $FTP_REMOTE_PATH
"

Hinweis: TLS-1.2-Constraint ist hier nicht direkt setzbar wie bei curl --tls-max 1.2. lftp verhandelt selbst — falls TLS-1.3-Probleme wie bei All-Inkl wieder auftreten, mit set ssl:cipher-list "TLSv1.2" einschränken.

Step 6.1.3: Trockenlauf gegen DEPLOY_TARGET=svelte

DEPLOY_TARGET=svelte ./scripts/deploy-svelte.sh

Erwartung: drei Phasen-Logs, am Ende erreichbarer Build, keine 500er.

Step 6.1.4: Live-Check

curl -sI https://svelte.joerg-lohrer.de/ | head -3

Step 6.1.5: Commit (falls Trockenlauf erfolgreich)

git add scripts/deploy-svelte.sh
git commit -m "feat(deploy): lftp mirror in drei phasen (assets, html, delete)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"

Self-Review-Checkliste (für Implementierende)

Wenn alle Etappen abgeschlossen sind, gegen diese Punkte prüfen:

cd snapshot && deno task test — alle Tests grün.
cd app && npm run test:unit — alle Tests grün.
cd app && npm run check — 0 errors.
curl -s https://joerg-lohrer.de/bibel-selfies/ | grep -c 'og:title' ≥ 1.
curl -s https://joerg-lohrer.de/bibel-selfies/ | grep -c 'application/ld+json' = 1.
LinkedIn Post-Inspector zeigt korrekten Titel + Bild.
Browser View-Source zeigt vollständigen Body als HTML.
joerg-lohrer.de (Homepage) und /archiv/ rendern weiterhin korrekt (SPA-Pfad unverändert).
Nostr-Sprachvarianten verlinken weiterhin wechselseitig (snapshot.translations + LanguageAvailability arbeiten parallel — der eine im Snapshot-Pfad, die andere für SPA-Routen).

66 KiB Raw Blame History Unescape Escape

Prerender-Snapshot Implementation Plan

Etappe 1 — renderMarkdown Node-kompatibel

Task 1.1: Failing Node-Test für renderMarkdown

Task 1.2: isomorphic-dompurify einführen

Etappe 2 — Snapshot-Modul (Deno)

Task 2.1: Modul-Skelett mit deno.jsonc

Task 2.2: Config-Modul mit Tests

Task 2.3: Dedup-by-d-tag mit Test

Task 2.4: NIP-09-Filter mit Test

Task 2.5: Plausibilitäts-Checks mit Test

Task 2.6: JSON-Builder pro Post mit Test

Task 2.6.b: Cover-Image-HEAD-Probe

Task 2.7: Cache-/Last-known-good-Modul

Task 2.8: Output-Writer (index.json + posts/.json)

Task 2.9: Relay-Loader (Bootstrap + Event-Fetch)

Task 2.10: CLI-Entrypoint

Task 2.11: End-to-End Smoke-Run gegen echte Relays

Etappe 3 — Snapshot in CI

Task 3.1: Workflow-Datei erweitern

Etappe 4 — Detail-Route auf Prerender umstellen

Task 4.1: SSR + Prerender für Detail-Route aktivieren

Task 4.2: +page.svelte mit Snapshot-Rendering und OG-Tags

Task 4.3: Reactions, Replies, Sprach-Switcher auf Snapshot-Pfad

Task 4.4: Hosting-Test auf svelte.joerg-lohrer.de

Etappe 5 — Runtime-Relay-Fetch in Detail-Route entfernen

Task 5.1: Fallback-Pfad ausbauen

Task 5.2: Live-Verifikation auf Staging und Prod

Etappe 6 — Deploy mit lftp mirror --delete (optional)

Task 6.1: lftp installiert prüfen + Phasen-Skript

Self-Review-Checkliste (für Implementierende)

66 KiB

Raw Blame History

Etappe 1 — `renderMarkdown` Node-kompatibel

Task 4.2: `+page.svelte` mit Snapshot-Rendering und OG-Tags

Etappe 6 — Deploy mit `lftp mirror --delete` (optional)