Answer the architecture pass: the seam attribute reading names, and the speller a third file copied

src/markdown/directive-syntax.ts

@@ -87,6 +87,10 @@ export function spellJsonAttribute(value: JsonValue): string {
   return quote(serializeCanonicalJson(value, 'compact'))
 }
 
+export function spellLeafDirective(name: string, attributes: string): string {
+  return `:${name}${attributes === '' ? '{}' : attributes}`
+}
+
 export function spellStringAttribute(text: string): string {
   return isBareToken(text) ? text : quote(text)
 }

src/markdown/emit/inline-line.ts

@@ -12,6 +12,7 @@ import { markSpelling, spellMarkAttributes } from '../mark-spellings.ts'
 import { sameMark } from '../../adf/editor-normal.ts'
 import { spellDestination, spellTitle } from '../link-syntax.ts'
 import { spellInlineNodeAttributes } from './inline-directive-spelling.ts'
+import { spellLeafDirective } from '../directive-syntax.ts'
 import { spellTextDirective } from '../text-directive.ts'
 
 type EmittedLine = { line: string; segments: InlineSegment[] }
@@ -121,10 +122,6 @@ function carriedText(text: string): InlineSegment {
   return syntax(spellTextDirective(text))
 }
 
-function spellLeafDirective(name: string, attributes: string): string {
-  return `:${name}${attributes === '' ? '{}' : attributes}`
-}
-
 function syntax(text: string): InlineSegment {
   return { escaping: 'none', text }
 }

src/markdown/parse/directive-attributes.ts

@@ -0,0 +1,31 @@
+import type { AdfAttributes } from '../../adf/document.ts'
+import type { AttributeVocabulary } from '../../adf/attribute-vocabulary.ts'
+import type { DirectiveAttributes } from '../directive-syntax.ts'
+import { attributeValue, spellAttributeValue } from '../directive-syntax.ts'
+import { failure, success, type ConvertErrorPath, type Result } from '../../result.ts'
+
+export type Elsewhere = { key: string; slot: 'argument' | 'content' }
+
+export function readVocabulary(
+  type: string,
+  attributes: DirectiveAttributes,
+  vocabulary: AttributeVocabulary,
+  elsewhere: Elsewhere | undefined,
+  path: ConvertErrorPath,
+): Result<AdfAttributes> {
+  const attrs: AdfAttributes = {}
+  for (const [key, spelled] of attributes) {
+    if (key === elsewhere?.key) {
+      const place = elsewhere.slot === 'argument' ? 'as the directive argument' : 'in the content slot'
+      return failure('unsupported-node-shape', `${type} spells its ${key} attribute ${place}`, path)
+    }
+    const kind = Object.hasOwn(vocabulary, key) ? vocabulary[key] : undefined
+    if (kind === undefined) return failure('unsupported-node-shape', `${type} holds no ${key} attribute`, path)
+    const read = attributeValue(spelled.decoded, kind)
+    if (read === undefined) return failure('unsupported-node-shape', `the ${key} attribute of ${type} is no ${kind}`, path)
+    const spelling = spellAttributeValue(read)
+    if (spelling !== spelled.spelling) return failure('unsupported-node-shape', `${type} spells its ${key} attribute as ${key}=${spelling}`, path)
+    attrs[key] = read.value
+  }
+  return success(attrs)
+}

src/markdown/parse/directive-marks.ts

@@ -3,7 +3,7 @@ import type { DirectiveAttributes } from '../directive-syntax.ts'
 import type { MarkSpelling } from '../mark-spellings.ts'
 import { failure, success, type ConvertErrorPath, type Result } from '../../result.ts'
 import { markSpelling } from '../mark-spellings.ts'
-import { readVocabulary } from './directive-nodes.ts'
+import { readVocabulary } from './directive-attributes.ts'
 
 export function readDirectiveMark(name: string, attributes: DirectiveAttributes, path: ConvertErrorPath): Result<AdfMark> | undefined {
   const spelling = markSpelling(name)

src/markdown/parse/directive-nodes.ts

@@ -1,7 +1,7 @@
 import type { AdfAttributes, AdfMark, AdfNode } from '../../adf/document.ts'
-import type { AttributeVocabulary } from '../../adf/attribute-vocabulary.ts'
 import type { BlockDirective } from '../../adf/block-directives.ts'
 import type { DirectiveAttributes, DirectiveValue } from '../directive-syntax.ts'
+import type { Elsewhere } from './directive-attributes.ts'
 import { attributeValue, spellAttributeValue, unknownDirectiveFault } from '../directive-syntax.ts'
 import { blockArgument } from '../block-directive-arguments.ts'
 import { blockDirective } from '../../adf/block-directives.ts'
@@ -9,11 +9,10 @@ import { carryName } from '../opaque-carry.ts'
 import { failure, faulted, success, type ConvertErrorPath, type Result } from '../../result.ts'
 import { inlineDirective } from '../../adf/inline-directives.ts'
 import { marksAttribute, readMarkValues } from '../block-directive-marks.ts'
+import { readVocabulary } from './directive-attributes.ts'
 
 export type BlockDirectiveNode = { contentModel: BlockDirective['contentModel']; node: AdfNode }
 
-type Elsewhere = { key: string; slot: 'argument' | 'content' }
-
 export function readBlockDirectiveNode(
   name: string,
   argument: string | undefined,
@@ -70,30 +69,6 @@ function slotText(content: readonly AdfNode[]): string | undefined {
   return only.text
 }
 
-export function readVocabulary(
-  type: string,
-  attributes: DirectiveAttributes,
-  vocabulary: AttributeVocabulary,
-  elsewhere: Elsewhere | undefined,
-  path: ConvertErrorPath,
-): Result<AdfAttributes> {
-  const attrs: AdfAttributes = {}
-  for (const [key, spelled] of attributes) {
-    if (key === elsewhere?.key) {
-      const place = elsewhere.slot === 'argument' ? 'as the directive argument' : 'in the content slot'
-      return failure('unsupported-node-shape', `${type} spells its ${key} attribute ${place}`, path)
-    }
-    const kind = Object.hasOwn(vocabulary, key) ? vocabulary[key] : undefined
-    if (kind === undefined) return failure('unsupported-node-shape', `${type} holds no ${key} attribute`, path)
-    const read = attributeValue(spelled.decoded, kind)
-    if (read === undefined) return failure('unsupported-node-shape', `the ${key} attribute of ${type} is no ${kind}`, path)
-    const spelling = spellAttributeValue(read)
-    if (spelling !== spelled.spelling) return failure('unsupported-node-shape', `${type} spells its ${key} attribute as ${key}=${spelling}`, path)
-    attrs[key] = read.value
-  }
-  return success(attrs)
-}
-
 function readMarks(type: string, spelled: DirectiveValue, path: ConvertErrorPath): Result<AdfMark[]> {
   const read = attributeValue(spelled.decoded, 'json')
   const marks = read === undefined || spellAttributeValue(read) !== spelled.spelling ? undefined : readMarkValues(read.value)

src/markdown/parse/markdown-to-adf.test.ts

@@ -697,6 +697,9 @@ test('names the content slot no one unmarked text node reads back from', () => {
   assert.equal(code(markdownToAdf(':status[:date{timestamp=1}]{color=yellow}\n')), 'unsupported-node-shape')
   assert.equal(content(markdownToAdf(':status[![a](/u)]{color=yellow}\n')), 'unmappable-image: an image fits only as a paragraph of its own')
   assert.equal(code(markdownToAdf(':status[<div>]{color=yellow}\n')), 'unmappable-html')
+  // The slot parses before the name's table is consulted, so a doubly-broken span reports its inner error.
+  assert.equal(code(markdownToAdf(':date[<div>]{timestamp=1}\n')), 'unmappable-html')
+  assert.equal(code(markdownToAdf(':widget[<div>]\n')), 'unmappable-html')
   assert.equal(content(markdownToAdf('Part :mention{id=b1c2 text=A}.\n')), 'unsupported-node-shape: mention spells its text attribute in the content slot')
 })
 

src/markdown/text-directive.ts

@@ -1,12 +1,12 @@
 import type { ConvertFault } from '../result.ts'
 import type { DirectiveSpan, Read } from './directive-syntax.ts'
-import { spellAttributes, spellStringAttribute } from './directive-syntax.ts'
+import { spellAttributes, spellLeafDirective, spellStringAttribute } from './directive-syntax.ts'
 
 const name = 'text'
 const whitespaceRun = /^(?:[ \t]+|\n+)$/
 
 export function spellTextDirective(text: string): string {
-  return `:${name}${spellAttributes([[name, spellStringAttribute(text)]])}`
+  return spellLeafDirective(name, spellAttributes([[name, spellStringAttribute(text)]]))
 }
 
 export function readTextDirective(span: DirectiveSpan): Read<string> | undefined {