BLOG

🌱 digital garden

Select Language

Based in Nice, France - CET (UTC+1)

BLOG

🌱 digital garden

Select Language

Based in Nice, France - CET (UTC+1)

BLOG

🌱 digital garden

Select Language

Based in Nice, France - CET (UTC+1)

← Back

A reuse rate case study for an LLM workflow

Nov 8, 2026

Notes from reviewing a German to French translation pipeline for regulated documents. One setting nobody sees moves the headline number from 14% to 91%.

I was asked to review the architecture of a machine translation pipeline for regulated technical directives, German to French. The documents are the kind where one term has one approved translation and a reviewer signs the result.

To review it I needed something to measure, so I wrote a small demonstrator: 6,600 lines of Python, standard library plus a PDF reader, runs offline in one command and prints a table. It translates badly on purpose. By default the model is a local lookup table. Its job is to measure three mechanisms, and to label everything it does not measure.

All figures below come from a public document: Swissgrid's minimum technical requirements for connecting converter-based energy storage systems, version 1.1, 36 pages, published in German and in French. No client document appears in this post.

The design

Three decisions carry the rest.

Segment per sentence, not per paragraph. A paragraph almost never repeats between two versions of a directive. A sentence does. Everything about reuse follows from this.

Look up the memory by edit distance on the source string, not by embeddings. A sentence and its negation share a topic and a vocabulary, so a vector index tends to call them near-identical. Edit distance does not put them far apart either, but it never calls them the same: the match comes back fuzzy, below 100%, and a fuzzy match is always opened by a reviewer. In a regulated text, serving the translation of "requires approval" for "does not require approval" is the worst available failure, and the test suite has a case for exactly that pair. I did not run an embedding model to compare, so the first half of that argument is reasoning and not a measurement.

Label every segment. Each sentence leaves with a status and a reason, so the reviewer opens only what is flagged.

Status	Meaning	Reviewer opens it
MEMOIRE_100	exact memory match, no model call	no
MEMOIRE_FLOUE	fuzzy match reused as is	yes
MACHINE	model output, conforms to the glossary	no
MACHINE_SIGNALEE	violation still there after one retry	yes
LANGUE_SOURCE_RESIDUELLE	sentence left in German	yes
LANGUE_INDETERMINEE	too few clues to decide	yes

What reading the PDF costs

Measure	Value
Pages	36
Segments (sentences)	750
End-of-line hyphenation breaks repaired	208
Repeated header and footer lines removed	35
Median segment length	86 characters
Longest segment	1,490 characters
Segments with undetermined language	159 (21%)

The longest segment is a table that PDF extraction poured into running text. That one row is the argument for working from the original Word file through a proper filter and not rebuilding structure from a PDF.

The number that depends on a setting nobody sees

To measure reuse on a real document I aligned the German with the published French, sentence by sentence, and loaded the pairs into the memory. Then I translated the German again and counted how many characters never reached the model.

The aligner gives each pair a confidence score. A threshold decides which pairs enter the memory. Same document, same memory, same code, only the threshold moves:

Threshold	Pairs kept	Reuse rate	Characters sent to the model
0.0	711	91%	6,642
0.5	655	80%	15,305
0.7 (default)	313	30%	53,675
0.8	286	25%	57,790
0.9	151	14%	65,845

From 14% to 91% on one setting. Anyone quoting a reuse rate without the threshold behind it is quoting nothing.

At 0.0 the pipeline reuses 91% by accepting wrong pairs, and a wrong pair loaded into a memory comes back later as a wrong translation with a displayed score of 100%. The high number is the dangerous one.

The cliff between 0.5 and 0.7 has a dull cause.

202 of the 716 pairs score exactly 0.600. The aligner cannot rank them against each other, so it gives them all the same value. A threshold at 0.7 drops all of them at once and a threshold at 0.6 keeps all of them. My default landed just above the plateau by accident. The tool now prints its plateaus so the cliff is visible before someone picks a number.

The score is noisy in both directions. • Normen IEC; and • les normes de la CEI ; are a correct pair scored 0.32, because the acronym itself is translated and the surfaces diverge. A plainly wrong pair in the same document also scores 0.32. The score has never been calibrated against a human judgement on this corpus. That calibration is a concrete task with a cost, and it comes before any claim about reuse.

Reuse between two versions

The other reuse case is the pleasant one: version 2.3 of a document after version 2.2 has been translated. I built a synthetic pair where the second version differs from the first by six declared string replacements, listed in a changelog next to the files.

	Pass 1 (v2.2)	Pass 2 (v2.3)
Segments	64	65
Model calls	91	5
Characters sent	6,331	372
Reuse rate	0%	92%

92% is a laboratory ceiling, since I wrote the second version myself. The number to present is the one from the real document, with its threshold.

A word search does not hold in German

The usual glossary check is a regular expression with word boundaries. German breaks it twice. It declines: \bPlangenehmigungsverfahren\b does not find Plangenehmigungsverfahrens, because the genitive s removes the boundary. And it compounds: the term can sit inside Plangenehmigungsverfahrensantrag, where no boundary will ever be.

I ran both checkers on the same segments, the naive regex and a morphological one that splits compounds and folds declensions.

	Synthetic German sample	Public Swissgrid document
Violations caught by morphology	56	2
Violations caught by regex	52	2
Violations missed by the regex	5 of 56 (9%)	0%
Fixed by one retry with the violation named	56	2

The regex reports 52 on the synthetic sample, and one of those is a finding the morphological checker does not confirm. That is why it misses 5 and not 4. The second column is the more useful one. The glossary was written for a directive about plan approval. On a document about energy storage it recognises one compound and one term. A glossary does not transfer between documents, and neither does a hand-written compound lexicon. The 9% is measured on that text with that glossary. It is not a statement about German.

Measuring quality, with the caveats attached

Quality is measured in exactly one place: translate cold with a real model, then score against the published human translation.

	First run	Second run
Model	claude-haiku-5-5, low effort	same
Calls	703	703
Input tokens, uncached	432,938	153,847
Input tokens read from cache	0	435,157
Output tokens	45,972	49,270
Duration	897 s	823 s
chrF	0.737	0.752
BLEU	0.565	0.596
Mean edit similarity	0.799	0.817

Two changes separate the runs. The glossary and instructions moved into a cached system prompt, with only the per-segment terms in the user turn. And the first run leaked. On short headings the model sometimes returned the German unchanged followed by its own hesitation: 6.2.1.5 Validierung, then "Hmm, the segment is". A scorer sees that as a bad translation. A reviewer sees a document with model commentary inside it. The second run forbids commentary in the prompt and filters what still gets through.

It did not fix everything. Segment 648, a sentence fragment cut at a page break, still comes back in German in the second run. It is flagged, not hidden.

What these scores do not say is printed under them every time:

311 of 750 segments are scored, 41% of the document. A segment without a reference is not counted as a zero and enters no average.
The reference is paired by an automatic aligner, so alignment error is inside the score.
chrF and BLEU measure surface overlap with a single reference. A different correct translation scores low and a close wrong one scores high.
Nobody has read the output. The numbers are automatic end to end.

What I would keep

A probabilistic component is easier to trust inside a deterministic frame. The model is one interface with three implementations: a local stub, an API, a self-hosted server. Nothing else in the pipeline knows which one is running, so the question of where the data may go stays a deployment decision.

Every number the tool prints is either measured by the tool or labelled as a demonstration, and the table always ends with what it does not say. That costs a few lines of code and it is the part of the review people remember.

Sources

Popović, chrF: character n-gram F-score for automatic MT evaluation, WMT 2015
Papineni et al., BLEU: a method for automatic evaluation of machine translation, ACL 2002
OASIS, XLIFF 2.0, the review format the pipeline exports
Measurements: my own runs of 5 November 2026 on the public document above

The demonstrator behind these measurements was built with AI coding tools. The text was proofread by AI.

import * as React from "react"

import { createPortal } from "react-dom"

import { addPropertyControls, ControlType, RenderTarget } from "framer"

/**

* Borrowed Authority — scroll rail

* Drop this anywhere on the blog CMS template page. It renders nothing in the

* page flow: it portals a fixed-position flow chart into <body>, gates itself

* on the post slug and on a minimum viewport width, and nudges the article

* column left so the chart has room. Below the breakpoint it renders nothing

* at all, so mobile is untouched.

* @framerSupportedLayoutWidth auto

* @framerSupportedLayoutHeight auto

* @framerIntrinsicWidth 12

* @framerIntrinsicHeight 12

* @framerDisableUnlink

// ---------------------------------------------------------------- palette

const C = {

ink: "#333",

mid: "#4f4f4f",

mut: "#777",

hair: "rgba(51,51,51,.22)",

blue: "#1020cc",

red: "#ff462e",

mono: "'DM Mono', ui-monospace, SFMono-Regular, Menlo, monospace",

sans: "Inter, 'Inter Placeholder', system-ui, sans-serif",

}

// ---------------------------------------------------------------- graph

const ART_W = 400 // drawing viewBox

const ART_H = 446

const MIN_RAIL = 330 // below this the chart stops being readable

const EDGE = 32 // breathing room at the right edge of the viewport

const SX = 124

const SW = 160

const RX = 300

const RW = 94

type Node = { x: number; y: number; w: number; h: number; t: string; s: string }

const N: Record<string, Node> = {

person: { x: SX, y: 8, w: SW, h: 24, t: "A PERSON", s: "" },

surface: { x: SX, y: 48, w: SW, h: 36, t: "SURFACE", s: "chat · WhatsApp · mail · CI" },

control: { x: SX, y: 100, w: SW, h: 40, t: "CONTROL PLANE", s: "router · policy · budget" },

agent: { x: SX, y: 156, w: SW, h: 40, t: "AGENT", s: "analyst · operator · author" },

gate: { x: SX, y: 212, w: SW, h: 40, t: "GATE", s: "allowlist · scrub · cap" },

systems: { x: SX, y: 268, w: SW, h: 38, t: "SYSTEMS", s: "guards unchanged" },

answer: { x: SX, y: 322, w: SW, h: 34, t: "ANSWER", s: "the trace under it" },

ledger: { x: SX, y: 372, w: SW, h: 30, t: "LEDGER", s: "calls · denials · cost" },

intro: { x: SX, y: 100, w: SW, h: 152, t: "ONE CHAT BOX", s: "" },

repo: { x: RX, y: 100, w: RW, h: 40, t: "CONTROL", s: "rules · actions" },

denied: { x: RX, y: 212, w: RW, h: 28, t: "DENIED", s: "" },

approve: { x: RX, y: 268, w: RW, h: 38, t: "A PERSON", s: "approves" },

pr: { x: RX, y: 322, w: RW, h: 34, t: "PULL REQ.", s: "never a merge" },

}

type EdgeOpt = { dash?: boolean; red?: boolean; side?: boolean; elbow?: boolean; elbow2?: boolean; y?: number }

const E: Array<[string, string, string, EdgeOpt?]> = [

["person", "surface", "signs in once"],

["surface", "control", "an identity"],

["control", "agent", "a run context"],

["agent", "gate", "a declared action"],

["gate", "systems", "the asker's token"],

["systems", "answer", "rows, not a summary"],

["answer", "ledger", "", { dash: true }],

["gate", "denied", "", { side: true, red: true }],

["repo", "gate", "", { elbow: true }],

["gate", "approve", "", { side: true, red: true, y: 287 }],

["agent", "pr", "", { elbow2: true }],

]

const SPINE = ["person", "surface", "control", "agent", "gate", "systems", "answer", "ledger"]

const FILES: Array<[string, string, boolean, boolean]> = [

["·", "rules.ts — levels, budgets, approvals", true, false],

["·", "actions/ — the declared manifest", true, false],

["·", "skills/ — the playbooks", true, false],

["↓", "loaded by the gate at startup; a mismatch is a", false, false],

[" ", "startup error, not an escalation", false, false],

["·", "evals (private) — CI reads it, agents never", false, false],

["·", "guardrails (no repo) — reviewers, secrets", false, false],

["✕", "the author agent opens a PR. never a merge.", false, true],

]

const LAYERS: Array<[string, string, boolean]> = [

["1", "edge — TLS, rate limit", false],

["2", "session — tokens server side, role re-read", false],

["3", "run gate — concurrency, wall clock", false],

["4", "process — no shell, no files, no network", false],

["5", "action — exact name, typed input, deny first", false],

["6", "the token — the API's own guards decide", false],

["7", "scrubber — fails closed on what it can't parse", false],

["8", "size cap — oversized results cut", false],

["9", "framing — results labelled untrusted data", false],

["✕", "undeclared action — denied, logged, no retry", true],

]

const CARD: Array<[string, string]> = [

["organisation", "the one named in the question"],

["amount", "the balance the dry run returned"],

["destination", "its registered bank account"],

["balance after", "what the ledger will say"],

["expires", "60 minutes, single use"],

]

// ---------------------------------------------------------------- helpers

function edgePath(a: Node, b: Node, o: EdgeOpt): string {

if (o.side) {

const y = o.y ?? a.y + a.h / 2

return `M${a.x + a.w} ${y} H${b.x - 6}`

}

if (o.elbow) return `M${a.x + a.w / 2} ${a.y + a.h} V${b.y + b.h / 2} H${b.x + b.w + 6}`

if (o.elbow2) return `M${a.x + a.w} ${a.y + a.h - 8} H${b.x + b.w / 2} V${b.y - 6}`

return `M${a.x + a.w / 2} ${a.y + a.h} V${b.y - 6}`

}

/** The article column: the outermost ancestor of the headings still 560–900px wide. */

function findColumn(): HTMLElement | null {

const h = document.querySelector("h2") || document.querySelector("h1")

if (!h) return null

let el = h.parentElement as HTMLElement | null

let best: HTMLElement | null = null

while (el && el !== document.body) {

const w = el.getBoundingClientRect().width

if (w > 560 && w < 900) best = el

el = el.parentElement

}

return best

}

/** Stage boundaries: the article top, then every H2. */

function readStops(): number[] {

const hs = Array.prototype.slice.call(document.querySelectorAll("h2")) as HTMLElement[]

if (!hs.length) return []

const first = hs[0]

const colTop = (findColumn() ?? first).getBoundingClientRect().top + window.scrollY

return [colTop].concat(hs.map((h) => h.getBoundingClientRect().top + window.scrollY - 40))

}

// ---------------------------------------------------------------- component

export default function BorrowedAuthorityRail(props) {

const { slug, minWidth, gap, maxWidth, anchor } = props

const isCanvas = RenderTarget.current() === RenderTarget.canvas

const [on, setOn] = React.useState(false)

const [box, setBox] = React.useState({ left: 0, w: 420, h: 446 })

const [stage, setStage] = React.useState(0)

const [t, setT] = React.useState(0)

const stopsRef = React.useRef<number[]>([])

const colRef = React.useRef<HTMLElement | null>(null)

React.useEffect(() => {

if (isCanvas || typeof window === "undefined") return

if (slug && window.location.pathname.indexOf(slug) === -1) return

const mq = window.matchMedia(`(min-width:${minWidth}px)`)

let raf = 0

const measure = () => {

stopsRef.current = readStops()

}

/**

* The article column is never moved — the page is left-aligned, so

* moving it produces a visible jump on load. The rail simply takes

* the space to the right of the column and scales to fill it, up to

* maxWidth and whatever the viewport height allows.

const place = () => {

const col = colRef.current ?? findColumn()

colRef.current = col

if (!col) {

setOn(false)

return

}

const r = col.getBoundingClientRect()

const vw = document.documentElement.clientWidth

const left = r.right + gap

const avail = vw - left - EDGE

const byHeight = Math.floor(((window.innerHeight * 0.86) * ART_W) / ART_H)

const w = Math.floor(Math.min(maxWidth, avail, byHeight))

if (!mq.matches || w < MIN_RAIL) {

setOn(false)

return

}

setBox({ left, w, h: Math.round((w * ART_H) / ART_W) })

setOn(true)

}

const onScroll = () => {

if (raf) return

raf = requestAnimationFrame(() => {

raf = 0

const stops = stopsRef.current

if (!stops.length) return

const y = window.scrollY + window.innerHeight * anchor

let i = 0

while (i + 1 < stops.length && y >= stops[i + 1]) i++

const a = stops[i]

const b = i + 1 < stops.length ? stops[i + 1] : a + window.innerHeight

setStage(Math.min(9, i))

setT(Math.max(0, Math.min(1, (y - a) / Math.max(1, b - a))))

})

}

const sync = () => {

measure()

place()

onScroll()

}

sync()

window.addEventListener("scroll", onScroll, { passive: true })

window.addEventListener("resize", sync)

const ro = new ResizeObserver(() => {

measure()

})

if (document.body) ro.observe(document.body)

return () => {

window.removeEventListener("scroll", onScroll)

window.removeEventListener("resize", sync)

ro.disconnect()

if (colRef.current) colRef.current.style.transform = ""

}

}, [isCanvas, slug, minWidth, gap, maxWidth, anchor])

if (isCanvas) {

return (

<div

style={{

width: "100%",

height: "100%",

minWidth: 160,

minHeight: 56,

border: `1px dashed ${C.hair}`,

borderRadius: 3,

display: "flex",

alignItems: "center",

justifyContent: "center",

textAlign: "center",

font: `10px/1.5 ${C.mono}`,

letterSpacing: ".08em",

textTransform: "uppercase",

color: C.mut,

padding: 8,

}}

scroll rail

<br />

renders on the live page

</div>

)

}

if (!on) return null

if (typeof document === "undefined") return null

return createPortal(<Rail stage={stage} t={t} box={box} />, document.body)

}

// ---------------------------------------------------------------- the rail

function Rail({ stage, t, box }) {

let list: string[] = SPINE.slice()

let hot: string[] = []

let red: string[] = []

let panel: "files" | "gate" | "card" | null = null

let firing = false

let token: string | null = null

if (stage === 0) {

list = ["intro"]

hot = ["intro"]

} else if (stage === 1) {

const k = Math.min(8, Math.floor(t * 8.6) + 1)

list = SPINE.slice(0, k)

hot = [SPINE[k - 1]]

} else if (stage === 2) {

list = SPINE.concat(["pr"])

hot = ["answer", "pr", "agent"]

} else if (stage === 3) {

const i = Math.min(5, Math.floor(t * 6))

hot = [SPINE[i]]

red = ["agent"]

token = SPINE[i]

} else if (stage === 4) {

firing = true

hot = ["gate", "systems", "answer"]

} else if (stage === 5) {

panel = "files"

} else if (stage === 6) {

panel = "gate"

} else if (stage === 7) {

panel = "card"

} else if (stage === 8) {

list = SPINE.concat(["approve", "pr", "repo", "denied"])

hot = ["gate", "systems"]

red = ["approve", "denied"]

} else {

list = SPINE.concat(["approve", "pr", "repo", "denied"])

hot = SPINE

red = ["approve"]

}

const nodeOn = (k: string) => (panel ? false : list.indexOf(k) >= 0)

const tokNode = token ? N[token] : null

return (

<div

style={{

position: "fixed",

top: 0,

left: box.left,

width: box.w,

height: "100vh",

display: "flex",

flexDirection: "column",

justifyContent: "center",

pointerEvents: "none",

zIndex: 5,

fontFamily: C.sans,

}}

<style>{`

@keyframes barun{0%{opacity:0;transform:translateY(0)}10%{opacity:1}

45%{opacity:1;transform:translateY(58px)}55%{opacity:1;transform:translateY(58px)}

95%{opacity:1;transform:translateY(0)}100%{opacity:0;transform:translateY(0)}}

.ba-firing .ba-pulse{animation:barun 1.6s linear infinite}

@media (prefers-reduced-motion:reduce){.ba-rail *{transition-duration:.01ms!important;animation-duration:.01ms!important}}

`}</style>

<svg

viewBox="0 0 400 446"

preserveAspectRatio="xMidYMid meet"

aria-hidden="true"

style={{ position: "absolute", inset: 0, width: "100%", height: "100%", display: "block" }}

<defs>

</marker>

</marker>

</marker>

</defs>

{E.map(([a, b, label, o], i) => {

const opt = o || {}

const show = nodeOn(a) && nodeOn(b)

const isHot = hot.indexOf(a) >= 0 && hot.indexOf(b) >= 0

const stroke = opt.red ? C.red : isHot ? C.blue : C.hair

const marker = opt.dash ? undefined : opt.red ? "url(#ba-ahr)" : isHot ? "url(#ba-ahb)" : "url(#ba-ah)"

return (

<path

d={edgePath(N[a], N[b], opt)}

fill="none"

stroke={stroke}

strokeWidth={1}

strokeDasharray={opt.dash || opt.red ? "3 3" : undefined}

markerEnd={marker}

style={{ transition: "stroke .3s" }}

{label ? (

<text

x={N[a].x - 10}

y={(N[a].y + N[a].h + N[b].y) / 2 + 3}

textAnchor="end"

style={{

font: `8.4px ${C.mono}`,

fill: isHot ? C.blue : C.mut,

transition: "fill .3s",

}}

{label}

</text>

) : null}

</g>

)

})}

{Object.keys(N).map((k) => {

const d = N[k]

const show = nodeOn(k)

const isHot = hot.indexOf(k) >= 0

const isRed = red.indexOf(k) >= 0

const stroke = isHot ? C.blue : isRed ? C.red : C.hair

const fill = isHot ? C.blue : isRed ? C.red : C.ink

return (

<rect

x={d.x}

y={d.y}

width={d.w}

height={d.h}

rx={2}

fill="none"

stroke={stroke}

strokeWidth={isHot ? 1.6 : 1}

style={{ transition: "stroke .3s, stroke-width .3s" }}

<text

x={d.x + d.w / 2}

y={d.s ? d.y + d.h / 2 - 2 : d.y + d.h / 2 + 3.5}

textAnchor="middle"

style={{

font: `500 10px ${C.mono}`,

letterSpacing: ".1em",

fill,

transition: "fill .3s",

}}

{d.t}

</text>

{d.s ? (

<text

x={d.x + d.w / 2}

y={d.y + d.h / 2 + 11}

textAnchor="middle"

style={{ font: `8.6px ${C.mono}`, fill: C.mut }}

{d.s}

</text>

) : null}

</g>

)

})}

<g>

{[0, 1, 2, 3, 4, 5].map((i) => (

<circle

key={i}

className="ba-pulse"

cx={SX + SW / 2}

cy={258}

r={2.6}

fill={C.blue}

style={{ opacity: 0, animationDelay: `${-i * 0.26}s` }}

))}

</g>

transform={tokNode ? `translate(${tokNode.x + tokNode.w + 16},${tokNode.y + tokNode.h / 2})` : undefined}

style={{

opacity: tokNode ? 1 : 0,

transition: "transform .5s cubic-bezier(.3,.8,.3,1), opacity .3s",

}}

token

</text>

</g>

</svg>

{FILES.map(([i, s, blk, deny], k) => (

))}

</Panel>

{LAYERS.map(([i, s, deny], k) => (

))}

</Panel>

<div

style={{

border: `1px solid ${C.hair}`,

borderRadius: 2,

font: `10.5px ${C.mono}`,

color: C.mid,

marginTop: 60,

}}

<div

style={{

display: "flex",

justifyContent: "space-between",

padding: "9px 12px",

borderBottom: `1px solid ${C.hair}`,

color: C.ink,

}}

<span>payouts.execute</span>

guarded

</span>

</div>

{CARD.map(([k, v]) => (

<React.Fragment key={k}>

</React.Fragment>

))}

</dl>

decline

</b>

type the name to approve

</b>

</div>

</Panel>

</div>

)

}

function Panel({ on, title, t, children }) {

const kids = React.Children.toArray(children)

const n = Math.ceil(t * (kids.length + 0.8))

return (

<div

style={{

position: "absolute",

inset: 0,

opacity: on ? 1 : 0,

pointerEvents: "none",

transition: "opacity .4s ease",

}}

{title ? (

{title}

</div>

) : null}

{kids.map((kid, i) =>

React.isValidElement(kid)

? React.cloneElement(kid as React.ReactElement<any>, { visible: on && i < n })

: kid

)}

</div>

)

}

function Row({ i, s, blk = false, deny = false, visible = false }) {

return (

<div

style={{

display: "flex",

gap: 9,

alignItems: "baseline",

font: `10.5px/1.5 ${C.mono}`,

color: deny ? C.red : C.mid,

padding: blk ? "4px 8px" : "3px 0",

border: blk ? `1px solid ${deny ? C.red : C.hair}` : undefined,

borderRadius: blk ? 2 : undefined,

marginBottom: blk ? 3 : 0,

opacity: visible ? 1 : 0.16,

transition: "opacity .3s",

}}

</div>

)

}

BorrowedAuthorityRail.defaultProps = {

slug: "agents-and-borrowed-authority",

minWidth: 1200,

gap: 64,

maxWidth: 760,

anchor: 0.42,

}

addPropertyControls(BorrowedAuthorityRail, {

slug: {

type: ControlType.String,

title: "Slug",

defaultValue: "agents-and-borrowed-authority",

description: "Only renders on URLs containing this. Leave empty to run on every post.",

minWidth: { type: ControlType.Number, title: "Min width", defaultValue: 1200, min: 900, max: 1800, step: 20 },

gap: { type: ControlType.Number, title: "Gap", defaultValue: 64, min: 16, max: 200, step: 4 },

maxWidth: { type: ControlType.Number, title: "Max width", defaultValue: 760, min: 360, max: 1000, step: 20 },

anchor: { type: ControlType.Number, title: "Trigger line", defaultValue: 0.42, min: 0.1, max: 0.9, step: 0.01 },

})