From ec5c92d4fddfff99e31f9269ddfc8f1db975b2f8 Mon Sep 17 00:00:00 2001
From: Lilleman auf Larv <lilleman@larvit.se>
Date: Tue, 15 Sep 2026 20:03:36 +0200
Subject: [PATCH] 4.3: the markdown property

---
 AGENTS.md                     |   6 +-
 package.json                  |   2 +-
 src/adf-property.test.ts      | 164 +-------------
 src/markdown-property.test.ts | 394 ++++++++++++++++++++++++++++++++++
 src/property-generators.ts    | 166 ++++++++++++++
 tsconfig.build.json           |   2 +-
 6 files changed, 567 insertions(+), 167 deletions(-)
 create mode 100644 src/markdown-property.test.ts
 create mode 100644 src/property-generators.ts

diff --git a/AGENTS.md b/AGENTS.md
index 9786496..a1c5beb 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -227,9 +227,9 @@ compared against `undefined` — have a half no valid document reaches.
 The corpus, all checked in: hand-built fixtures per node and combination; real ADF Atlassian's
 editor wrote; the CommonMark spec suite against `markdownToAdf` and `markdownToHtml`.
 
-Beside the corpus, properties run over documents generated from the node tables, on a fixed seed in
-the gate; `PROPERTY_RUNS=<runs>` raises the runs and randomizes the seed for local digging, and a
-counterexample found becomes a round-trip fixture.
+Beside the corpus, properties run over documents generated from the node tables and over generated
+markdown, on a fixed seed in the gate; `PROPERTY_RUNS=<runs>` raises the runs and randomizes the
+seed for local digging, and a counterexample found becomes a round-trip fixture.
 
 `spec/flavour.md` is read as a source too, so the node tables cannot drift from the prose they
 copy: each `- ` bullet in `## Block nodes`, `## Inline nodes` and `## Marks` declares the nodes
diff --git a/package.json b/package.json
index a188be2..5b86fde 100644
--- a/package.json
+++ b/package.json
@@ -23,7 +23,7 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
-    "test": "node --test --experimental-test-coverage --test-coverage-exclude=\"src/**/*.test.ts\" --test-coverage-branches=98 --test-coverage-functions=100 --test-coverage-lines=100 \"src/**/*.test.ts\"",
+    "test": "node --test --experimental-test-coverage --test-coverage-exclude=\"src/**/*.test.ts\" --test-coverage-exclude=src/property-generators.ts --test-coverage-branches=98 --test-coverage-functions=100 --test-coverage-lines=100 \"src/**/*.test.ts\"",
     "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.build.json"
   },
   "devDependencies": {
diff --git a/src/adf-property.test.ts b/src/adf-property.test.ts
index 4343cb1..4e54660 100644
--- a/src/adf-property.test.ts
+++ b/src/adf-property.test.ts
@@ -1,173 +1,13 @@
 import fc from 'fast-check'
 import assert from 'node:assert/strict'
-import { env } from 'node:process'
 import test from 'node:test'
 
-import type { AdfAttributes, AdfDocument, AdfMark, AdfNode } from './adf/document.ts'
-import type { Arbitrary } from 'fast-check'
-import type { AttributeKind, AttributeVocabulary } from './adf/attribute-vocabulary.ts'
-import type { JsonValue } from './json-value.ts'
+import { adfDocument, propertyRuns, propertyTimeout } from './property-generators.ts'
 import { adfToMarkdown } from './markdown/emit/adf-to-markdown.ts'
-import { blockArgument } from './markdown/block-directive-arguments.ts'
-import { blockDirectives } from './adf/block-directives.ts'
-import { inlineDirectives } from './adf/inline-directives.ts'
-import { markAttributes } from './adf/mark-attributes.ts'
 import { markdownToAdf } from './markdown/parse/markdown-to-adf.ts'
 import { toEditorNormal } from './adf/editor-normal.ts'
 
-type Positions = { block: AdfNode; inline: AdfNode }
-
-const deepRunsVariable = 'PROPERTY_RUNS'
 const gateRuns = 1600
-const gateSeed = 20260914
-// Bun's test runner stops a test after five seconds unless the test sets its own timeout.
-const propertyTimeout = 600000
-
-const depthIdentifier = fc.createDepthIdentifier()
-const emptyCell: AdfNode = { content: [{ type: 'paragraph' }], type: 'tableCell' }
-const flatCommonMarkShapeWeight = 4
-const markdownPieces = fc.constantFrom(...'aZ09 \t\n!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~é\xa0🎉', ':a[', ':a{', 'ab:', 'http://')
-const nestingCommonMarkShapeWeight = 21
-const spelledTypes = new Set(['text', ...Object.keys(blockDirectives), ...Object.keys(inlineDirectives), ...Object.keys(markAttributes)])
-
-function textOf(minLength: number): Arbitrary<string> {
-  return fc.oneof(
-    { arbitrary: fc.string({ maxLength: 12, minLength, unit: markdownPieces }), weight: 4 },
-    { arbitrary: fc.string({ maxLength: 6, minLength, unit: 'grapheme' }), weight: 1 },
-  )
-}
-
-const text = textOf(1)
-const unknownType = fc.oneof(fc.stringMatching(/^[a-z][A-Za-z0-9]{0,7}$/), text).filter((type) => !spelledTypes.has(type))
-const numberValue = fc.oneof({ arbitrary: fc.integer({ max: 10, min: -1 }), weight: 3 }, { arbitrary: fc.double({ noDefaultInfinity: true, noNaN: true }), weight: 1 })
-
-// V8's JSON.parse returns a wrong key after parsing a key holding an escaped backslash (https://issues.chromium.org/issues/521080746); Bun is unaffected.
-const keyPiece = fc
-  .oneof({ arbitrary: markdownPieces, weight: 4 }, { arbitrary: fc.string({ maxLength: 1, minLength: 1, unit: 'grapheme' }), weight: 1 })
-  .filter((piece) => !/[\\"\x00-\x1f]/.test(piece))
-const jsonKey = fc.string({ maxLength: 8, unit: keyPiece })
-
-const { jsonValue } = fc.letrec<{ jsonValue: JsonValue }>((tie) => ({
-  jsonValue: fc.oneof(
-    { depthSize: 'small', maxDepth: 2 },
-    fc.oneof(fc.constant(null), fc.boolean(), numberValue, textOf(0)),
-    fc.array(tie('jsonValue'), { maxLength: 3 }),
-    fc.dictionary(jsonKey, tie('jsonValue'), { maxKeys: 3, noNullPrototype: true }),
-  ),
-}))
-
-const valueByKind: Readonly<Record<AttributeKind, Arbitrary<JsonValue>>> = {
-  boolean: fc.boolean(),
-  json: jsonValue,
-  number: numberValue,
-  string: textOf(0),
-}
-
-function attributes(vocabulary: AttributeVocabulary): Arbitrary<AdfAttributes> {
-  const model = Object.fromEntries(
-    Object.entries(vocabulary).map(([key, kind]) => [key, fc.oneof({ arbitrary: fc.constant(undefined), weight: 2 }, { arbitrary: valueByKind[kind], weight: 1 })]),
-  )
-  return fc.record(model).map(heldAttributes)
-}
-
-function heldAttributes(held: Readonly<Record<string, JsonValue | undefined>>): AdfAttributes {
-  const attrs: AdfAttributes = {}
-  for (const [key, value] of Object.entries(held)) if (value !== undefined) attrs[key] = value
-  return attrs
-}
-
-function pipeTable({ body, header }: { body: AdfNode[][]; header: AdfNode[] }): AdfNode {
-  const rows = [header, ...body.map((cells) => header.map((_, index) => cells[index] ?? emptyCell))]
-  return { content: rows.map((content): AdfNode => ({ content, type: 'tableRow' })), type: 'table' }
-}
-
-const mark: Arbitrary<AdfMark> = fc.oneof(
-  { arbitrary: fc.oneof(...Object.entries(markAttributes).map(([type, vocabulary]) => attributes(vocabulary).map((attrs) => ({ attrs, type })))), weight: 9 },
-  { arbitrary: fc.record({ attrs: fc.dictionary(jsonKey, jsonValue, { maxKeys: 2, noNullPrototype: true }), type: unknownType }), weight: 1 },
-)
-const marks = fc.uniqueArray(mark, { maxLength: 3, selector: (held) => held.type })
-
-const textNode = fc.record({ marks, text }).map((held): AdfNode => ({ ...held, type: 'text' }))
-
-const autolinkTextNode = fc
-  .record({ href: fc.tuple(fc.constantFrom('ab:', 'http://'), textOf(0)).map(([scheme, rest]) => `${scheme}${rest}`), marks })
-  .map(({ href, marks: held }): AdfNode => ({ marks: [...held.filter((outer) => outer.type !== 'link'), { attrs: { href }, type: 'link' }], text: href, type: 'text' }))
-
-const inlineNodes = Object.entries(inlineDirectives).map(([type, directive]) =>
-  fc.record({ attrs: attributes(directive.attributes), marks }).map((held): AdfNode => ({ ...held, type })),
-)
-
-function weighted(arbitraries: readonly Arbitrary<AdfNode>[], weight: number): { arbitrary: Arbitrary<AdfNode>; weight: number }[] {
-  return arbitraries.map((arbitrary) => ({ arbitrary, weight }))
-}
-
-const positions = fc.letrec<Positions>((tie) => {
-  const blockContent = fc.array(tie('block'), { depthIdentifier, maxLength: 3 })
-  const inlineContent = fc.array(tie('inline'), { depthIdentifier, maxLength: 4 })
-  const contentByModel = {
-    block: blockContent,
-    code: fc.array(text.map((held): AdfNode => ({ text: held, type: 'text' })), { maxLength: 2 }),
-    inline: inlineContent,
-    none: fc.constant<AdfNode[]>([]),
-  }
-  const blockMarks = fc.oneof({ arbitrary: fc.constant<AdfMark[]>([]), weight: 4 }, { arbitrary: marks, weight: 1 })
-  const blockNodes = Object.entries(blockDirectives).map(([type, directive]) => {
-    const argument = blockArgument(type)
-    const vocabulary: AttributeVocabulary = argument === undefined ? directive.attributes : { ...directive.attributes, [argument]: 'string' }
-    const node = fc.record({ attrs: attributes(vocabulary), content: contentByModel[directive.contentModel], marks: blockMarks }).map((held): AdfNode => ({ ...held, type }))
-    return { leaf: directive.contentModel === 'code' || directive.contentModel === 'none', node }
-  })
-  const unknownNode = fc
-    .record({ attrs: fc.dictionary(jsonKey, jsonValue, { maxKeys: 2, noNullPrototype: true }), content: fc.array(tie('inline'), { depthIdentifier, maxLength: 2 }), marks, type: unknownType })
-    .map((held): AdfNode => held)
-  const leafBlocks = blockNodes.filter((entry) => entry.leaf).map((entry) => entry.node)
-  const containerBlocks = blockNodes.filter((entry) => !entry.leaf).map((entry) => entry.node)
-  const misplacedWeight = 7
-  const paragraph = inlineContent.map((content): AdfNode => ({ content, type: 'paragraph' }))
-  const cell = (type: string) => paragraph.map((held): AdfNode => ({ content: [held], type }))
-  const listItems = fc.array(
-    blockContent.map((content): AdfNode => ({ content, type: 'listItem' })),
-    { depthIdentifier, maxLength: 3, minLength: 1 },
-  )
-  const flatCommonMarkShapes = [
-    fc.record({ content: inlineContent, level: fc.integer({ max: 6, min: 1 }) }).map(({ content, level }): AdfNode => ({ attrs: { level }, content, type: 'heading' })),
-    paragraph,
-    fc.record({ body: fc.array(fc.array(cell('tableCell'), { maxLength: 3 }), { maxLength: 2 }), header: fc.array(cell('tableHeader'), { maxLength: 3, minLength: 1 }) }).map(pipeTable),
-  ]
-  const nestingCommonMarkShapes = [
-    blockContent.map((content): AdfNode => ({ content, type: 'blockquote' })),
-    listItems.map((content): AdfNode => ({ content, type: 'bulletList' })),
-    fc
-      .record({ content: listItems, order: fc.oneof({ arbitrary: fc.integer({ max: 3, min: 0 }), weight: 4 }, { arbitrary: fc.integer({ max: 999999999, min: 0 }), weight: 1 }) })
-      .map(({ content, order }): AdfNode => ({ attrs: { order }, content, type: 'orderedList' })),
-  ]
-  const flatBlocks = [...weighted(leafBlocks, 2), ...weighted(flatCommonMarkShapes, flatCommonMarkShapeWeight)]
-  return {
-    block: fc.oneof(
-      { depthIdentifier, depthSize: 'small', maxDepth: 4 },
-      { arbitrary: fc.oneof(...flatBlocks), weight: flatBlocks.reduce((sum, entry) => sum + entry.weight, 0) },
-      { arbitrary: fc.oneof(...containerBlocks), weight: containerBlocks.length * 2 },
-      { arbitrary: fc.oneof(textNode, ...inlineNodes, unknownNode), weight: misplacedWeight },
-      { arbitrary: fc.oneof(...nestingCommonMarkShapes), weight: nestingCommonMarkShapes.length * nestingCommonMarkShapeWeight },
-    ),
-    inline: fc.oneof(
-      { depthIdentifier, depthSize: 'small', maxDepth: 4 },
-      { arbitrary: textNode, weight: 12 },
-      { arbitrary: autolinkTextNode, weight: 2 },
-      { arbitrary: fc.oneof(...inlineNodes), weight: 7 },
-      { arbitrary: fc.oneof(...blockNodes.map((entry) => entry.node), unknownNode), weight: 2 },
-    ),
-  }
-})
-
-const adfDocument = fc.array(positions.block, { depthIdentifier, maxLength: 4, minLength: 1 }).map((content): AdfDocument => toEditorNormal({ content, type: 'doc', version: 1 }))
-
-function runParameters(): { numRuns: number; seed?: number } {
-  const deepRuns = env[deepRunsVariable]
-  if (deepRuns === undefined) return { numRuns: gateRuns, seed: gateSeed }
-  assert.ok(/^[1-9]\d*$/.test(deepRuns), `${deepRunsVariable} is a run count in digits, such as ${deepRunsVariable}=10000: found ${JSON.stringify(deepRuns)}`)
-  return { numRuns: Number(deepRuns) }
-}
 
 test('a generated document refuses to emit, or its markdown reads back to it', { timeout: propertyTimeout }, () => {
   fc.assert(
@@ -178,6 +18,6 @@ test('a generated document refuses to emit, or its markdown reads back to it', {
       assert.ok(read.ok, read.ok ? '' : `${read.error.code}: ${read.error.message} — reading ${JSON.stringify(emitted.value)}`)
       assert.deepEqual(toEditorNormal(read.value), document, `reading ${JSON.stringify(emitted.value)}`)
     }),
-    runParameters(),
+    propertyRuns(gateRuns),
   )
 })
diff --git a/src/markdown-property.test.ts b/src/markdown-property.test.ts
new file mode 100644
index 0000000..b0cd732
--- /dev/null
+++ b/src/markdown-property.test.ts
@@ -0,0 +1,394 @@
+import fc from 'fast-check'
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import type { Arbitrary, DepthIdentifier } from 'fast-check'
+import type { AttributeVocabulary } from './adf/attribute-vocabulary.ts'
+import type { JsonValue } from './json-value.ts'
+import { adfDocument, attributes, jsonKey, jsonValue, markdownPieces, propertyRuns, propertyTimeout, textOf } from './property-generators.ts'
+import { adfToMarkdown } from './markdown/emit/adf-to-markdown.ts'
+import { blockArgument } from './markdown/block-directive-arguments.ts'
+import { blockDirectives } from './adf/block-directives.ts'
+import { carryName } from './markdown/opaque-carry.ts'
+import { fencedCodeBlock } from './markdown/backtick-runs.ts'
+import { inlineDirectives } from './adf/inline-directives.ts'
+import { listBreakName } from './markdown/list-break.ts'
+import { markAttributes } from './adf/mark-attributes.ts'
+import { markSpelling } from './markdown/mark-spellings.ts'
+import { markdownToAdf } from './markdown/parse/markdown-to-adf.ts'
+import { marksAttribute } from './markdown/block-directive-marks.ts'
+import { serializeCanonicalJson } from './canonical-json.ts'
+import { spellAttributes, spellJsonAttribute, spellLeafDirective, spellStringAttribute, spellVocabulary } from './markdown/directive-syntax.ts'
+import { textDirectiveName } from './markdown/text-directive.ts'
+import { toEditorNormal } from './adf/editor-normal.ts'
+import { vocabularyPairs } from './adf/attribute-vocabulary.ts'
+
+type Choice = { arbitrary: Arbitrary<string>; hostile?: true; weight: number }
+
+type Edit = [at: number, removed: number, inserted: string]
+
+const gateRuns = 1000
+
+const vocabularies = [...Object.values(blockDirectives).map((directive) => directive.attributes), ...Object.values(inlineDirectives).map((directive) => directive.attributes), ...Object.values(markAttributes)]
+const attributeKeys = [
+  ...new Set([...vocabularies.flatMap((vocabulary) => Object.keys(vocabulary)), ...Object.keys(blockDirectives).flatMap((type) => blockArgument(type) ?? []), marksAttribute, 'json', textDirectiveName]),
+]
+const directiveNames = [...Object.keys(blockDirectives), ...Object.keys(inlineDirectives), ...Object.keys(markAttributes), carryName, listBreakName, textDirectiveName]
+
+// Hostile generation reaches refusals; clean generation holds none a single piece would trip, so a whole document reaches the emitter.
+function choose(hostile: boolean, choices: readonly Choice[], depth?: { depthIdentifier: DepthIdentifier; maxDepth: number }): Arbitrary<string> {
+  const held = choices.filter((choice) => hostile || choice.hostile !== true).map(({ arbitrary, weight }) => ({ arbitrary, weight }))
+  return depth === undefined ? fc.oneof(...held) : fc.oneof({ ...depth, depthSize: 'small' }, ...held)
+}
+
+const bareToken = fc.stringMatching(/^[A-Za-z0-9_-]{1,8}$/)
+const prose = fc.stringMatching(/^[A-Za-z][a-z]{0,6}(?: [a-z]{1,6}){0,3}$/)
+const cleanText = fc.string({ maxLength: 12, unit: fc.constantFrom(...'aZ09 \t!"#$%&\'()*+,-./;=?@[\\]^_`{}~é\xa0🎉') })
+const syntaxTokens = fc.constantFrom(
+  ...[...String.fromCodePoint(0x0, 0xb, 0xc, 0x85, 0xa0, 0x200b, 0x2028, 0x3000, 0xfeff)],
+  '\n',
+  '\r\n',
+  '\r',
+  '\t',
+  '    ',
+  '  \n',
+  '\\\n',
+  '**',
+  '__',
+  '~~',
+  '***',
+  '```',
+  '~~~',
+  '![',
+  '](',
+  '{}',
+  '::',
+  ':::',
+  '> ',
+  '- ',
+  '* ',
+  '1. ',
+  '2) ',
+  '# ',
+  '---',
+  '===',
+  '| ',
+  ' |',
+  '<!--',
+  '-->',
+  '&amp;',
+  '&#',
+)
+const piece = fc.oneof(markdownPieces, syntaxTokens)
+
+const namedEntity = fc.constantFrom('&amp;', '&lt;', '&quot;', '&copy;', '&nbsp;', '&ouml;', '&bogus;', '&amp', '&#;', '&AMP;', '&ngE;')
+const numericEntity = fc
+  .tuple(fc.oneof(fc.integer({ max: 0x7f, min: 0 }), fc.integer({ max: 0xffff, min: 0 }), fc.integer({ max: 0x110000, min: 0 })), fc.boolean())
+  .map(([code, hex]) => (hex ? `&#x${code.toString(16)};` : `&#${code};`))
+const escape = fc.constantFrom(...'!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~a \n').map((escaped) => `\\${escaped}`)
+const backticks = fc.integer({ max: 3, min: 1 }).map((count) => '`'.repeat(count))
+const codeSpan = fc
+  .tuple(backticks, fc.oneof(prose, textOf(0)), fc.oneof({ arbitrary: fc.constant(undefined), weight: 4 }, { arbitrary: backticks, weight: 1 }))
+  .map(([opener, body, closer]) => `${opener}${body}${closer ?? opener}`)
+const autolink = fc.oneof(
+  fc.tuple(fc.constantFrom('http://', 'https://', 'mailto:', 'ab:', 'x+y.z-:'), prose).map(([scheme, rest]) => `<${scheme}${rest.replaceAll(' ', '/')}>`),
+  fc.stringMatching(/^<[a-z.+]{1,6}@[a-z-]{1,6}(?:\.[a-z]{1,4})?>$/),
+)
+const hostileAutolink = fc.tuple(fc.constantFrom('http://', 'ab:', 'a:'), textOf(0)).map(([scheme, rest]) => `<${scheme}${rest}>`)
+const inlineHtml = fc.constantFrom('<span>', '</span>', '<a href="x">', "<b class='y'/>", '<!-- c -->', '<!---->', '<?x?>', '<![CDATA[x]]>', '<!X y>', '<br/>', '<b', '<3', '< a>')
+const hardBreak = fc.constantFrom('\\\n', '  \n', '\n', ':hardBreak{}')
+const textDirective = fc.constantFrom(' ', '  ', '\t', '\n', '\n\n').map((held) => `:${textDirectiveName}{${textDirectiveName}=${spellStringAttribute(held)}}`)
+const hostileTextDirective = fc.constantFrom(' \n', 'a', '').map((held) => `:${textDirectiveName}{${textDirectiveName}=${spellStringAttribute(held)}}`)
+
+const url = fc.stringMatching(/^https?:\/\/[a-z]{1,6}\.[a-z]{2,3}(?:\/[a-z0-9()]{0,5})?$/)
+const title = (text: Arbitrary<string>) => fc.oneof(fc.constant(''), text.map((held) => ` "${held}"`), text.map((held) => ` '${held}'`), text.map((held) => ` (${held})`))
+
+const attributeValue = fc.oneof(
+  { arbitrary: bareToken, weight: 3 },
+  { arbitrary: fc.constantFrom('true', 'false', '0', '1', '3', '-1', '1.5', '1e2', '"1"', '01', 'null', '"[]"', '"{}"', '"#deebff"'), weight: 2 },
+  { arbitrary: textOf(0).map(spellStringAttribute), weight: 3 },
+  { arbitrary: jsonValue.map(spellJsonAttribute), weight: 2 },
+  { arbitrary: textOf(0).map((held) => JSON.stringify(held)), weight: 1 },
+  { arbitrary: textOf(0).map((held) => `"${held}`), weight: 1 },
+)
+const attributePairs = fc.uniqueArray(fc.tuple(fc.oneof({ arbitrary: fc.constantFrom(...attributeKeys), weight: 4 }, { arbitrary: bareToken, weight: 1 }), attributeValue), {
+  maxLength: 3,
+  minLength: 1,
+  selector: ([key]) => key,
+})
+const hostileAttributes = fc.oneof(
+  { arbitrary: fc.constant(''), weight: 3 },
+  {
+    arbitrary: fc.tuple(attributePairs, fc.boolean()).map(([pairs, sorted]) => {
+      const ordered = sorted ? pairs.toSorted(([left], [right]) => (left < right ? -1 : 1)) : pairs
+      return `{${ordered.map(([key, value]) => `${key}=${value}`).join(' ')}}`
+    }),
+    weight: 6,
+  },
+  { arbitrary: fc.constantFrom('{}', '{ }', '{a}', '{a=}', '{=b}', '{a=b', '{a=b  c=d}', '{a="}"}'), weight: 1 },
+)
+
+function tableAttributes(vocabulary: AttributeVocabulary, slot?: string): Arbitrary<string> {
+  return attributes(vocabulary).map((attrs) => spellAttributes(spellVocabulary(vocabularyPairs(attrs, vocabulary, slot === undefined ? [] : [slot]) ?? [])))
+}
+
+const directiveName = fc.oneof({ arbitrary: fc.constantFrom(...directiveNames), weight: 8 }, { arbitrary: fc.stringMatching(/^[A-Za-z0-9-]{1,6}$/), weight: 1 })
+const hostileArgument = fc.oneof(
+  { arbitrary: fc.constant(''), weight: 3 },
+  { arbitrary: fc.constantFrom(' info', ' warning', ' custom', ' DONE', ' TODO'), weight: 2 },
+  { arbitrary: fc.oneof(bareToken.map((held) => ` ${held}`), fc.constantFrom('  info', ' a b', ' "a"')), weight: 1 },
+)
+
+function directiveHeader(colons: number, name: string, argument: string, attrs: string): string {
+  return `${':'.repeat(colons)}${name}${argument}${attrs === '' ? '' : ` ${attrs}`}`
+}
+
+function container(header: (colons: number) => string, body: string, closer: number | null): string {
+  const colons = Math.max(2, ...[...body.matchAll(/:{2,}/g)].map(([run]) => run.length)) + 1
+  return [header(colons), ...(body === '' ? [] : [body]), ':'.repeat(closer ?? colons)].join('\n')
+}
+
+const carriedNode = fc.oneof(
+  fc.tuple(fc.constantFrom('mention', 'paragraph', 'status', 'widget'), fc.dictionary(jsonKey, jsonValue, { maxKeys: 2, noNullPrototype: true })).map(([type, attrs]): JsonValue => ({ attrs, type })),
+  textOf(1).map((held): JsonValue => ({ text: held, type: 'text' })),
+)
+const inlineCarry = carriedNode.map((node) => `:${carryName}{json=${spellStringAttribute(serializeCanonicalJson(node, 'compact'))}}`)
+const hostileInlineCarry = fc.oneof(carriedNode, jsonValue).map((node) => `:${carryName}{json=${spellStringAttribute(JSON.stringify(node, null, 1))}}`)
+const blockCarry = carriedNode.map((node) => fencedCodeBlock(carryName, serializeCanonicalJson(node, 'two-space')))
+const hostileBlockCarry = fc.oneof(carriedNode, jsonValue).map((node) => fencedCodeBlock(carryName, JSON.stringify(node)))
+
+function prefixLines(body: string, first: string, rest: (index: number) => string): string {
+  return body
+    .split('\n')
+    .map((line, index) => (index === 0 ? `${first}${line}` : line === '' ? rest(index).trimEnd() : `${rest(index)}${line}`))
+    .join('\n')
+}
+
+const separator = fc.oneof({ arbitrary: fc.constant('\n\n'), weight: 4 }, { arbitrary: fc.constant('\n'), weight: 3 }, { arbitrary: fc.constantFrom('\n\n\n', '\n \n', '\n\t\n'), weight: 1 })
+const quotePrefix = fc.oneof({ arbitrary: fc.constant('> '), weight: 6 }, { arbitrary: fc.constantFrom('>', ' > ', '>  ', '>\t', ''), weight: 1 })
+const listMarker = fc.oneof(
+  { arbitrary: fc.constantFrom('-', '*', '+'), weight: 3 },
+  {
+    arbitrary: fc
+      .tuple(fc.oneof({ arbitrary: fc.integer({ max: 3, min: 0 }), weight: 4 }, { arbitrary: fc.integer({ max: 1000000000, min: 0 }), weight: 1 }), fc.constantFrom('.', ')'))
+      .map(([start, delimiter]) => `${start}${delimiter}`),
+    weight: 2,
+  },
+)
+const indentDrift = fc.oneof({ arbitrary: fc.constant(0), weight: 6 }, { arbitrary: fc.integer({ max: 2, min: -2 }), weight: 1 })
+const closerDrift = fc.option(fc.integer({ max: 5, min: 2 }), { freq: 6 })
+
+function markdownOf(hostile: boolean): Arbitrary<string> {
+  const blockDepth = fc.createDepthIdentifier()
+  const inlineDepth = fc.createDepthIdentifier()
+  const text = hostile ? fc.oneof(cleanText, textOf(0)) : cleanText
+  const word = fc.oneof({ arbitrary: prose, weight: 3 }, { arbitrary: text.filter((held) => held !== ''), weight: 2 })
+  const destination = fc.oneof(url, text, fc.stringMatching(/^<[0-9.#][a-z0-9 ]{0,6}>$/), fc.constant(''), ...(hostile ? [text.map((held) => `<${held}>`)] : []))
+  const label = fc.oneof(prose, word)
+
+  const { inlines } = fc.letrec<{ inline: string; inlines: string }>((tie) => ({
+    inline: choose(
+      hostile,
+      [
+        { arbitrary: word, weight: 12 },
+        { arbitrary: fc.oneof(codeSpan, autolink, namedEntity, numericEntity, escape, hardBreak, textDirective, inlineCarry), weight: 8 },
+        { arbitrary: fc.oneof(hostileAutolink, hostileInlineCarry, hostileTextDirective, inlineHtml, piece), hostile: true, weight: 4 },
+        {
+          arbitrary: fc
+            .tuple(fc.constantFrom('*', '_', '**', '__', '***', '~~', '~'), fc.constantFrom('', '', ' '), tie('inlines'), fc.constantFrom('', '', ' '), fc.option(fc.constantFrom('*', '_', '**', '~~'), { freq: 4 }))
+            .map(([opener, inside, body, closing, closer]) => `${opener}${inside}${body}${closing}${closer ?? opener}`),
+          weight: 4,
+        },
+        {
+          arbitrary: fc
+            .tuple(fc.constantFrom('', '', hostile ? '!' : ''), tie('inlines'), fc.oneof(fc.tuple(destination, title(text)).map(([target, titled]) => `(${target}${titled})`), label.map((held) => `[${held}]`), fc.constantFrom('', '[]')))
+            .map(([image, content, target]) => `${image}[${content}]${target}`),
+          weight: 3,
+        },
+        {
+          arbitrary: fc.oneof(
+            ...Object.entries(inlineDirectives).map(([name, directive]) =>
+              fc
+                .tuple(directive.textAttribute === undefined ? fc.constant(null) : fc.option(hostile ? word : prose), tableAttributes(directive.attributes, directive.textAttribute))
+                .map(([slot, attrs]) => (slot === null ? spellLeafDirective(name, attrs) : `:${name}[${slot}]${attrs}`)),
+            ),
+            ...Object.entries(markAttributes)
+              .filter(([name]) => hostile || markSpelling(name)?.kind === 'directive')
+              .map(([name, vocabulary]) => fc.tuple(tie('inlines'), tableAttributes(vocabulary)).map(([content, attrs]) => `:${name}[${content}]${attrs}`)),
+          ),
+          weight: 2,
+        },
+        {
+          arbitrary: fc.tuple(directiveName, fc.option(tie('inlines'), { freq: 3 }), hostileAttributes).map(([name, content, attrs]) => `:${name}${content === null ? '' : `[${content}]`}${attrs}`),
+          hostile: true,
+          weight: 2,
+        },
+      ],
+      { depthIdentifier: inlineDepth, maxDepth: 3 },
+    ),
+    inlines: fc.array(tie('inline'), { depthIdentifier: inlineDepth, maxLength: 4, minLength: 1 }).map((parts) => parts.join('')),
+  }))
+
+  const oneLine = inlines.map((held) => held.replace(/[\n\r]/g, ' '))
+  const fencedCode = fc
+    .tuple(
+      fc.constantFrom('```', '```', '~~~', '````', '``'),
+      fc.oneof(fc.constant(''), bareToken, text),
+      fc.array(fc.oneof(prose, text, fc.constantFrom('```', '~~~', ':::', '    x')), { maxLength: 3 }),
+      fc.constantFrom('', '', '`', '~', 'none'),
+    )
+    .map(([fence, info, lines, closer]) => [`${fence}${info}`, ...lines, ...(closer === 'none' ? [] : [`${fence}${closer}`])].join('\n'))
+  const pipeTable = fc
+    .record({
+      body: fc.array(fc.array(oneLine, { maxLength: 3 }), { maxLength: 2 }),
+      delimiter: fc.array(fc.constantFrom('---', '-', ':--', '--:', ':-:', '', '==='), { maxLength: 3, minLength: 1 }),
+      header: fc.array(oneLine, { maxLength: 3, minLength: 1 }),
+      leading: fc.boolean(),
+      regular: hostile ? fc.boolean() : fc.constant(true),
+      trailing: fc.boolean(),
+    })
+    .map(({ body, delimiter, header, leading, regular, trailing }) => {
+      const row = (cells: readonly string[]) => (regular || leading ? `| ${cells.join(' | ')}` : cells.join(' | ')) + (regular || trailing ? ' |' : '')
+      const width = (cells: readonly string[]) => (regular ? header.map((_, index) => cells[index] ?? '') : cells)
+      return [row(header), row(regular ? header.map(() => '---') : delimiter), ...body.map((cells) => row(width(cells)))].join('\n')
+    })
+
+  const leafBlock = choose(hostile, [
+    {
+      arbitrary: fc
+        .tuple(fc.integer({ max: 7, min: 1 }), fc.constantFrom(' ', ' ', '', '\t'), oneLine, fc.constantFrom('', '', ' #', '#', ' ##  '))
+        .map(([level, gap, content, closer]) => `${'#'.repeat(level)}${gap}${content}${closer}`),
+      weight: 3,
+    },
+    {
+      arbitrary: fc.tuple(inlines, fc.constantFrom('=', '-'), fc.integer({ max: 4, min: 1 }), fc.constantFrom('', ' ')).map(([content, underline, length, trailing]) => `${content}\n${underline.repeat(length)}${trailing}`),
+      weight: 2,
+    },
+    { arbitrary: fc.constantFrom('---', '***', '___', '- - -', ' * * *', '_____', '--', '*-*'), weight: 1 },
+    { arbitrary: fencedCode, weight: 2 },
+    { arbitrary: blockCarry, weight: 1 },
+    {
+      arbitrary: fc.tuple(fc.constantFrom('    ', '\t', '     '), fc.array(fc.oneof(prose, text), { maxLength: 3, minLength: 1 })).map(([indent, lines]) => lines.map((line) => `${indent}${line}`).join('\n')),
+      weight: 1,
+    },
+    { arbitrary: pipeTable, weight: 2 },
+    { arbitrary: fc.tuple(label, destination, title(text)).map(([name, target, titled]) => `[${name}]: ${target}${titled}`), weight: 1 },
+    { arbitrary: fc.tuple(word, fc.oneof(url, fc.constant(''))).map(([alt, target]) => `![${alt}](${target})`), weight: 1 },
+    { arbitrary: hostileBlockCarry, hostile: true, weight: 1 },
+    {
+      arbitrary: fc.constantFrom('<div>\ntext\n</div>', '<!-- comment -->', '<pre>\nx\n</pre>', '<?php echo 1; ?>', '<!DOCTYPE html>', '<table>', '<custom-tag attr="1">', '</div>', '<![CDATA[\nx\n]]>'),
+      hostile: true,
+      weight: 1,
+    },
+    {
+      arbitrary: fc.tuple(fc.constantFrom(2, 2, 3, 1, 4), directiveName, hostileArgument, hostileAttributes).map(([colons, name, argument, attrs]) => directiveHeader(colons, name, argument, attrs)),
+      hostile: true,
+      weight: 1,
+    },
+    { arbitrary: fc.constantFrom(':::', '::', '::::', ':::panel', '::: panel', ':::panel info extra'), hostile: true, weight: 1 },
+  ])
+
+  const { blocks } = fc.letrec<{ block: string; blocks: string }>((tie) => {
+    const bodyByModel = { block: fc.oneof(tie('blocks'), fc.constant('')), code: fencedCode, inline: fc.oneof(oneLine, fc.constant('')) }
+    const tableDirectives = Object.entries(blockDirectives).map(([name, directive]) => {
+      const argument =
+        blockArgument(name) === undefined
+          ? fc.constant('')
+          : fc.oneof({ arbitrary: fc.constantFrom(' DONE', ' TODO', ' custom', ' info', ' warning'), weight: 3 }, { arbitrary: bareToken.map((held) => ` ${held}`), weight: 1 })
+      const attrs = hostile ? fc.oneof({ arbitrary: tableAttributes(directive.attributes), weight: 4 }, { arbitrary: hostileAttributes, weight: 1 }) : tableAttributes(directive.attributes)
+      if (directive.contentModel === 'none') return fc.tuple(argument, attrs).map(([held, spelled]) => directiveHeader(2, name, held, spelled))
+      return fc
+        .tuple(argument, attrs, bodyByModel[directive.contentModel], hostile ? closerDrift : fc.constant(null))
+        .map(([held, spelled, body, closer]) => container((colons) => directiveHeader(colons, name, held, spelled), body, closer))
+    })
+    return {
+      block: choose(
+        hostile,
+        [
+          { arbitrary: fc.array(inlines, { maxLength: 3, minLength: 1 }).map((lines) => lines.join('\n')), weight: 10 },
+          { arbitrary: leafBlock, weight: 10 },
+          {
+            arbitrary: fc.tuple(tie('blocks'), fc.array(quotePrefix, { maxLength: 3, minLength: 1 })).map(([body, prefixes]) => prefixLines(body, '> ', (index) => prefixes[index % prefixes.length] ?? '')),
+            weight: 3,
+          },
+          {
+            arbitrary: fc
+              .tuple(listMarker, fc.array(fc.tuple(fc.option(listMarker, { freq: 4 }), fc.constantFrom(' ', ' ', ' ', '  ', '\t', '', '     '), tie('blocks'), indentDrift), { maxLength: 3, minLength: 1 }), separator)
+              .map(([listed, items, gap]) =>
+                items
+                  .map(([own, space, body, drift]) => {
+                    const marker = own ?? listed
+                    return prefixLines(body, `${marker}${space}`, () => ' '.repeat(Math.max(0, marker.length + space.length + drift)))
+                  })
+                  .join(gap === '\n\n' ? '\n\n' : '\n'),
+              ),
+            weight: 4,
+          },
+          { arbitrary: fc.oneof(...tableDirectives), weight: 3 },
+          {
+            arbitrary: fc
+              .tuple(directiveName, hostileArgument, hostileAttributes, tie('blocks'), fc.option(fc.integer({ max: 5, min: 3 }), { freq: 2 }), closerDrift)
+              .map(([name, argument, attrs, body, opener, closer]) => container((colons) => directiveHeader(opener ?? colons, name, argument, attrs), body, closer)),
+            hostile: true,
+            weight: 1,
+          },
+        ],
+        { depthIdentifier: blockDepth, maxDepth: 3 },
+      ),
+      blocks: fc
+        .array(fc.tuple(separator, tie('block')), { depthIdentifier: blockDepth, maxLength: 3, minLength: 1 })
+        .map((entries) => entries.map(([gap, block], index) => (index === 0 ? block : `${gap}${block}`)).join('')),
+    }
+  })
+  return blocks
+}
+
+const cleanMarkdown = markdownOf(false)
+const hostileMarkdown = markdownOf(true)
+
+const canonical = adfDocument.map((document) => {
+  const emitted = adfToMarkdown(document)
+  return emitted.ok ? emitted.value : ''
+})
+
+function edited(markdown: string, edits: readonly Edit[]): string {
+  let text = markdown
+  for (const [at, removed, inserted] of edits) {
+    const index = at % (text.length + 1)
+    text = `${text.slice(0, index)}${inserted}${text.slice(index + removed)}`
+  }
+  return text
+}
+
+const edit: Arbitrary<Edit> = fc.tuple(fc.nat(), fc.nat({ max: 3 }), fc.oneof(piece, fc.constant('')))
+
+const markdown = fc.oneof(
+  { arbitrary: cleanMarkdown, weight: 4 },
+  { arbitrary: hostileMarkdown, weight: 2 },
+  { arbitrary: canonical, weight: 2 },
+  { arbitrary: fc.tuple(fc.oneof(cleanMarkdown, canonical), fc.array(edit, { maxLength: 3, minLength: 1 })).map(([held, edits]) => edited(held, edits)), weight: 3 },
+  { arbitrary: fc.string({ maxLength: 40, unit: piece }), weight: 1 },
+)
+
+const document = fc
+  .tuple(markdown, fc.oneof({ arbitrary: fc.constant('\n'), weight: 8 }, { arbitrary: fc.constantFrom('\r\n', '\r'), weight: 1 }), fc.constantFrom('', '', '\n', '  \n'))
+  .map(([held, ending, trailing]) => `${held}${trailing}`.replaceAll('\n', ending))
+
+test('generated markdown refuses, or what it parses to refuses to emit, or its spelling reads back and spells itself', { timeout: propertyTimeout }, () => {
+  fc.assert(
+    fc.property(document, (input) => {
+      const parsed = markdownToAdf(input)
+      if (!parsed.ok) return
+      const emitted = adfToMarkdown(parsed.value)
+      if (!emitted.ok) return
+      const read = markdownToAdf(emitted.value)
+      assert.ok(read.ok, read.ok ? '' : `${read.error.code}: ${read.error.message} — reading ${JSON.stringify(emitted.value)}`)
+      assert.deepEqual(toEditorNormal(read.value), toEditorNormal(parsed.value), `reading ${JSON.stringify(emitted.value)}`)
+      const respelled = adfToMarkdown(read.value)
+      assert.ok(respelled.ok, respelled.ok ? '' : `${respelled.error.code}: ${respelled.error.message} — spelling ${JSON.stringify(emitted.value)} again`)
+      assert.equal(respelled.value, emitted.value)
+    }),
+    propertyRuns(gateRuns),
+  )
+})
+
diff --git a/src/property-generators.ts b/src/property-generators.ts
new file mode 100644
index 0000000..4e38daf
--- /dev/null
+++ b/src/property-generators.ts
@@ -0,0 +1,166 @@
+import fc from 'fast-check'
+import assert from 'node:assert/strict'
+import { env } from 'node:process'
+
+import type { AdfAttributes, AdfDocument, AdfMark, AdfNode } from './adf/document.ts'
+import type { Arbitrary } from 'fast-check'
+import type { AttributeKind, AttributeVocabulary } from './adf/attribute-vocabulary.ts'
+import type { JsonValue } from './json-value.ts'
+import { blockArgument } from './markdown/block-directive-arguments.ts'
+import { blockDirectives } from './adf/block-directives.ts'
+import { inlineDirectives } from './adf/inline-directives.ts'
+import { markAttributes } from './adf/mark-attributes.ts'
+import { toEditorNormal } from './adf/editor-normal.ts'
+
+type Positions = { block: AdfNode; inline: AdfNode }
+
+const deepRunsVariable = 'PROPERTY_RUNS'
+const gateSeed = 20260914
+// Bun's test runner stops a test after five seconds unless the test sets its own timeout.
+export const propertyTimeout = 600000
+
+const depthIdentifier = fc.createDepthIdentifier()
+const emptyCell: AdfNode = { content: [{ type: 'paragraph' }], type: 'tableCell' }
+const flatCommonMarkShapeWeight = 4
+export const markdownPieces = fc.constantFrom(...'aZ09 \t\n!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~é\xa0🎉', ':a[', ':a{', 'ab:', 'http://')
+const nestingCommonMarkShapeWeight = 21
+const spelledTypes = new Set(['text', ...Object.keys(blockDirectives), ...Object.keys(inlineDirectives), ...Object.keys(markAttributes)])
+
+export function textOf(minLength: number): Arbitrary<string> {
+  return fc.oneof(
+    { arbitrary: fc.string({ maxLength: 12, minLength, unit: markdownPieces }), weight: 4 },
+    { arbitrary: fc.string({ maxLength: 6, minLength, unit: 'grapheme' }), weight: 1 },
+  )
+}
+
+const text = textOf(1)
+const unknownType = fc.oneof(fc.stringMatching(/^[a-z][A-Za-z0-9]{0,7}$/), text).filter((type) => !spelledTypes.has(type))
+const numberValue = fc.oneof({ arbitrary: fc.integer({ max: 10, min: -1 }), weight: 3 }, { arbitrary: fc.double({ noDefaultInfinity: true, noNaN: true }), weight: 1 })
+
+// V8's JSON.parse returns a wrong key after parsing a key holding an escaped backslash (https://issues.chromium.org/issues/521080746); Bun is unaffected.
+const keyPiece = fc
+  .oneof({ arbitrary: markdownPieces, weight: 4 }, { arbitrary: fc.string({ maxLength: 1, minLength: 1, unit: 'grapheme' }), weight: 1 })
+  .filter((piece) => !/[\\"\x00-\x1f]/.test(piece))
+export const jsonKey = fc.string({ maxLength: 8, unit: keyPiece })
+
+export const { jsonValue } = fc.letrec<{ jsonValue: JsonValue }>((tie) => ({
+  jsonValue: fc.oneof(
+    { depthSize: 'small', maxDepth: 2 },
+    fc.oneof(fc.constant(null), fc.boolean(), numberValue, textOf(0)),
+    fc.array(tie('jsonValue'), { maxLength: 3 }),
+    fc.dictionary(jsonKey, tie('jsonValue'), { maxKeys: 3, noNullPrototype: true }),
+  ),
+}))
+
+const valueByKind: Readonly<Record<AttributeKind, Arbitrary<JsonValue>>> = {
+  boolean: fc.boolean(),
+  json: jsonValue,
+  number: numberValue,
+  string: textOf(0),
+}
+
+export function attributes(vocabulary: AttributeVocabulary): Arbitrary<AdfAttributes> {
+  const model = Object.fromEntries(
+    Object.entries(vocabulary).map(([key, kind]) => [key, fc.oneof({ arbitrary: fc.constant(undefined), weight: 2 }, { arbitrary: valueByKind[kind], weight: 1 })]),
+  )
+  return fc.record(model).map(heldAttributes)
+}
+
+function heldAttributes(held: Readonly<Record<string, JsonValue | undefined>>): AdfAttributes {
+  const attrs: AdfAttributes = {}
+  for (const [key, value] of Object.entries(held)) if (value !== undefined) attrs[key] = value
+  return attrs
+}
+
+function pipeTable({ body, header }: { body: AdfNode[][]; header: AdfNode[] }): AdfNode {
+  const rows = [header, ...body.map((cells) => header.map((_, index) => cells[index] ?? emptyCell))]
+  return { content: rows.map((content): AdfNode => ({ content, type: 'tableRow' })), type: 'table' }
+}
+
+const mark: Arbitrary<AdfMark> = fc.oneof(
+  { arbitrary: fc.oneof(...Object.entries(markAttributes).map(([type, vocabulary]) => attributes(vocabulary).map((attrs) => ({ attrs, type })))), weight: 9 },
+  { arbitrary: fc.record({ attrs: fc.dictionary(jsonKey, jsonValue, { maxKeys: 2, noNullPrototype: true }), type: unknownType }), weight: 1 },
+)
+const marks = fc.uniqueArray(mark, { maxLength: 3, selector: (held) => held.type })
+
+const textNode = fc.record({ marks, text }).map((held): AdfNode => ({ ...held, type: 'text' }))
+
+const autolinkTextNode = fc
+  .record({ href: fc.tuple(fc.constantFrom('ab:', 'http://'), textOf(0)).map(([scheme, rest]) => `${scheme}${rest}`), marks })
+  .map(({ href, marks: held }): AdfNode => ({ marks: [...held.filter((outer) => outer.type !== 'link'), { attrs: { href }, type: 'link' }], text: href, type: 'text' }))
+
+const inlineNodes = Object.entries(inlineDirectives).map(([type, directive]) =>
+  fc.record({ attrs: attributes(directive.attributes), marks }).map((held): AdfNode => ({ ...held, type })),
+)
+
+function weighted(arbitraries: readonly Arbitrary<AdfNode>[], weight: number): { arbitrary: Arbitrary<AdfNode>; weight: number }[] {
+  return arbitraries.map((arbitrary) => ({ arbitrary, weight }))
+}
+
+const positions = fc.letrec<Positions>((tie) => {
+  const blockContent = fc.array(tie('block'), { depthIdentifier, maxLength: 3 })
+  const inlineContent = fc.array(tie('inline'), { depthIdentifier, maxLength: 4 })
+  const contentByModel = {
+    block: blockContent,
+    code: fc.array(text.map((held): AdfNode => ({ text: held, type: 'text' })), { maxLength: 2 }),
+    inline: inlineContent,
+    none: fc.constant<AdfNode[]>([]),
+  }
+  const blockMarks = fc.oneof({ arbitrary: fc.constant<AdfMark[]>([]), weight: 4 }, { arbitrary: marks, weight: 1 })
+  const blockNodes = Object.entries(blockDirectives).map(([type, directive]) => {
+    const argument = blockArgument(type)
+    const vocabulary: AttributeVocabulary = argument === undefined ? directive.attributes : { ...directive.attributes, [argument]: 'string' }
+    const node = fc.record({ attrs: attributes(vocabulary), content: contentByModel[directive.contentModel], marks: blockMarks }).map((held): AdfNode => ({ ...held, type }))
+    return { leaf: directive.contentModel === 'code' || directive.contentModel === 'none', node }
+  })
+  const unknownNode = fc
+    .record({ attrs: fc.dictionary(jsonKey, jsonValue, { maxKeys: 2, noNullPrototype: true }), content: fc.array(tie('inline'), { depthIdentifier, maxLength: 2 }), marks, type: unknownType })
+    .map((held): AdfNode => held)
+  const leafBlocks = blockNodes.filter((entry) => entry.leaf).map((entry) => entry.node)
+  const containerBlocks = blockNodes.filter((entry) => !entry.leaf).map((entry) => entry.node)
+  const misplacedWeight = 7
+  const paragraph = inlineContent.map((content): AdfNode => ({ content, type: 'paragraph' }))
+  const cell = (type: string) => paragraph.map((held): AdfNode => ({ content: [held], type }))
+  const listItems = fc.array(
+    blockContent.map((content): AdfNode => ({ content, type: 'listItem' })),
+    { depthIdentifier, maxLength: 3, minLength: 1 },
+  )
+  const flatCommonMarkShapes = [
+    fc.record({ content: inlineContent, level: fc.integer({ max: 6, min: 1 }) }).map(({ content, level }): AdfNode => ({ attrs: { level }, content, type: 'heading' })),
+    paragraph,
+    fc.record({ body: fc.array(fc.array(cell('tableCell'), { maxLength: 3 }), { maxLength: 2 }), header: fc.array(cell('tableHeader'), { maxLength: 3, minLength: 1 }) }).map(pipeTable),
+  ]
+  const nestingCommonMarkShapes = [
+    blockContent.map((content): AdfNode => ({ content, type: 'blockquote' })),
+    listItems.map((content): AdfNode => ({ content, type: 'bulletList' })),
+    fc
+      .record({ content: listItems, order: fc.oneof({ arbitrary: fc.integer({ max: 3, min: 0 }), weight: 4 }, { arbitrary: fc.integer({ max: 999999999, min: 0 }), weight: 1 }) })
+      .map(({ content, order }): AdfNode => ({ attrs: { order }, content, type: 'orderedList' })),
+  ]
+  const flatBlocks = [...weighted(leafBlocks, 2), ...weighted(flatCommonMarkShapes, flatCommonMarkShapeWeight)]
+  return {
+    block: fc.oneof(
+      { depthIdentifier, depthSize: 'small', maxDepth: 4 },
+      { arbitrary: fc.oneof(...flatBlocks), weight: flatBlocks.reduce((sum, entry) => sum + entry.weight, 0) },
+      { arbitrary: fc.oneof(...containerBlocks), weight: containerBlocks.length * 2 },
+      { arbitrary: fc.oneof(textNode, ...inlineNodes, unknownNode), weight: misplacedWeight },
+      { arbitrary: fc.oneof(...nestingCommonMarkShapes), weight: nestingCommonMarkShapes.length * nestingCommonMarkShapeWeight },
+    ),
+    inline: fc.oneof(
+      { depthIdentifier, depthSize: 'small', maxDepth: 4 },
+      { arbitrary: textNode, weight: 12 },
+      { arbitrary: autolinkTextNode, weight: 2 },
+      { arbitrary: fc.oneof(...inlineNodes), weight: 7 },
+      { arbitrary: fc.oneof(...blockNodes.map((entry) => entry.node), unknownNode), weight: 2 },
+    ),
+  }
+})
+
+export const adfDocument = fc.array(positions.block, { depthIdentifier, maxLength: 4, minLength: 1 }).map((content): AdfDocument => toEditorNormal({ content, type: 'doc', version: 1 }))
+
+export function propertyRuns(gateRuns: number): { numRuns: number; seed?: number } {
+  const deepRuns = env[deepRunsVariable]
+  if (deepRuns === undefined) return { numRuns: gateRuns, seed: gateSeed }
+  assert.ok(/^[1-9]\d*$/.test(deepRuns), `${deepRunsVariable} is a run count in digits, such as ${deepRunsVariable}=10000: found ${JSON.stringify(deepRuns)}`)
+  return { numRuns: Number(deepRuns) }
+}
diff --git a/tsconfig.build.json b/tsconfig.build.json
index 3f6e2c7..6b17c1b 100644
--- a/tsconfig.build.json
+++ b/tsconfig.build.json
@@ -27,6 +27,6 @@
     "forceConsistentCasingInFileNames": true,
     "skipLibCheck": true
   },
-  "exclude": ["src/**/*.test.ts"],
+  "exclude": ["src/**/*.test.ts", "src/property-generators.ts"],
   "include": ["src"]
 }