mdld-parse 0.2.3 → 0.2.4

package/README.md

@@ -149,12 +149,12 @@ ex:apollo11 schema:organizer ex:nasa .
 
 ### Resource Declaration
 
-Declare resources inline with `(=iri)`:
+Declare resources inline with `{=iri}`:
 
 ```markdown
 # Mission {=ex:apollo11}
 
-[Neil Armstrong](=ex:armstrong) {?commander .Person}
+[Neil Armstrong] {=ex:armstrong ?commander .Person}
 ```
 
 ```turtle
@@ -171,8 +171,8 @@ Lists require explicit subjects per item:
 
 Ingredients: {?ingredient .Ingredient}
 
-- [Flour](=ex:flour) {name}
-- [Water](=ex:water) {name}
+- Flour {=ex:flour name}
+- Water {=ex:water name}
 ```
 
 ```turtle
@@ -219,7 +219,7 @@ Reverse the relationship direction:
 
 Part of: {^?hasPart}
 
-- [Book](=ex:book) {}
+- Book {=ex:book}
 ```
 
 ```turtle
@@ -331,21 +331,17 @@ console.log(updated.text);
 Only specific markdown elements can carry semantic values:
 
 **Inline:**
-- `[text]` — span with annotation
-- `[text](url)` — link to external resource
-- `[text](=iri)` — inline resource declaration
+- `[text] {...}` — span with annotation
+- `[text](url) {...}` — link to external resource
+- `[text] {...}` — inline resource declaration
+- `![alt text](image.png) {...}` — embedding with annotation
 
 **Block:**
 - Headings (`# Title`)
-- List items (`- item`)
+- List items (`- item`, `1. item`) (single-level)
 - Blockquotes (`> quote`)
 - Code blocks (` ```lang `)
 
-**Non-carriers:**
-- Plain paragraphs without `[...]`
-- Images (future)
-- Tables (future)
-
 ## Architecture
 
 ### Design Principles
@@ -383,12 +379,12 @@ MD-LD explicitly forbids to ensure deterministic parsing:
 
 Attendees: {?attendee}
 
-- [Alice](=urn:person:alice) {name}
-- [Bob](=urn:person:bob) {name}
+- Alice {=urn:person:alice name}
+- Bob {=urn:person:bob name}
 
 Action items: {?actionItem}
 
-- [Review proposal](=urn:task:1) {name}
+- Review proposal {=urn:task:1 name}
 ```
 
 ### Developer Documentation
@@ -401,7 +397,7 @@ Action items: {?actionItem}
 
 Example:
 
-```bash {=api:/users/:id/example .CodeExample programmingLanguage}
+```bash {=api:/users/:id#example .CodeExample text}
 curl https://api.example.com/users/123
 ```
 ````
@@ -412,7 +408,7 @@ curl https://api.example.com/users/123
 # Paper {=doi:10.1234/example .ScholarlyArticle}
 
 [Semantic Web] {about}
-[Alice Johnson](=orcid:0000-0001-2345-6789) {?author .Person}
+[Alice Johnson] {=orcid:0000-0001-2345-6789 author}
 [2024-01] {datePublished ^^xsd:gYearMonth}
 
 > This paper explores semantic markup in Markdown. {abstract @en}

package/index.js

@@ -25,8 +25,9 @@ function hash(str) {
 }
 
 function expandIRI(term, ctx) {
-    if (!term) return null;
-    const t = term.trim();
+    if (term == null) return null;
+    const raw = typeof term === 'string' ? term : (typeof term === 'object' && typeof term.value === 'string') ? term.value : String(term);
+    const t = raw.trim();
     if (t.match(/^https?:/)) return t;
     if (t.includes(':')) {
         const [prefix, ref] = t.split(':', 2);
@@ -37,38 +38,83 @@ function expandIRI(term, ctx) {
 
 function parseSemanticBlock(raw) {
     try {
-        const cleaned = raw.replace(/^\{|\}$/g, '').trim();
-        if (!cleaned) return { subject: null, types: [], predicates: [], datatype: null, language: null };
+        const src = String(raw || '').trim();
+        const cleaned = src.replace(/^\{|\}$/g, '').trim();
+        if (!cleaned) return { subject: null, types: [], predicates: [], datatype: null, language: null, entries: [] };
+
+        const result = { subject: null, types: [], predicates: [], datatype: null, language: null, entries: [] };
+        const re = /\S+/g;
+        let m;
+        while ((m = re.exec(cleaned)) !== null) {
+            const token = m[0];
+            const relStart = 1 + m.index;
+            const relEnd = relStart + token.length;
+            const entryIndex = result.entries.length;
 
-        const result = { subject: null, types: [], predicates: [], datatype: null, language: null };
-        const tokens = cleaned.split(/\s+/).filter(t => t);
-
-        for (const token of tokens) {
             if (token === '=') {
                 result.subject = 'RESET';
-            } else if (token.startsWith('=')) {
-                result.subject = token.substring(1);
-            } else if (token.startsWith('^^')) {
-                result.datatype = token.substring(2);
-            } else if (token.startsWith('@')) {
-                result.language = token.substring(1);
-            } else if (token.startsWith('.')) {
-                result.types.push(token.substring(1));
-            } else if (token.startsWith('^?')) {
-                result.predicates.push({ iri: token.substring(2), form: '^?' });
-            } else if (token.startsWith('^')) {
-                result.predicates.push({ iri: token.substring(1), form: '^' });
-            } else if (token.startsWith('?')) {
-                result.predicates.push({ iri: token.substring(1), form: '?' });
-            } else {
-                result.predicates.push({ iri: token, form: '' });
+                result.entries.push({ kind: 'subjectReset', relRange: { start: relStart, end: relEnd }, raw: token });
+                continue;
+            }
+
+            if (token.startsWith('=')) {
+                const iri = token.substring(1);
+                result.subject = iri;
+                result.entries.push({ kind: 'subject', iri, relRange: { start: relStart, end: relEnd }, raw: token });
+                continue;
+            }
+
+            if (token.startsWith('^^')) {
+                const datatype = token.substring(2);
+                if (!result.language) result.datatype = datatype;
+                result.entries.push({ kind: 'datatype', datatype, relRange: { start: relStart, end: relEnd }, raw: token });
+                continue;
+            }
+
+            if (token.startsWith('@')) {
+                const language = token.substring(1);
+                result.language = language;
+                result.datatype = null;
+                result.entries.push({ kind: 'language', language, relRange: { start: relStart, end: relEnd }, raw: token });
+                continue;
+            }
+
+            if (token.startsWith('.')) {
+                const classIRI = token.substring(1);
+                result.types.push({ iri: classIRI, entryIndex });
+                result.entries.push({ kind: 'type', iri: classIRI, relRange: { start: relStart, end: relEnd }, raw: token });
+                continue;
+            }
+
+            if (token.startsWith('^?')) {
+                const iri = token.substring(2);
+                result.predicates.push({ iri, form: '^?', entryIndex });
+                result.entries.push({ kind: 'property', iri, form: '^?', relRange: { start: relStart, end: relEnd }, raw: token });
+                continue;
             }
+
+            if (token.startsWith('^')) {
+                const iri = token.substring(1);
+                result.predicates.push({ iri, form: '^', entryIndex });
+                result.entries.push({ kind: 'property', iri, form: '^', relRange: { start: relStart, end: relEnd }, raw: token });
+                continue;
+            }
+
+            if (token.startsWith('?')) {
+                const iri = token.substring(1);
+                result.predicates.push({ iri, form: '?', entryIndex });
+                result.entries.push({ kind: 'property', iri, form: '?', relRange: { start: relStart, end: relEnd }, raw: token });
+                continue;
+            }
+
+            result.predicates.push({ iri: token, form: '', entryIndex });
+            result.entries.push({ kind: 'property', iri: token, form: '', relRange: { start: relStart, end: relEnd }, raw: token });
         }
 
         return result;
     } catch (error) {
         console.error(`Error parsing semantic block ${raw}:`, error);
-        return { subject: null, types: [], predicates: [], datatype: null, language: null };
+        return { subject: null, types: [], predicates: [], datatype: null, language: null, entries: [] };
     }
 }
 
@@ -86,20 +132,29 @@ function scanTokens(text) {
         if (line.startsWith('```')) {
             if (!codeBlock) {
                 const fence = line.match(/^(`{3,})(.*)/);
+                const attrsText = fence[2].match(/\{[^}]+\}/)?.[0] || null;
+                const attrsStartInLine = attrsText ? line.indexOf(attrsText) : -1;
+                const contentStart = lineStart + line.length + 1;
                 codeBlock = {
                     fence: fence[1],
                     start: lineStart,
                     content: [],
                     lang: fence[2].trim().split(/[\s{]/)[0],
-                    attrs: fence[2].match(/\{[^}]+\}/)?.[0]
+                    attrs: attrsText,
+                    attrsRange: attrsText && attrsStartInLine >= 0 ? [lineStart + attrsStartInLine, lineStart + attrsStartInLine + attrsText.length] : null,
+                    valueRangeStart: contentStart
                 };
             } else if (line.startsWith(codeBlock.fence)) {
+                const valueStart = codeBlock.valueRangeStart;
+                const valueEnd = Math.max(valueStart, lineStart - 1);
                 tokens.push({
                     type: 'code',
                     range: [codeBlock.start, lineStart],
                     text: codeBlock.content.join('\n'),
                     lang: codeBlock.lang,
-                    attrs: codeBlock.attrs
+                    attrs: codeBlock.attrs,
+                    attrsRange: codeBlock.attrsRange,
+                    valueRange: [valueStart, valueEnd]
                 });
                 codeBlock = null;
             }
@@ -119,35 +174,58 @@ function scanTokens(text) {
 
         const headingMatch = line.match(/^(#{1,6})\s+(.+?)(?:\s*(\{[^}]+\}))?$/);
         if (headingMatch) {
+            const attrs = headingMatch[3] || null;
+            const attrsStartInLine = attrs ? line.lastIndexOf(attrs) : -1;
+            const afterHashes = headingMatch[1].length;
+            const ws = line.substring(afterHashes).match(/^\s+/)?.[0]?.length || 0;
+            const valueStartInLine = afterHashes + ws;
+            const valueEndInLine = valueStartInLine + headingMatch[2].length;
             tokens.push({
                 type: 'heading',
                 depth: headingMatch[1].length,
                 range: [lineStart, pos - 1],
                 text: headingMatch[2].trim(),
-                attrs: headingMatch[3]
+                attrs,
+                attrsRange: attrs && attrsStartInLine >= 0 ? [lineStart + attrsStartInLine, lineStart + attrsStartInLine + attrs.length] : null,
+                valueRange: [lineStart + valueStartInLine, lineStart + valueEndInLine]
             });
             continue;
         }
 
         const listMatch = line.match(/^(\s*)([-*+]|\d+\.)\s+(.+?)(?:\s*(\{[^}]+\}))?$/);
         if (listMatch) {
+            const attrs = listMatch[4] || null;
+            const attrsStartInLine = attrs ? line.lastIndexOf(attrs) : -1;
+            const prefix = listMatch[1].length + listMatch[2].length;
+            const ws = line.substring(prefix).match(/^\s+/)?.[0]?.length || 0;
+            const valueStartInLine = prefix + ws;
+            const valueEndInLine = valueStartInLine + listMatch[3].length;
             tokens.push({
                 type: 'list',
                 indent: listMatch[1].length,
                 range: [lineStart, pos - 1],
                 text: listMatch[3].trim(),
-                attrs: listMatch[4]
+                attrs,
+                attrsRange: attrs && attrsStartInLine >= 0 ? [lineStart + attrsStartInLine, lineStart + attrsStartInLine + attrs.length] : null,
+                valueRange: [lineStart + valueStartInLine, lineStart + valueEndInLine]
             });
             continue;
         }
 
         const blockquoteMatch = line.match(/^>\s+(.+?)(?:\s*(\{[^}]+\}))?$/);
         if (blockquoteMatch) {
+            const attrs = blockquoteMatch[2] || null;
+            const attrsStartInLine = attrs ? line.lastIndexOf(attrs) : -1;
+            const prefixMatch = line.match(/^>\s+/);
+            const valueStartInLine = prefixMatch ? prefixMatch[0].length : 2;
+            const valueEndInLine = valueStartInLine + blockquoteMatch[1].length;
             tokens.push({
                 type: 'blockquote',
                 range: [lineStart, pos - 1],
                 text: blockquoteMatch[1].trim(),
-                attrs: blockquoteMatch[2]
+                attrs,
+                attrsRange: attrs && attrsStartInLine >= 0 ? [lineStart + attrsStartInLine, lineStart + attrsStartInLine + attrs.length] : null,
+                valueRange: [lineStart + valueStartInLine, lineStart + valueEndInLine]
             });
             continue;
         }
@@ -165,7 +243,6 @@ function scanTokens(text) {
     return tokens;
 }
 
-// Extract inline carriers: [text] {attrs}, [text](url) {attrs}, [text](=iri) {attrs}
 function extractInlineCarriers(text, baseOffset = 0) {
     const carriers = [];
     let pos = 0;
@@ -174,14 +251,25 @@ function extractInlineCarriers(text, baseOffset = 0) {
         const bracketStart = text.indexOf('[', pos);
         if (bracketStart === -1) break;
 
-        const bracketEnd = text.indexOf(']', bracketStart);
-        if (bracketEnd === -1) break;
+        let bracketDepth = 1;
+        let bracketEnd = bracketStart + 1;
+
+        while (bracketEnd < text.length && bracketDepth > 0) {
+            if (text[bracketEnd] === '[') {
+                bracketDepth++;
+            } else if (text[bracketEnd] === ']') {
+                bracketDepth--;
+            }
+            bracketEnd++;
+        }
+
+        if (bracketDepth > 0) break;
 
-        const carrierText = text.substring(bracketStart + 1, bracketEnd);
-        let spanEnd = bracketEnd + 1;
+        const carrierText = text.substring(bracketStart + 1, bracketEnd - 1);
+        const valueRange = [baseOffset + bracketStart + 1, baseOffset + bracketEnd - 1];
+        let spanEnd = bracketEnd;
         let url = null;
 
-        // Check for (url) or (=iri)
         if (text[spanEnd] === '(') {
             const parenEnd = text.indexOf(')', spanEnd);
             if (parenEnd !== -1) {
@@ -190,22 +278,24 @@ function extractInlineCarriers(text, baseOffset = 0) {
             }
         }
 
-        // Check for {attrs}
         let attrs = null;
+        let attrsRange = null;
         const attrsMatch = text.substring(spanEnd).match(/^\s*\{([^}]+)\}/);
         if (attrsMatch) {
             attrs = `{${attrsMatch[1]}}`;
+            const braceIndex = attrsMatch[0].indexOf('{');
+            const absStart = baseOffset + spanEnd + (braceIndex >= 0 ? braceIndex : 0);
+            attrsRange = [absStart, absStart + attrs.length];
             spanEnd += attrsMatch[0].length;
         }
 
-        // Determine type and resource
         let carrierType = 'span';
         let resourceIRI = null;
 
         if (url) {
             if (url.startsWith('=')) {
-                carrierType = 'resource';
-                resourceIRI = url.substring(1);
+                pos = spanEnd;
+                continue;
             } else {
                 carrierType = 'link';
                 resourceIRI = url;
@@ -217,6 +307,8 @@ function extractInlineCarriers(text, baseOffset = 0) {
             text: carrierText,
             url: resourceIRI,
             attrs: attrs,
+            attrsRange,
+            valueRange,
             range: [baseOffset + bracketStart, baseOffset + spanEnd]
         });
 
@@ -226,191 +318,150 @@ function extractInlineCarriers(text, baseOffset = 0) {
     return carriers;
 }
 
-function createBlock(subject, types, predicates, range, ctx) {
+function createBlock(subject, types, predicates, entries, range, attrsRange, valueRange, carrierType, ctx) {
     const expanded = {
-        subject: subject,
-        types: types.map(t => expandIRI(t, ctx)),
-        predicates: predicates.map(p => ({
-            iri: expandIRI(p.iri, ctx),
-            form: p.form
-        }))
+        subject,
+        types: types.map(t => expandIRI(typeof t === 'string' ? t : t.iri, ctx)),
+        predicates: predicates.map(p => ({ iri: expandIRI(p.iri, ctx), form: p.form }))
     };
-
     const blockId = hash([subject, JSON.stringify(expanded)].join('|'));
     return {
         id: blockId,
         range: { start: range[0], end: range[1] },
+        attrsRange: attrsRange ? { start: attrsRange[0], end: attrsRange[1] } : null,
+        valueRange: valueRange ? { start: valueRange[0], end: valueRange[1] } : null,
+        carrierType: carrierType || null,
         subject,
         types: expanded.types,
         predicates: expanded.predicates,
+        entries: entries || [],
         context: { ...ctx }
     };
 }
 
-function emitQuad(quads, quadIndex, blockId, subject, predicate, object, dataFactory) {
+function quadIndexKey(subject, predicate, object) {
+    const objKey = object.termType === 'Literal'
+        ? JSON.stringify({ t: 'Literal', v: object.value, lang: object.language || '', dt: object.datatype?.value || '' })
+        : JSON.stringify({ t: object.termType, v: object.value });
+    return JSON.stringify([subject.value, predicate.value, objKey]);
+}
+
+function emitQuad(quads, quadIndex, blockId, subject, predicate, object, dataFactory, meta = null) {
     if (!subject || !predicate || !object) return;
     const quad = dataFactory.quad(subject, predicate, object);
     quads.push(quad);
-    const key = JSON.stringify([
-        quad.subject.value,
-        quad.predicate.value,
-        quad.object.termType === 'Literal' ? quad.object.value : quad.object.value
-    ]);
-    quadIndex.set(key, blockId);
+    quadIndex.set(quadIndexKey(quad.subject, quad.predicate, quad.object), meta ? { blockId, ...meta } : { blockId });
 }
 
 function createLiteral(value, datatype, language, context, dataFactory) {
-    if (datatype) {
-        return dataFactory.literal(value, dataFactory.namedNode(expandIRI(datatype, context)));
-    }
-    if (language) {
-        return dataFactory.literal(value, language);
-    }
+    if (datatype) return dataFactory.literal(value, dataFactory.namedNode(expandIRI(datatype, context)));
+    if (language) return dataFactory.literal(value, language);
     return dataFactory.literal(value);
 }
 
-// Core processing: handle subject/type declarations and property emissions
 function processAnnotation(carrier, sem, state) {
-    // §6.1 Subject declaration
     if (sem.subject === 'RESET') {
         state.currentSubject = null;
         return;
     }
 
-    if (sem.subject) {
-        state.currentSubject = state.df.namedNode(expandIRI(sem.subject, state.ctx));
-    }
+    const previousSubject = state.currentSubject;
+    let newSubject = sem.subject ? state.df.namedNode(expandIRI(sem.subject, state.ctx)) : null;
+    if (newSubject) state.currentSubject = newSubject;
 
-    // Determine the subject for emissions
     const S = state.currentSubject;
-    if (!S) return; // Need a subject to emit anything
-
-    // Create origin block
-    const block = createBlock(
-        S.value,
-        sem.types,
-        sem.predicates,
-        carrier.range,
-        state.ctx
-    );
+    if (!S) return;
+
+    const block = createBlock(S.value, sem.types, sem.predicates, sem.entries, carrier.range, carrier.attrsRange || null, carrier.valueRange || null, carrier.type || null, state.ctx);
     state.origin.blocks.set(block.id, block);
 
-    // Extract L (literal) and O (object IRI)
     const L = createLiteral(carrier.text, sem.datatype, sem.language, state.ctx, state.df);
     const O = carrier.url ? state.df.namedNode(expandIRI(carrier.url, state.ctx)) : null;
 
-    // §7 Emit type triples
-    sem.types.forEach(typeIRI => {
+    sem.types.forEach(t => {
+        const typeIRI = typeof t === 'string' ? t : t.iri;
+        const entryIndex = typeof t === 'string' ? null : t.entryIndex;
         const typeSubject = O || S;
-        emitQuad(
-            state.quads,
-            state.origin.quadIndex,
-            block.id,
-            typeSubject,
-            state.df.namedNode(expandIRI('rdf:type', state.ctx)),
-            state.df.namedNode(expandIRI(typeIRI, state.ctx)),
-            state.df
-        );
+        const expandedType = expandIRI(typeIRI, state.ctx);
+        emitQuad(state.quads, state.origin.quadIndex, block.id, typeSubject, state.df.namedNode(expandIRI('rdf:type', state.ctx)), state.df.namedNode(expandedType), state.df, { kind: 'type', token: `.${typeIRI}`, expandedType, entryIndex });
     });
 
-    // §8 Emit predicate triples (routing table)
     sem.predicates.forEach(pred => {
         const P = state.df.namedNode(expandIRI(pred.iri, state.ctx));
+        const token = `${pred.form}${pred.iri}`;
 
         if (pred.form === '') {
-            // p: S → L
-            emitQuad(state.quads, state.origin.quadIndex, block.id, S, P, L, state.df);
+            emitQuad(state.quads, state.origin.quadIndex, block.id, S, P, L, state.df, { kind: 'pred', token, form: pred.form, expandedPredicate: P.value, entryIndex: pred.entryIndex });
         } else if (pred.form === '?') {
-            // ?p: S → O
-            if (O) {
-                emitQuad(state.quads, state.origin.quadIndex, block.id, S, P, O, state.df);
+            if (newSubject) {
+                emitQuad(state.quads, state.origin.quadIndex, block.id, previousSubject, P, newSubject, state.df, { kind: 'pred', token, form: pred.form, expandedPredicate: P.value, entryIndex: pred.entryIndex });
+            } else if (O) {
+                emitQuad(state.quads, state.origin.quadIndex, block.id, S, P, O, state.df, { kind: 'pred', token, form: pred.form, expandedPredicate: P.value, entryIndex: pred.entryIndex });
             }
-        } else if (pred.form === '^') {
-            // ^p: reverse literal (L → S impossible, emit nothing per spec)
-            // Note: Some interpretations might emit S → S or skip
         } else if (pred.form === '^?') {
-            // ^?p: O → S
-            if (O) {
-                emitQuad(state.quads, state.origin.quadIndex, block.id, O, P, S, state.df);
+            if (newSubject) {
+                emitQuad(state.quads, state.origin.quadIndex, block.id, newSubject, P, previousSubject, state.df, { kind: 'pred', token, form: pred.form, expandedPredicate: P.value, entryIndex: pred.entryIndex });
+            } else if (O) {
+                emitQuad(state.quads, state.origin.quadIndex, block.id, O, P, S, state.df, { kind: 'pred', token, form: pred.form, expandedPredicate: P.value, entryIndex: pred.entryIndex });
             }
         }
     });
 }
 
-// Process list with context annotation
-function processListContext(contextSem, listTokens, state) {
-    const contextSubject = state.currentSubject;
-    if (!contextSubject) return;
+function processListContext(contextSem, listTokens, state, contextSubject = null) {
+    if (!contextSubject) contextSubject = state.currentSubject;
 
     listTokens.forEach(listToken => {
-        // Extract carriers from list item text
         const carriers = extractInlineCarriers(listToken.text, listToken.range[0]);
-
-        // Find subject from carriers or list item annotation
         let itemSubject = null;
         let itemSubjectCarrier = null;
 
-        // First check carriers for subject declarations
-        for (const carrier of carriers) {
-            if (carrier.url && carrier.type === 'resource') {
-                // [text](=iri) declares a subject
-                itemSubject = state.df.namedNode(expandIRI(carrier.url, state.ctx));
-                itemSubjectCarrier = carrier;
-                break;
+        if (listToken.attrs) {
+            const itemSem = parseSemanticBlock(listToken.attrs);
+            if (itemSem.subject && itemSem.subject !== 'RESET') {
+                itemSubject = state.df.namedNode(expandIRI(itemSem.subject, state.ctx));
+                itemSubjectCarrier = { type: 'list', text: listToken.text, attrs: listToken.attrs, range: listToken.range };
             }
-            if (carrier.attrs) {
-                const itemSem = parseSemanticBlock(carrier.attrs);
-                if (itemSem.subject && itemSem.subject !== 'RESET') {
-                    itemSubject = state.df.namedNode(expandIRI(itemSem.subject, state.ctx));
-                    itemSubjectCarrier = carrier;
-                    break;
+        }
+
+        if (!itemSubject) {
+            for (const carrier of carriers) {
+                if (carrier.attrs) {
+                    const itemSem = parseSemanticBlock(carrier.attrs);
+                    if (itemSem.subject && itemSem.subject !== 'RESET') {
+                        itemSubject = state.df.namedNode(expandIRI(itemSem.subject, state.ctx));
+                        itemSubjectCarrier = carrier;
+                        break;
+                    }
                 }
             }
         }
 
-        if (!itemSubject) return; // List items must declare subjects
-
-        // Apply context types to item
-        contextSem.types.forEach(typeIRI => {
-            emitQuad(
-                state.quads,
-                state.origin.quadIndex,
-                'list-context',
-                itemSubject,
-                state.df.namedNode(expandIRI('rdf:type', state.ctx)),
-                state.df.namedNode(expandIRI(typeIRI, state.ctx)),
-                state.df
-            );
+        if (!itemSubject) return;
+
+        contextSem.types.forEach(t => {
+            const typeIRI = typeof t === 'string' ? t : t.iri;
+            emitQuad(state.quads, state.origin.quadIndex, 'list-context', itemSubject, state.df.namedNode(expandIRI('rdf:type', state.ctx)), state.df.namedNode(expandIRI(typeIRI, state.ctx)), state.df);
         });
 
-        // Emit context relationships
         contextSem.predicates.forEach(pred => {
             const P = state.df.namedNode(expandIRI(pred.iri, state.ctx));
-
             if (pred.form === '^' || pred.form === '^?') {
-                // Reverse: item → context
-                emitQuad(state.quads, state.origin.quadIndex, 'list-context',
-                    itemSubject, P, contextSubject, state.df);
+                emitQuad(state.quads, state.origin.quadIndex, 'list-context', itemSubject, P, contextSubject, state.df);
             } else {
-                // Forward: context → item
-                emitQuad(state.quads, state.origin.quadIndex, 'list-context',
-                    contextSubject, P, itemSubject, state.df);
+                emitQuad(state.quads, state.origin.quadIndex, 'list-context', contextSubject, P, itemSubject, state.df);
             }
         });
 
-        // Process item's own annotations
         const prevSubject = state.currentSubject;
         state.currentSubject = itemSubject;
 
-        // Process the list token's own attributes
         if (listToken.attrs) {
             const itemSem = parseSemanticBlock(listToken.attrs);
-            // For list item attributes, the literal is the text content without links
-            const carrier = { type: 'list', text: listToken.text.replace(/\[([^\]]+)\]\([^)]+\)/, '$1'), range: listToken.range };
+            const carrier = { type: 'list', text: listToken.text, range: listToken.range, attrsRange: listToken.attrsRange || null, valueRange: listToken.valueRange || null };
             processAnnotation(carrier, itemSem, state);
         }
 
-        // Process inline carriers' attributes
         carriers.forEach(carrier => {
             if (carrier.attrs) {
                 const itemSem = parseSemanticBlock(carrier.attrs);
@@ -432,8 +483,6 @@ export function parse(text, options = {}) {
     };
 
     const tokens = scanTokens(text);
-
-    // Apply prefix declarations
     tokens.filter(t => t.type === 'prefix').forEach(t => state.ctx[t.prefix] = t.iri);
 
     for (let i = 0; i < tokens.length; i++) {
@@ -441,18 +490,26 @@ export function parse(text, options = {}) {
 
         if (token.type === 'heading' && token.attrs) {
             const sem = parseSemanticBlock(token.attrs);
-            const carrier = { type: 'heading', text: token.text, range: token.range };
+            const carrier = { type: 'heading', text: token.text, range: token.range, attrsRange: token.attrsRange || null, valueRange: token.valueRange || null };
             processAnnotation(carrier, sem, state);
         } else if (token.type === 'code' && token.attrs) {
             const sem = parseSemanticBlock(token.attrs);
-            const carrier = { type: 'code', text: token.text, range: token.range };
+            const carrier = { type: 'code', text: token.text, range: token.range, attrsRange: token.attrsRange || null, valueRange: token.valueRange || null };
             processAnnotation(carrier, sem, state);
         } else if (token.type === 'blockquote' && token.attrs) {
             const sem = parseSemanticBlock(token.attrs);
-            const carrier = { type: 'blockquote', text: token.text, range: token.range };
+            const carrier = { type: 'blockquote', text: token.text, range: token.range, attrsRange: token.attrsRange || null, valueRange: token.valueRange || null };
             processAnnotation(carrier, sem, state);
         } else if (token.type === 'para') {
-            // Check for list context
+            // Check for standalone subject declarations: {=iri} on its own line
+            const standaloneSubjectMatch = token.text.match(/^\s*\{=(.*?)\}\s*$/);
+            if (standaloneSubjectMatch) {
+                const sem = parseSemanticBlock(`{=${standaloneSubjectMatch[1]}}`);
+                const attrsStart = token.range[0] + token.text.indexOf('{=');
+                const attrsEnd = attrsStart + (standaloneSubjectMatch[1] ? standaloneSubjectMatch[1].length : 0);
+                processAnnotation({ type: 'standalone', text: '', range: token.range, attrsRange: [attrsStart, attrsEnd], valueRange: null }, sem, state);
+            }
+
             const followingLists = [];
             let j = i + 1;
             while (j < tokens.length && tokens[j].type === 'list') {
@@ -460,17 +517,28 @@ export function parse(text, options = {}) {
                 j++;
             }
 
-            // Check if this paragraph ends with {attrs} and is followed by lists
             const contextMatch = token.text.match(/^(.+?)\s*\{([^}]+)\}$/);
             if (contextMatch && followingLists.length > 0) {
-                // This is a list context annotation
                 const contextSem = parseSemanticBlock(`{${contextMatch[2]}}`);
-                processListContext(contextSem, followingLists, state);
+                let contextSubject = state.currentSubject;
+
+                // Always look for the most recent heading subject for context
+                for (let k = i - 1; k >= 0; k--) {
+                    const prevToken = tokens[k];
+                    if (prevToken.type === 'heading' && prevToken.attrs) {
+                        const headingSem = parseSemanticBlock(prevToken.attrs);
+                        if (headingSem.subject) {
+                            contextSubject = state.df.namedNode(expandIRI(headingSem.subject, state.ctx));
+                            break;
+                        }
+                    }
+                }
+
+                processListContext(contextSem, followingLists, state, contextSubject);
                 i = j - 1;
                 continue;
             }
 
-            // Process inline carriers
             const carriers = extractInlineCarriers(token.text, token.range[0]);
             carriers.forEach(carrier => {
                 if (carrier.attrs) {
@@ -484,76 +552,429 @@ export function parse(text, options = {}) {
     return { quads: state.quads, origin: state.origin, context: state.ctx };
 }
 
-function shortenIRI(iri, ctx) {
+export function shortenIRI(iri, ctx) {
     if (!iri || !iri.startsWith('http')) return iri;
-
-    if (ctx['@vocab'] && iri.startsWith(ctx['@vocab'])) {
-        return iri.substring(ctx['@vocab'].length);
-    }
-
+    if (ctx['@vocab'] && iri.startsWith(ctx['@vocab'])) return iri.substring(ctx['@vocab'].length);
     for (const [prefix, namespace] of Object.entries(ctx)) {
         if (prefix !== '@vocab' && iri.startsWith(namespace)) {
             return prefix + ':' + iri.substring(namespace.length);
         }
     }
-
     return iri;
 }
 
+const serializeHelpers = {
+    readAttrsSpan: (block, text) => {
+        if (!block?.attrsRange) return null;
+        const { start, end } = block.attrsRange;
+        return (Number.isFinite(start) && Number.isFinite(end) && start >= 0 && end > start)
+            ? { start, end, text: text.substring(start, end) }
+            : null;
+    },
+
+    readValueSpan: (block, text) => {
+        if (!block?.valueRange) return null;
+        const { start, end } = block.valueRange;
+        return (Number.isFinite(start) && Number.isFinite(end) && start >= 0 && end >= start)
+            ? { start, end, text: text.substring(start, end) }
+            : null;
+    },
+
+    normalizeAttrsTokens: (attrsText) => {
+        const cleaned = String(attrsText || '').replace(/^\s*\{|\}\s*$/g, '').trim();
+        return cleaned ? cleaned.split(/\s+/).filter(Boolean) : [];
+    },
+
+    blockTokensFromEntries: (block) => block?.entries?.length ? block.entries.map(e => e.raw).filter(Boolean) : null,
+
+    removeEntryAt: (block, entryIndex) => {
+        if (!block?.entries || entryIndex == null || entryIndex < 0 || entryIndex >= block.entries.length) return null;
+        return [...block.entries.slice(0, entryIndex), ...block.entries.slice(entryIndex + 1)];
+    },
+
+    replaceLangDatatypeEntries: (block, lit, ctx) => {
+        if (!block?.entries) return null;
+        const filtered = block.entries.filter(e => e.kind !== 'language' && e.kind !== 'datatype');
+        const extras = [];
+        if (lit?.language) extras.push({ kind: 'language', language: lit.language, raw: `@${lit.language}`, relRange: { start: 0, end: 0 } });
+        const dt = lit?.datatype?.value;
+        if (!lit?.language && dt && dt !== 'http://www.w3.org/2001/XMLSchema#string') {
+            extras.push({ kind: 'datatype', datatype: shortenIRI(dt, ctx), raw: `^^${shortenIRI(dt, ctx)}`, relRange: { start: 0, end: 0 } });
+        }
+        return [...filtered, ...extras];
+    },
+
+    writeAttrsTokens: (tokens) => `{${tokens.join(' ').trim()}}`,
+
+    removeOneToken: (tokens, matchFn) => {
+        const i = tokens.findIndex(matchFn);
+        return i === -1 ? { tokens, removed: false } : { tokens: [...tokens.slice(0, i), ...tokens.slice(i + 1)], removed: true };
+    },
+
+    normalizeQuad: (q) => {
+        if (!q) return null;
+        const { subject, predicate, object } = q;
+        if (object?.termType === 'Literal') {
+            const language = typeof object.language === 'string' ? object.language : '';
+            const datatype = object.datatype?.value || { termType: 'NamedNode', value: 'http://www.w3.org/2001/XMLSchema#string' };
+            return { ...q, subject, predicate, object: { ...object, language, datatype } };
+        }
+        return { ...q, subject, predicate, object };
+    },
+
+    quadToKeyForOrigin: (q) => {
+        const nq = serializeHelpers.normalizeQuad(q);
+        return nq ? quadIndexKey(nq.subject, nq.predicate, nq.object) : null;
+    },
+
+    parseQuadIndexKey: (key) => {
+        try {
+            const [s, p, objKey] = JSON.parse(key);
+            return { s, p, o: JSON.parse(objKey) };
+        } catch {
+            return null;
+        }
+    },
+
+    sanitizeCarrierValueForBlock: (block, raw) => {
+        const s = String(raw ?? '');
+        const t = block?.carrierType;
+        if (t === 'code') return s.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+        const oneLine = s.replace(/[\n\r]+/g, ' ').trim();
+        return (t === 'span' || t === 'link') ? oneLine.replace(/[\[\]]/g, ' ') : oneLine;
+    }
+};
+
 export function serialize({ text, diff, origin, options = {} }) {
-    if (!diff || (!diff.add?.length && !diff.delete?.length)) return { text, origin };
+    if (!diff || (!diff.add?.length && !diff.delete?.length)) {
+        const reparsed = parse(text, { context: options.context || {} });
+        return { text, origin: reparsed.origin };
+    }
 
+    const base = origin || parse(text, { context: options.context || {} }).origin;
     let result = text;
     const edits = [];
     const ctx = options.context || {};
 
-    if (diff.delete) {
-        diff.delete.forEach(quad => {
-            if (!quad || !quad.subject) return;
-            const key = JSON.stringify([
-                quad.subject.value,
-                quad.predicate.value,
-                quad.object.termType === 'Literal' ? quad.object.value : quad.object.value
-            ]);
-            const blockId = origin?.quadIndex.get(key);
-            if (!blockId) return;
+    const findOriginEntryForLiteralByValue = (subjectIri, predicateIri, literalValue) => {
+        for (const [k, entry] of base?.quadIndex || []) {
+            const parsed = serializeHelpers.parseQuadIndexKey(k);
+            if (!parsed) continue;
+            if (parsed.s !== subjectIri || parsed.p !== predicateIri) continue;
+            if (parsed.o?.t !== 'Literal') continue;
+            if (parsed.o?.v !== literalValue) continue;
+            return entry;
+        }
+        return null;
+    };
+
+    const findLiteralCarrierBlocksBySP = (subjectIri, predicateIri) => {
+        const out = [];
+        for (const [k, entry] of base?.quadIndex || []) {
+            const parsed = serializeHelpers.parseQuadIndexKey(k);
+            if (!parsed) continue;
+            if (parsed.s !== subjectIri || parsed.p !== predicateIri) continue;
+            if (parsed.o?.t !== 'Literal') continue;
+            const blockId = entry?.blockId || entry;
+            const block = blockId ? base?.blocks?.get(blockId) : null;
+            if (block) out.push({ block, entry, obj: parsed.o });
+        }
+        return out;
+    };
+
+    const objectSignature = (o) => {
+        if (!o) return '';
+        if (o.termType === 'Literal') {
+            return JSON.stringify({ t: 'Literal', v: o.value, lang: o.language || '', dt: o.datatype?.value || '' });
+        }
+        return JSON.stringify({ t: o.termType, v: o.value });
+    };
+
+    const anchors = new Map();
+    for (const q0 of diff.delete || []) {
+        const q = serializeHelpers.normalizeQuad(q0);
+        if (!q) continue;
+        if (!q?.subject || !q?.object || !q?.predicate) continue;
+        const key = JSON.stringify([q.subject.value, objectSignature(q.object)]);
+        const qk = serializeHelpers.quadToKeyForOrigin(q);
+        const entry = qk ? base?.quadIndex?.get(qk) : null;
+        const blockId = entry?.blockId || entry;
+        const block = blockId ? base?.blocks?.get(blockId) : null;
+        if (!block?.attrsRange) continue;
+        anchors.set(key, { block, entry });
+    }
+
+    const addBySP = new Map();
+    for (const q0 of diff.add || []) {
+        const q = serializeHelpers.normalizeQuad(q0);
+        if (!q) continue;
+        if (!q?.subject || !q?.predicate || !q?.object) continue;
+        const k = JSON.stringify([q.subject.value, q.predicate.value]);
+        const list = addBySP.get(k) || [];
+        list.push(q);
+        addBySP.set(k, list);
+    }
+
+    const consumedAdds = new Set();
+    const literalUpdates = [];
+    for (const dq0 of diff.delete || []) {
+        const dq = serializeHelpers.normalizeQuad(dq0);
+        if (!dq) continue;
+        if (!dq?.subject || !dq?.predicate || !dq?.object) continue;
+        if (dq.object.termType !== 'Literal') continue;
+        const k = JSON.stringify([dq.subject.value, dq.predicate.value]);
+        const candidates = addBySP.get(k) || [];
+        const aq = candidates.find(x => x?.object?.termType === 'Literal' && !consumedAdds.has(serializeHelpers.quadToKeyForOrigin(x)));
+        if (!aq) continue;
+
+        const dqk = serializeHelpers.quadToKeyForOrigin(dq);
+        let entry = dqk ? base?.quadIndex?.get(dqk) : null;
+        if (!entry && dq.object?.termType === 'Literal') {
+            entry = findOriginEntryForLiteralByValue(dq.subject.value, dq.predicate.value, dq.object.value);
+        }
+        const blockId = entry?.blockId || entry;
+        const block = blockId ? base?.blocks?.get(blockId) : null;
+        if (!block) continue;
+
+        literalUpdates.push({ deleteQuad: dq, addQuad: aq, entry, block });
+        consumedAdds.add(serializeHelpers.quadToKeyForOrigin(aq));
+    }
 
-            const block = origin.blocks.get(blockId);
-            if (!block) return;
+    for (const q0 of diff.add || []) {
+        const quad = serializeHelpers.normalizeQuad(q0);
+        if (!quad || quad.object?.termType !== 'Literal') continue;
+        if (consumedAdds.has(serializeHelpers.quadToKeyForOrigin(quad))) continue;
 
-            const start = block.range.start;
-            const end = block.range.end;
-            const before = text.substring(Math.max(0, start - 1), start);
-            const after = text.substring(end, Math.min(end + 1, text.length));
-            const deleteStart = before === '\n' ? start - 1 : start;
-            const deleteEnd = after === '\n' ? end + 1 : end;
+        const matches = findLiteralCarrierBlocksBySP(quad.subject.value, quad.predicate.value);
+        if (matches.length === 0) continue;
 
-            edits.push({ start: deleteStart, end: deleteEnd, text: '' });
+        const desiredLang = quad.object.language || '';
+        const sameLang = matches.filter(m => {
+            const entries = m.block?.entries || [];
+            const langEntry = entries.find(e => e.kind === 'language');
+            const lang = langEntry?.language || '';
+            return lang === desiredLang;
         });
+
+        if (sameLang.length !== 1) continue;
+        const target = sameLang[0].block;
+        const vSpan = serializeHelpers.readValueSpan(target, text);
+        if (!vSpan) continue;
+
+        const newValue = serializeHelpers.sanitizeCarrierValueForBlock(target, quad.object.value);
+        edits.push({ start: vSpan.start, end: vSpan.end, text: newValue });
+
+        const aSpan = serializeHelpers.readAttrsSpan(target, text);
+        if (aSpan && target?.entries?.length) {
+            const nextEntries = serializeHelpers.replaceLangDatatypeEntries(target, quad.object, ctx);
+            if (nextEntries) {
+                const nextTokens = nextEntries.map(e => e.raw).filter(Boolean);
+                edits.push({ start: aSpan.start, end: aSpan.end, text: serializeHelpers.writeAttrsTokens(nextTokens) });
+            }
+        }
+
+        consumedAdds.add(quad);
     }
 
-    if (diff.add) {
-        diff.add.forEach(quad => {
-            let insertPos = result.length;
+    for (const u of literalUpdates) {
+        const span = serializeHelpers.readValueSpan(u.block, text);
+        if (span) {
+            const newValue = serializeHelpers.sanitizeCarrierValueForBlock(u.block, u.addQuad.object.value);
+            edits.push({ start: span.start, end: span.end, text: newValue });
+        }
 
-            for (const [, block] of origin?.blocks || []) {
-                if (block.subject === quad.subject.value) {
-                    insertPos = block.range.end;
-                    break;
+        const aSpan = serializeHelpers.readAttrsSpan(u.block, text);
+        if (aSpan) {
+            if (u.block?.entries?.length) {
+                const nextEntries = serializeHelpers.replaceLangDatatypeEntries(u.block, u.addQuad.object, ctx);
+                if (nextEntries) {
+                    const nextTokens = nextEntries.map(e => e.raw).filter(Boolean);
+                    if (nextTokens.length === 0) {
+                        edits.push({ start: aSpan.start, end: aSpan.end, text: '{}' });
+                    } else {
+                        edits.push({ start: aSpan.start, end: aSpan.end, text: serializeHelpers.writeAttrsTokens(nextTokens) });
+                    }
+                }
+            } else {
+                const tokens = serializeHelpers.normalizeAttrsTokens(aSpan.text);
+                const updated = updateAttrsDatatypeLang(tokens, u.addQuad.object);
+                if (updated.join(' ') !== tokens.join(' ')) {
+                    if (updated.length === 0) {
+                        edits.push({ start: aSpan.start, end: aSpan.end, text: '{}' });
+                    } else {
+                        edits.push({ start: aSpan.start, end: aSpan.end, text: serializeHelpers.writeAttrsTokens(updated) });
+                    }
                 }
             }
+        }
+    }
+
+    const updateAttrsDatatypeLang = (tokens, newLit) => {
+        const predicatesAndTypes = tokens.filter(t => !t.startsWith('@') && !t.startsWith('^^'));
+        if (newLit?.language) return [...predicatesAndTypes, `@${newLit.language}`];
+        const dt = newLit?.datatype?.value;
+        if (dt && dt !== 'http://www.w3.org/2001/XMLSchema#string') {
+            return [...predicatesAndTypes, `^^${shortenIRI(dt, ctx)}`];
+        }
+        return predicatesAndTypes;
+    };
 
-            const pred = shortenIRI(quad.predicate.value, ctx);
-            let objText;
+    if (diff.delete) {
+        diff.delete.forEach(q0 => {
+            const quad = serializeHelpers.normalizeQuad(q0);
+            if (!quad) return;
+            if (!quad?.subject || !quad?.predicate || !quad?.object) return;
 
             if (quad.object.termType === 'Literal') {
-                objText = quad.object.value;
+                const isUpdated = literalUpdates.some(u =>
+                    u.deleteQuad.subject.value === quad.subject.value &&
+                    u.deleteQuad.predicate.value === quad.predicate.value &&
+                    u.deleteQuad.object.value === quad.object.value
+                );
+                if (isUpdated) return;
+            }
+
+            const key = serializeHelpers.quadToKeyForOrigin(quad);
+            let entry = key ? base?.quadIndex?.get(key) : null;
+            if (!entry && quad.object?.termType === 'Literal') {
+                entry = findOriginEntryForLiteralByValue(quad.subject.value, quad.predicate.value, quad.object.value);
+            }
+            const blockId = entry?.blockId || entry;
+            if (!blockId) return;
+            const block = base?.blocks?.get(blockId);
+            const span = serializeHelpers.readAttrsSpan(block, text);
+            if (!span) return;
+
+            if (entry?.entryIndex != null && block?.entries?.length) {
+                const nextEntries = serializeHelpers.removeEntryAt(block, entry.entryIndex);
+                if (!nextEntries) return;
+                const nextTokens = nextEntries.map(e => e.raw).filter(Boolean);
+                if (nextTokens.length === 0) {
+                    edits.push({ start: span.start, end: span.end, text: '{}' });
+                } else {
+                    edits.push({ start: span.start, end: span.end, text: serializeHelpers.writeAttrsTokens(nextTokens) });
+                }
+                return;
+            }
+
+            const tokens = serializeHelpers.normalizeAttrsTokens(span.text);
+            let updated = tokens;
+            let removed = false;
+
+            if (entry?.kind === 'type' && quad.predicate.value.endsWith('rdf-syntax-ns#type')) {
+                const expectedType = entry.expandedType || quad.object.value;
+                ({ tokens: updated, removed } = serializeHelpers.removeOneToken(tokens, t => {
+                    if (!t.startsWith('.')) return false;
+                    const raw = t.slice(1);
+                    return expandIRI(raw, ctx) === expectedType;
+                }));
             } else {
-                objText = shortenIRI(quad.object.value, ctx);
+                const expectedPred = entry?.expandedPredicate || quad.predicate.value;
+                const expectedForm = entry?.form;
+                ({ tokens: updated, removed } = serializeHelpers.removeOneToken(tokens, t => {
+                    const m = String(t).match(/^(\^\?|\^|\?|)(.+)$/);
+                    if (!m) return false;
+                    const form = m[1] || '';
+                    const raw = m[2];
+                    if (expectedForm != null && form !== expectedForm) return false;
+                    return expandIRI(raw, ctx) === expectedPred;
+                }));
+            }
+
+            if (!removed) return;
+
+            if (updated.length === 0) {
+                edits.push({ start: span.start, end: span.end, text: '{}' });
+                return;
+            }
+
+            const newAttrs = serializeHelpers.writeAttrsTokens(updated);
+            edits.push({ start: span.start, end: span.end, text: newAttrs });
+        });
+    }
+
+    if (diff.add) {
+        diff.add.forEach(q0 => {
+            const quad = serializeHelpers.normalizeQuad(q0);
+            if (!quad) return;
+            if (!quad?.subject || !quad?.predicate || !quad?.object) return;
+
+            if (consumedAdds.has(serializeHelpers.quadToKeyForOrigin(quad))) return;
+
+            const anchorKey = JSON.stringify([quad.subject.value, objectSignature(quad.object)]);
+            const anchored = anchors.get(anchorKey) || null;
+            let targetBlock = anchored?.block || null;
+
+            if (!targetBlock) {
+                for (const [, block] of base?.blocks || []) {
+                    if (block.subject === quad.subject.value && block.attrsRange) {
+                        targetBlock = block;
+                        break;
+                    }
+                }
+            }
+
+            if (quad.object.termType === 'Literal' || quad.object.termType === 'NamedNode') {
+                if (!targetBlock) {
+                    const predShort = shortenIRI(quad.predicate.value, ctx);
+                    if (quad.object.termType === 'Literal') {
+                        const value = String(quad.object.value ?? '');
+                        let ann = predShort;
+                        if (quad.object.language) ann += ` @${quad.object.language}`;
+                        else if (quad.object.datatype?.value && quad.object.datatype.value !== 'http://www.w3.org/2001/XMLSchema#string') {
+                            ann += ` ^^${shortenIRI(quad.object.datatype.value, ctx)}`;
+                        }
+                        edits.push({ start: result.length, end: result.length, text: `\n[${value}] {${ann}}` });
+                    } else {
+                        const full = quad.object.value;
+                        const label = shortenIRI(full, ctx);
+                        edits.push({ start: result.length, end: result.length, text: `\n[${label}](${full}) {?${predShort}}` });
+                    }
+                    return;
+                }
+
+                const predShort = shortenIRI(quad.predicate.value, ctx);
+                if (quad.object.termType === 'Literal') {
+                    const value = String(quad.object.value ?? '');
+                    let ann = predShort;
+                    if (quad.object.language) ann += ` @${quad.object.language}`;
+                    else if (quad.object.datatype?.value && quad.object.datatype.value !== 'http://www.w3.org/2001/XMLSchema#string') {
+                        ann += ` ^^${shortenIRI(quad.object.datatype.value, ctx)}`;
+                    }
+                    edits.push({ start: result.length, end: result.length, text: `\n[${value}] {${ann}}` });
+                    return;
+                }
+
+                if (quad.object.termType === 'NamedNode') {
+                    const full = quad.object.value;
+                    const label = shortenIRI(full, ctx);
+                    edits.push({ start: result.length, end: result.length, text: `\n[${label}](${full}) {?${predShort}}` });
+                    return;
+                }
+            }
+
+            const span = serializeHelpers.readAttrsSpan(targetBlock, text);
+            if (!span) return;
+            const tokens = serializeHelpers.blockTokensFromEntries(targetBlock) || serializeHelpers.normalizeAttrsTokens(span.text);
+
+            if (quad.predicate.value.endsWith('rdf-syntax-ns#type') && quad.object?.termType === 'NamedNode') {
+                const typeShort = shortenIRI(quad.object.value, ctx);
+                const typeToken = typeShort.includes(':') || !typeShort.startsWith('http') ? `.${typeShort}` : null;
+                if (!typeToken) return;
+                if (tokens.includes(typeToken)) return;
+                const updated = [...tokens, typeToken];
+                edits.push({ start: span.start, end: span.end, text: serializeHelpers.writeAttrsTokens(updated) });
+                return;
             }
 
-            const newLine = `\n[${objText}] {${pred}}`;
-            edits.push({ start: insertPos, end: insertPos, text: newLine });
+            const form = anchored?.entry?.form;
+            if (form == null) return;
+            const predShort = shortenIRI(quad.predicate.value, ctx);
+            const predToken = `${form}${predShort}`;
+            if (!predToken) return;
+            if (tokens.includes(predToken)) return;
+            const updated = [...tokens, predToken];
+            edits.push({ start: span.start, end: span.end, text: serializeHelpers.writeAttrsTokens(updated) });
         });
     }
 
@@ -562,7 +983,8 @@ export function serialize({ text, diff, origin, options = {} }) {
         result = result.substring(0, edit.start) + edit.text + result.substring(edit.end);
     });
 
-    return { text: result, origin };
+    const reparsed = parse(result, { context: options.context || {} });
+    return { text: result, origin: reparsed.origin };
 }
 
-export default { parse, serialize, parseSemanticBlock };
+export default { parse, serialize, parseSemanticBlock, shortenIRI };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mdld-parse",
-	"version": "0.2.3",
+	"version": "0.2.4",
 	"description": "A standards-compliant parser for **MD-LD (Markdown-Linked Data)** — a human-friendly RDF authoring format that extends Markdown with semantic annotations.",
 	"type": "module",
 	"main": "index.js",