Merge: t-paliad-275 — HL-formatted skeleton template with placeholders (m/paliad#107)

2026-05-25 16:37:34 +02:00
parent 7368e7012b f2fbf93adf
commit 930771a898
3 changed files with 517 additions and 13 deletions
--- a/internal/handlers/files.go
+++ b/internal/handlers/files.go
@@ -79,6 +79,24 @@ var fileRegistry = map[string]fileEntry{
 		RepoName:     "mWorkRepo",
 		FilePath:     "6 - material/Templates/Word/Paliad/" + branding.Name + "/_skeleton.docx",
 	},
+	// Firm-formatted skeleton (t-paliad-275). Carries the same 48-key
+	// placeholder bag as the universal _skeleton.docx, but additionally
+	// preserves every HL paragraph + character style from the HL Patents
+	// Style .dotm (HLpat-Heading-H1..H5, HLpat-Body-B0, HLpat-Header-Section,
+	// HLpat-Table-Recitals-*, HLpat-Signature, …) and the firm letterhead
+	// (header logo + firm-address footer). Slotted ahead of the universal
+	// skeleton in the fallback chain so any submission_code without a
+	// dedicated per-code template still renders as a real firm-branded
+	// Schriftsatz with variables substituted, rather than a plain skeleton.
+	// Generated via scripts/gen-hl-skeleton-template against the .dotm.
+	firmSkeletonSubmissionSlug: {
+		RawURL:       "https://mgit.msbls.de/m/mWorkRepo/raw/branch/main/6%20-%20material/Templates/Word/Paliad/" + branding.Name + "/_firm-skeleton.docx",
+		DownloadName: branding.Name + " — Firm Schriftsatz-Skelett.docx",
+		ContentType:  "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+		RepoOwner:    "m",
+		RepoName:     "mWorkRepo",
+		FilePath:     "6 - material/Templates/Word/Paliad/" + branding.Name + "/_firm-skeleton.docx",
+	},
 }

 // skeletonSubmissionSlug names the universal skeleton template inside
@@ -87,6 +105,14 @@ var fileRegistry = map[string]fileEntry{
 // the same string the registry uses.
 const skeletonSubmissionSlug = "submission/_skeleton.docx"

+// firmSkeletonSubmissionSlug names the firm-formatted skeleton template
+// inside the shared fileRegistry cache (t-paliad-275). Same placeholder
+// surface as skeletonSubmissionSlug; carries HL paragraph + character
+// styles from the source .dotm on top. Sits between the per-code
+// template and the generic universal skeleton in the fallback chain so
+// codes without a dedicated template still render with firm branding.
+const firmSkeletonSubmissionSlug = "submission/_firm-skeleton.docx"
+
 // submissionTemplateRegistry maps a deadline-rule submission_code to a
 // fileRegistry slug. Lookup order matches the cronus design fallback
 // chain §8: per-firm `templates/{FIRM_NAME}/{code}.docx` first, then
@@ -219,11 +245,28 @@ func handleFileRefresh(w http.ResponseWriter, r *http.Request) {
 // call warms the cache synchronously from mWorkRepo via Gitea; later
 // calls return immediately while a background refresh runs.
 func fetchSubmissionSkeletonBytes(ctx context.Context) ([]byte, string, error) {
-	entry, ok := fileRegistry[skeletonSubmissionSlug]
+	return fetchSubmissionTemplateSlug(ctx, skeletonSubmissionSlug)
+}
+
+// fetchFirmSkeletonBytes returns the cached firm-formatted skeleton
+// template bytes (HL paragraph/character styles + 48-key placeholder
+// bag) plus its provenance SHA. Sits between the per-code template and
+// the generic universal skeleton in resolveSubmissionTemplate's
+// fallback chain (t-paliad-275). Same stale-while-revalidate caching
+// as the other Gitea-backed template parts.
+func fetchFirmSkeletonBytes(ctx context.Context) ([]byte, string, error) {
+	return fetchSubmissionTemplateSlug(ctx, firmSkeletonSubmissionSlug)
+}
+
+// fetchSubmissionTemplateSlug is the shared cache-aware fetcher used by
+// the firm-skeleton and universal-skeleton accessors. Factored out so
+// the two paths can't drift apart on caching semantics.
+func fetchSubmissionTemplateSlug(ctx context.Context, slug string) ([]byte, string, error) {
+	entry, ok := fileRegistry[slug]
 	if !ok {
-		return nil, "", fmt.Errorf("file proxy: %s not registered", skeletonSubmissionSlug)
+		return nil, "", fmt.Errorf("file proxy: %s not registered", slug)
 	}
-	ce := getCacheEntry(skeletonSubmissionSlug)
+	ce := getCacheEntry(slug)

 	ce.mu.RLock()
 	hasData := len(ce.data) > 0
@@ -241,7 +284,7 @@ func fetchSubmissionSkeletonBytes(ctx context.Context) ([]byte, string, error) {
 	ce.mu.RLock()
 	defer ce.mu.RUnlock()
 	if len(ce.data) == 0 {
-		return nil, "", fmt.Errorf("file proxy: %s cache empty after fetch", skeletonSubmissionSlug)
+		return nil, "", fmt.Errorf("file proxy: %s cache empty after fetch", slug)
 	}
 	out := make([]byte, len(ce.data))
 	copy(out, ce.data)
--- a/internal/handlers/submission_drafts.go
+++ b/internal/handlers/submission_drafts.go
@@ -904,19 +904,25 @@ func buildSubmissionDraftView(ctx context.Context, d *services.SubmissionDraft,

 // resolveSubmissionTemplate returns the .docx bytes for the given
 // submission code. Lookup order matches the cronus design fallback chain
-// §8 plus the t-paliad-259 universal-skeleton slot:
+// §8 plus the t-paliad-259 universal-skeleton slot and the t-paliad-275
+// firm-skeleton slot:
 //
 //  1. per-firm per-submission_code template registered in
 //     submissionTemplateRegistry (e.g. de.inf.lg.erwidg.docx) — code-
 //     specific structure plus the full variable bag.
-//  2. universal _skeleton.docx — same variable bag, no submission_code-
-//     specific prose. Catches every code without a dedicated template
-//     so the editor preview / generate flow still has variables to
-//     substitute instead of falling through to the bare letterhead.
-//  3. universal HL Patents Style .dotm — macro-only letterhead, no
-//     placeholders. Final fallback when even the skeleton is unreachable
-//     (mWorkRepo outage etc.). Preserves the pre-t-paliad-259 behaviour
-//     for resilience.
+//  2. firm-formatted _firm-skeleton.docx — full HL paragraph + character
+//     styles (HLpat-Heading-H1..H5, HLpat-Body-B0, HLpat-Header-Section,
+//     HLpat-Table-Recitals-*, HLpat-Signature, …) preserved from the
+//     source .dotm, the firm letterhead header/footer, plus the full
+//     48-key placeholder bag. Catches every code without a dedicated
+//     template so the editor still renders firm-branded output.
+//  3. universal _skeleton.docx — same variable bag, no firm formatting.
+//     Backstop for when the firm skeleton is unreachable (e.g. a future
+//     firm hasn't authored one yet).
+//  4. universal HL Patents Style .dotm — macro-only letterhead, no
+//     placeholders. Final fallback when even both skeletons are
+//     unreachable (mWorkRepo outage etc.). Preserves the
+//     pre-t-paliad-259 behaviour for resilience.
 //
 // The returned SHA is the cache entry's commit SHA so the export audit
 // row can record provenance.
@@ -926,6 +932,11 @@ func resolveSubmissionTemplate(ctx context.Context, submissionCode string) ([]by
 	} else if found {
 		return data, sha, nil
 	}
+	if data, sha, err := fetchFirmSkeletonBytes(ctx); err == nil {
+		return data, sha, nil
+	} else {
+		log.Printf("submission_drafts: firm-skeleton fetch failed for code=%s, falling back to universal skeleton: %v", submissionCode, err)
+	}
 	if data, sha, err := fetchSubmissionSkeletonBytes(ctx); err == nil {
 		return data, sha, nil
 	} else {
--- a/scripts/gen-hl-skeleton-template/main.go
+++ b/scripts/gen-hl-skeleton-template/main.go
@@ -0,0 +1,450 @@
+// HL-firm skeleton submission template generator (t-paliad-275).
+//
+// Reads HLC's "HL Patents Style" .dotm letterhead, strips its VBA
+// macros and template-only artifacts, then emits a clean .docx that:
+//
+//  1. Preserves every HL paragraph + character style (HLpat-Heading-H1,
+//     HLpat-Body-B0, HLpat-Signature, HLpat-Table-Recitals-*, …) by
+//     keeping word/styles.xml, word/theme/*, word/numbering.xml,
+//     word/fontTable.xml, settings.xml, footnotes/endnotes from the
+//     source .dotm untouched.
+//  2. Preserves the firm letterhead (logo header + firm-address footer)
+//     by keeping word/header[12].xml + word/footer[12].xml and the
+//     sectPr that references them.
+//  3. Replaces word/document.xml with a Schriftsatz-shaped body that
+//     exercises every SubmissionVarsService placeholder (firm.*,
+//     today.*, user.*, project.*, parties.*, procedural_event.*, rule.*,
+//     deadline.*) — applying HL paragraph/character styles to each
+//     section so the rendered output reads as a real HL submission with
+//     variables substituted.
+//
+// Drop the output into HL/mWorkRepo at
+//
+//	6 - material/Templates/Word/Paliad/HLC/_firm-skeleton.docx
+//
+// so paliad's submission generator picks it up via the fallback chain.
+// Lookup order after this CL: per-firm per-code → _firm-skeleton.docx
+// (THIS file — HL formatting + placeholders) → universal _skeleton.docx
+// (generic skeleton from t-paliad-259) → bare HL Patents Style .dotm
+// (no placeholders). See internal/handlers/submission_drafts.go
+// resolveSubmissionTemplate.
+//
+// Why this is firm-specific: the .dotm carries HL-licensed fonts,
+// HL-branded logo media, and HLpat-prefixed style IDs. The output lives
+// under the firm-namespaced directory in mWorkRepo so a future firm gets
+// its own equivalent file generated against its own .dotm.
+//
+// Run:
+//
+//	go run ./scripts/gen-hl-skeleton-template \
+//	  -in /tmp/hl-patents-style.dotm \
+//	  -out /tmp/_firm-skeleton.docx
+//
+// Output is byte-stable across runs for a given input (zip mtimes
+// pinned).
+package main
+
+import (
+	"archive/zip"
+	"bytes"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+	"time"
+)
+
+func main() {
+	in := flag.String("in", "", "path to source HL Patents Style .dotm (required)")
+	out := flag.String("out", "_firm-skeleton.docx", "output .docx path")
+	flag.Parse()
+
+	if *in == "" {
+		fmt.Fprintln(os.Stderr, "gen-hl-skeleton-template: -in is required (path to HL Patents Style .dotm)")
+		os.Exit(2)
+	}
+
+	srcBytes, err := os.ReadFile(*in)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "gen-hl-skeleton-template: read source:", err)
+		os.Exit(1)
+	}
+
+	docx, err := buildDocx(srcBytes)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "gen-hl-skeleton-template:", err)
+		os.Exit(1)
+	}
+	if err := os.WriteFile(*out, docx, 0o644); err != nil {
+		fmt.Fprintln(os.Stderr, "gen-hl-skeleton-template: write:", err)
+		os.Exit(1)
+	}
+	fmt.Printf("wrote %s (%d bytes)\n", *out, len(docx))
+}
+
+// fixedTime pins every zip entry's mtime so successive runs over the
+// same .dotm produce byte-stable output. Useful for diffing the
+// generated file in PR review.
+var fixedTime = time.Date(2026, 5, 25, 0, 0, 0, 0, time.UTC)
+
+// dropPaths lists zip entries removed during the .dotm → .docx
+// conversion. VBA macros + their keymap binding + the template-only
+// glossary parts and ribbon customizations are all dead weight (and
+// some actively trigger Word's macro-security warning) — none of them
+// add anything to a placeholder-rich Schriftsatz starter.
+var dropPaths = map[string]bool{
+	"word/vbaProject.bin":              true,
+	"word/vbaData.xml":                 true,
+	"word/customizations.xml":          true,
+	"userCustomization/customUI.xml":   true,
+	"customUI/customUI14.xml":          true,
+	"word/glossary/document.xml":       true,
+	"word/glossary/_rels/document.xml.rels": true,
+	"word/glossary/fontTable.xml":      true,
+	"word/glossary/numbering.xml":      true,
+	"word/glossary/settings.xml":       true,
+	"word/glossary/styles.xml":         true,
+	"word/glossary/webSettings.xml":    true,
+}
+
+// rIdsToDrop names the document-rel ids whose targets are stripped
+// from the package (vbaProject, customizations.xml, glossary). They
+// must vanish from word/_rels/document.xml.rels so Word doesn't choke
+// on a dangling reference.
+var rIdsToDrop = map[string]bool{
+	"rId1":  true, // vbaProject.bin
+	"rId2":  true, // customizations.xml (keymap to VBA)
+	"rId21": true, // glossary/document.xml
+}
+
+func buildDocx(src []byte) ([]byte, error) {
+	zr, err := zip.NewReader(bytes.NewReader(src), int64(len(src)))
+	if err != nil {
+		return nil, fmt.Errorf("open source zip: %w", err)
+	}
+
+	var buf bytes.Buffer
+	zw := zip.NewWriter(&buf)
+
+	for _, f := range zr.File {
+		name := f.Name
+		if dropPaths[name] {
+			continue
+		}
+
+		body, err := readZipEntry(f)
+		if err != nil {
+			return nil, fmt.Errorf("read %s: %w", name, err)
+		}
+
+		switch name {
+		case "[Content_Types].xml":
+			body = []byte(patchContentTypes(string(body)))
+		case "_rels/.rels":
+			body = []byte(patchRootRels(string(body)))
+		case "word/_rels/document.xml.rels":
+			body = []byte(patchDocumentRels(string(body)))
+		case "word/document.xml":
+			body = []byte(buildDocumentXML())
+		}
+
+		hdr := &zip.FileHeader{
+			Name:     name,
+			Method:   zip.Deflate,
+			Modified: fixedTime,
+		}
+		w, err := zw.CreateHeader(hdr)
+		if err != nil {
+			return nil, fmt.Errorf("create %s: %w", name, err)
+		}
+		if _, err := w.Write(body); err != nil {
+			return nil, fmt.Errorf("write %s: %w", name, err)
+		}
+	}
+
+	if err := zw.Close(); err != nil {
+		return nil, fmt.Errorf("finalise zip: %w", err)
+	}
+	return buf.Bytes(), nil
+}
+
+func readZipEntry(f *zip.File) ([]byte, error) {
+	rc, err := f.Open()
+	if err != nil {
+		return nil, err
+	}
+	defer rc.Close()
+	return io.ReadAll(rc)
+}
+
+// patchContentTypes rewrites the macroEnabledTemplate part type to the
+// regular wordprocessingml.document type (a .dotm carries the macro
+// part type even on the body part), and removes Default/Override
+// entries that target now-deleted parts (vba binary, customizations,
+// glossary).
+func patchContentTypes(in string) string {
+	out := in
+	out = strings.ReplaceAll(out,
+		`<Override PartName="/word/document.xml" ContentType="application/vnd.ms-word.template.macroEnabledTemplate.main+xml"/>`,
+		`<Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/>`)
+
+	removals := []string{
+		`<Default Extension="bin" ContentType="application/vnd.ms-office.vbaProject"/>`,
+		`<Override PartName="/word/vbaData.xml" ContentType="application/vnd.ms-word.vbaData+xml"/>`,
+		`<Override PartName="/word/customizations.xml" ContentType="application/vnd.ms-word.keyMapCustomizations+xml"/>`,
+		`<Override PartName="/word/glossary/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml"/>`,
+		`<Override PartName="/word/glossary/numbering.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml"/>`,
+		`<Override PartName="/word/glossary/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml"/>`,
+		`<Override PartName="/word/glossary/settings.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml"/>`,
+		`<Override PartName="/word/glossary/webSettings.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.webSettings+xml"/>`,
+		`<Override PartName="/word/glossary/fontTable.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.fontTable+xml"/>`,
+	}
+	for _, r := range removals {
+		out = strings.ReplaceAll(out, r, "")
+	}
+	return out
+}
+
+// patchRootRels drops the userCustomization (ribbon mini-tab) and the
+// customUI14 extensibility relationships — both reference VBA-backed
+// UI we don't ship.
+func patchRootRels(in string) string {
+	out := in
+	out = stripRelByPrefix(out, `<Relationship Id="rId2" Type="http://schemas.microsoft.com/office/2006/relationships/ui/userCustomization"`)
+	out = stripRelByPrefix(out, `<Relationship Id="Rf8f70ab1afd0469a" Type="http://schemas.microsoft.com/office/2007/relationships/ui/extensibility"`)
+	return out
+}
+
+// patchDocumentRels drops the document-level rels whose targets we
+// stripped (vbaProject, customizations.xml, glossaryDocument).
+func patchDocumentRels(in string) string {
+	out := in
+	for rid := range rIdsToDrop {
+		needle := `<Relationship Id="` + rid + `" `
+		out = stripRelByPrefix(out, needle)
+	}
+	return out
+}
+
+// stripRelByPrefix removes the full <Relationship .../> element whose
+// open tag starts with the given prefix. Tolerates either a regular
+// closing tag (</Relationship>) or the more common self-closing form.
+func stripRelByPrefix(s, prefix string) string {
+	for {
+		start := strings.Index(s, prefix)
+		if start < 0 {
+			return s
+		}
+		// Find end of this element (next "/>"). The .dotm always uses the
+		// self-closing form for Relationship elements.
+		end := strings.Index(s[start:], "/>")
+		if end < 0 {
+			return s
+		}
+		s = s[:start] + s[start+end+2:]
+	}
+}
+
+// buildDocumentXML emits a Schriftsatz skeleton that exercises every
+// SubmissionVarsService placeholder (the canonical 48-key v1 contract
+// + the procedural_event.* canonical names + their rule.* legacy
+// aliases). The structure mirrors a real DE/UPC submission — title
+// block → court → rubrum → patent reference → submission title →
+// legal grounds → Sachverhalt/Anträge/Rechtsausführungen/Beweis →
+// signature → locale-variant verification footer.
+//
+// Each placeholder lives in its own <w:r> run so the renderer's pass-1
+// (format-preserving single-run replace) catches every key. HL
+// paragraph styles (HLpat-Heading-H1, HLpat-Header-Section, etc.) are
+// applied via pStyle, character styles via rStyle.
+//
+// The sectPr at the bottom is copied verbatim from the source .dotm
+// so the firm header/footer references (rId16=header1, rId17=footer1,
+// rId18=header2 first-page, rId19=footer2 first-page) keep resolving
+// after we replace the body. pgSz/pgMar/cols/docGrid match the .dotm
+// exactly — a lawyer printing this gets the same A4 layout the .dotm
+// produces.
+func buildDocumentXML() string {
+	var b strings.Builder
+	b.WriteString(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`)
+	b.WriteString(`<w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">`)
+	b.WriteString(`<w:body>`)
+
+	skeletonBanner(&b)
+
+	heading(&b, "HLpat-Heading-H1", "{{firm.name}}")
+	body0(&b, "Bearbeiter: {{user.display_name}}")
+	body0(&b, "E-Mail: {{user.email}} · Büro: {{user.office}}")
+	body0(&b, "Datum: {{today.long_de}} ({{today.iso}})")
+	body0(&b, "{{firm.signature_block}}")
+
+	headerSection(&b, "{{project.court}}")
+	body0(&b, "Aktenzeichen: {{project.case_number}}")
+	body0(&b, "Verfahrensart: {{project.proceeding.name}} ({{project.proceeding.code}})")
+	body0(&b, "Instanz: {{project.instance_level}}")
+
+	headerSubsection(&b, "In der Sache")
+
+	recitalsParty(&b, "{{parties.claimant.name}}")
+	recitalsPartyDetails(&b, "vertreten durch {{parties.claimant.representative}}")
+	recitalsRoles(&b, "— Klägerin / Patentinhaberin / Anmelderin —")
+
+	recitalsSequencer(&b, "gegen")
+
+	recitalsParty(&b, "{{parties.defendant.name}}")
+	recitalsPartyDetails(&b, "vertreten durch {{parties.defendant.representative}}")
+	recitalsRoles(&b, "— Beklagte / Einsprechende / Beschwerdegegnerin —")
+
+	recitalsSequencer(&b, "sowie")
+
+	recitalsParty(&b, "{{parties.other.name}}")
+	recitalsPartyDetails(&b, "vertreten durch {{parties.other.representative}}")
+	recitalsRoles(&b, "— Weitere Beteiligte —")
+
+	headerSubsection(&b, "Betreff")
+	body0(&b, "Streitpatent: {{project.patent_number}} (UPC-Schreibweise: {{project.patent_number_upc}})")
+	body0(&b, "Anmeldung: {{project.filing_date}} · Erteilung: {{project.grant_date}}")
+	body0(&b, "Projekttitel: {{project.title}}")
+	body0(&b, "Unsere Seite: {{project.our_side_de}} ({{project.our_side}})")
+	body0(&b, "Mandant: {{project.client_number}} · Matter: {{project.matter_number}}")
+	body0(&b, "Internes Aktenzeichen: {{project.reference}}")
+
+	heading(&b, "HLpat-Heading-H1", "{{procedural_event.name}}")
+	body0(&b, "(Schriftsatz-Code: {{procedural_event.code}})")
+	body0(&b, "Rechtsgrundlage: {{procedural_event.legal_source_pretty}} ({{procedural_event.legal_source}})")
+	body0(&b, "Typische Partei: {{procedural_event.primary_party}} · Schriftsatz-Typ: {{procedural_event.event_kind}}")
+
+	headerSubsection(&b, "Frist")
+	body0(&b, "Frist-Bezeichnung: {{deadline.title}}")
+	body0(&b, "Fälligkeit: {{deadline.due_date_long_de}} ({{deadline.due_date}})")
+	body0(&b, "Ursprüngliche Frist: {{deadline.original_due_date}}")
+	body0(&b, "Berechnet aus: {{deadline.computed_from}} · Quelle: {{deadline.source}}")
+
+	heading(&b, "HLpat-Heading-H2", "I. Sachverhalt")
+	body0(&b, "[Hier folgt der Sachverhalt. Diese Vorlage ist eine Skelett-Fassung — bitte gemäß Schriftsatz-Typ ({{procedural_event.name}}) ausformulieren.]")
+
+	heading(&b, "HLpat-Heading-H2", "II. Anträge")
+	requestsIntro(&b, "Es wird beantragt:")
+	requestsLevel1(&b, "[Antrag 1 — gemäß {{procedural_event.legal_source_pretty}}]")
+	requestsLevel1(&b, "[Antrag 2]")
+
+	heading(&b, "HLpat-Heading-H2", "III. Rechtsausführungen")
+	body0(&b, "[Hier folgen die Rechtsausführungen.]")
+
+	heading(&b, "HLpat-Heading-H2", "IV. Beweis")
+	evidenceOffering(&b, "Beweis: [Beweismittel — z. B. Anlage K1: {{project.patent_number}}]")
+
+	heading(&b, "HLpat-Heading-H2", "Schlussformel")
+	signature(&b, "{{today.long_de}}")
+	signature(&b, "")
+	signature(&b, "{{user.display_name}}")
+	signature(&b, "{{firm.name}}")
+
+	// Locale-aware verification block — exercises every EN/DE alias the
+	// variable bag carries plus the rule.* legacy aliases so a lawyer
+	// editing the template sees that both surfaces resolve. A real
+	// submission deletes this section after sanity-checking the render.
+	heading(&b, "HLpat-Heading-H3", "Locale-Varianten & Legacy-Aliase (SKELETON)")
+	body1(&b, "EN long date: {{today.long_en}} · Today (bare alias): {{today}}")
+	body1(&b, "Project our side (EN): {{project.our_side_en}} · Proceeding (EN): {{project.proceeding.name_en}}")
+	body1(&b, "Proceeding (DE): {{project.proceeding.name_de}}")
+	body1(&b, "Deadline EN long: {{deadline.due_date_long_en}}")
+	body1(&b, "Procedural event name (DE): {{procedural_event.name_de}} · (EN): {{procedural_event.name_en}}")
+	body1(&b, "Rule legacy aliases — name: {{rule.name}}, name_de: {{rule.name_de}}, name_en: {{rule.name_en}}")
+	body1(&b, "Rule legacy aliases — code: {{rule.submission_code}}, legal_source: {{rule.legal_source}}, legal_source_pretty: {{rule.legal_source_pretty}}")
+	body1(&b, "Rule legacy aliases — primary_party: {{rule.primary_party}}, event_type: {{rule.event_type}}")
+
+	// sectPr — copied verbatim from the source .dotm. Keeps the firm
+	// letterhead header (rId16=header1.xml, rId18=header2.xml first-page)
+	// and the firm-address footer (rId17, rId19) on every printed page.
+	b.WriteString(sectPrXML)
+
+	b.WriteString(`</w:body></w:document>`)
+	return b.String()
+}
+
+// sectPrXML matches the source .dotm's section properties exactly so
+// the firm header/footer refs and A4 page geometry round-trip.
+const sectPrXML = `<w:sectPr><w:headerReference w:type="default" r:id="rId16"/><w:footerReference w:type="default" r:id="rId17"/><w:headerReference w:type="first" r:id="rId18"/><w:footerReference w:type="first" r:id="rId19"/><w:pgSz w:w="11906" w:h="16838" w:code="9"/><w:pgMar w:top="567" w:right="1418" w:bottom="567" w:left="1418" w:header="284" w:footer="284" w:gutter="0"/><w:cols w:space="720"/><w:titlePg/><w:docGrid w:linePitch="286"/></w:sectPr>`
+
+func skeletonBanner(b *strings.Builder) {
+	b.WriteString(`<w:p><w:pPr><w:pStyle w:val="HLpat-Heading-H1"/></w:pPr><w:r><w:rPr><w:b/><w:color w:val="C00000"/></w:rPr><w:t xml:space="preserve">SKELETON — HL Patents Style mit Platzhaltern (nicht freigegeben)</w:t></w:r></w:p>`)
+}
+
+func heading(b *strings.Builder, style, text string)         { styledPara(b, style, "", text) }
+func headerSection(b *strings.Builder, text string)          { styledPara(b, "HLpat-Header-Section", "", text) }
+func headerSubsection(b *strings.Builder, text string)       { styledPara(b, "HLpat-Header-Subsection", "", text) }
+func body0(b *strings.Builder, text string)                  { styledPara(b, "HLpat-Body-B0", "", text) }
+func body1(b *strings.Builder, text string)                  { styledPara(b, "HLpat-Body-B1", "", text) }
+func recitalsParty(b *strings.Builder, text string)          { styledPara(b, "HLpat-Table-Recitals-Party", "", text) }
+func recitalsPartyDetails(b *strings.Builder, text string)   { styledPara(b, "HLpat-Table-Recitals-PartyDetails", "", text) }
+func recitalsRoles(b *strings.Builder, text string)          { styledPara(b, "HLpat-Table-Recitals-PartyRoles", "", text) }
+func recitalsSequencer(b *strings.Builder, text string)      { styledPara(b, "HLpat-Table-Recitals-Sequencers", "", text) }
+func requestsIntro(b *strings.Builder, text string)          { styledPara(b, "HLpat-Requests-Intro", "", text) }
+func requestsLevel1(b *strings.Builder, text string)         { styledPara(b, "HLpat-Requests-Level1", "", text) }
+func evidenceOffering(b *strings.Builder, text string)       { styledPara(b, "HLpat-EvidenceOffering", "", text) }
+func signature(b *strings.Builder, text string)              { styledPara(b, "HLpat-Signature", "", text) }
+
+// styledPara writes one paragraph with the given pStyle (paragraph
+// style id) and optional rStyle (character style applied to every run).
+// Empty style ids drop the corresponding wrapper. Placeholders inside
+// `text` are split into their own runs so the renderer's pass-1
+// single-run replace catches each one independently.
+func styledPara(b *strings.Builder, pStyle, rStyle, text string) {
+	b.WriteString(`<w:p>`)
+	if pStyle != "" {
+		b.WriteString(`<w:pPr><w:pStyle w:val="`)
+		b.WriteString(pStyle)
+		b.WriteString(`"/></w:pPr>`)
+	}
+	for _, seg := range splitOnPlaceholders(text) {
+		b.WriteString(`<w:r>`)
+		if rStyle != "" {
+			b.WriteString(`<w:rPr><w:rStyle w:val="`)
+			b.WriteString(rStyle)
+			b.WriteString(`"/></w:rPr>`)
+		}
+		b.WriteString(`<w:t xml:space="preserve">`)
+		b.WriteString(xmlEscape(seg))
+		b.WriteString(`</w:t></w:r>`)
+	}
+	b.WriteString(`</w:p>`)
+}
+
+func splitOnPlaceholders(s string) []string {
+	if s == "" {
+		return []string{""}
+	}
+	var out []string
+	for {
+		open := strings.Index(s, "{{")
+		if open < 0 {
+			out = append(out, s)
+			return out
+		}
+		close := strings.Index(s[open:], "}}")
+		if close < 0 {
+			out = append(out, s)
+			return out
+		}
+		end := open + close + 2
+		if open > 0 {
+			out = append(out, s[:open])
+		}
+		out = append(out, s[open:end])
+		s = s[end:]
+		if s == "" {
+			return out
+		}
+	}
+}
+
+func xmlEscape(s string) string {
+	s = strings.ReplaceAll(s, "&", "&amp;")
+	s = strings.ReplaceAll(s, "<", "&lt;")
+	s = strings.ReplaceAll(s, ">", "&gt;")
+	s = strings.ReplaceAll(s, `"`, "&quot;")
+	s = strings.ReplaceAll(s, "'", "&apos;")
+	return s
+}