Composed text

Machine-composed prose. A sentence is bound to a record source or it is withheld; the disclosure is a constant; there is no author, no score on the whole, and no half a document.

Overview

Two pattern pages carry the rules for text a machine wrote. Composed output says every clinically material assertion binds to a source, an unbindable sentence is withheld rather than hedged, omissions are counted, and nothing carries an overall score. Authorship & the record says the disclosure is text that survives copy and print, is authored by the application rather than the composer, and that a person accepts composed text and never authors it. Until this component existed, every one of those rules was held by the implementer — fourteen rows of “The implementer” across the two guarantees tables, nine of them now here — and the pattern pages had the largest implementer-held share in this system.

Anatomy

Withheld, not hedged

The tempting rendering of a sentence the composer could not support is the sentence with a caveat — greyed, marked unverified, followed by a question mark. Every one of those loses to the momentum of the paragraph around it: a reader moving through fluent prose does not stop at a grey word. So the sentence is not rendered. What the reader gets instead is a count in the omission notice and the reason, which is a fact they can act on: two assertions withheld for want of a supporting entry is a prompt to go and look, where two hedged sentences are a prompt to keep reading.

This is why Sentence has two kinds and not three. A hedged kind would be the most natural addition and the most harmful; its absence is the rule.

A disclosure the composer cannot write

If the model writes its own disclosure, the disclosure is another output of the thing being disclosed. The sentence here — Composed text, not committed. Review before accepting — you will be recorded as having accepted it, not as its author — is a constant in the component’s source. It is not a prop, so a caller cannot pass a softer one, and it is not generated, so the composer cannot pass any. Once someone has accepted the text, the sentence changes to name them: accepted by, never author. There is no author prop, because nobody authors composed text; someone stands behind it.

Do's and don'ts

What the component enforces, and what it only asks for

The shape of the props holds the rules that are about the artefact. The rules about whether the bindings are true are the composer’s, and no renderer can hold those.

Accessibility

• An <article> whose first content is the disclosure. A screen reader reaches “Composed by” before any composed sentence.
• Bindings are real links with meaningful names — “obs 21:00”, not “source” or “[1]” — and they are inline in prose, taking the inline exemption to SC 2.5.8.
• Underlined, in the running colour. Bound text is not distinguished by colour, because there is no unbound text on the surface to distinguish it from.
• Counts are words with their nouns — “2 assertions withheld”, “3 nursing notes” — never a bare digit or a chip.
• Nothing here is a live region. The artefact arrives whole; there is no streaming to announce, by construction.

Outcomes of use

• Effectiveness — a clinician can check any sentence against the entry it rests on, and knows what was not said.
• Efficiency — the checking apparatus is in the artefact, not in a second system.
• Satisfaction — not having to guess which sentences are safe. Attributes believed to contribute to an outcome; the outcome is settled by observing real use, not by this page — see Usability & context of use.

Clinical safety notes

• Unsupported prose cannot be rendered. (the component) Mitigates: an unsupported statement acted on because prose reads as verified.
• The disclosure is text the composer did not write. (the component) Mitigates: composed text read as human-authored after copy, print or transfer; and a risk control produced by the thing it controls.
• Omissions are stated before the prose. (the component) Mitigates: the failure mode with no surface — a competent reader who cannot see what is absent.
• No score on the whole, no partial document. (the component) Mitigates: a number with no calibrated referent standing in for checking the parts; reading that begins before the bindings exist.
• Every binding is true. (you) Mitigates: a sentence that cites an entry which does not support it — the composer’s error, rendered with complete confidence.
• Acceptance is a named human act, recorded. (you) Mitigates: unreviewed composed text entering a clinical record.

Implementation

$ npx shadcn@latest add https://md.notjustany.tech/r/composed-text.json

<ComposedText
  composer={{ name: "NightBrief", version: "4.2" }}
  composedAt="17 Aug 06:41"
  omissions={{
    covered: "observations, medication changes, 15 Aug 08:00 – 17 Aug 06:30",
    notCarried: [{ category: "nursing notes", count: 3 }],
    notAvailable: [{ source: "theatre record", reason: "system unreachable at 06:41" }],
  }}
  paragraphs={[
    [
      { kind: "bound", text: "Oxygen requirement fell from 4 L/min to 2 L/min over the shift.",
        sources: [{ id: "o1", label: "obs 21:00", href: "/record/obs/o1" }] },
      { kind: "withheld", reason: "no supporting entry found" },
    ],
  ]}
  acceptedBy={undefined}   // not yet; there is no `author` prop and never will be
/>

// A sentence is bound or withheld. There is no hedged kind, no score prop, and no
// way to pass the disclosure in: the component owns that sentence.

Related

• Composed output — the binding, omission and no-score rules this component holds.
• Authorship & the record — the disclosure and “accepted by”.
• Editing the draft — what happens to this text before it is accepted, and the commit control that is not here.
• Event log — where the composed version and the acceptance are recorded, separately.
• AI transparency & human oversight — the disclosure obligation this is built to meet.