mdld-parse 0.5.6 → 0.6.0

package/README.md

@@ -22,10 +22,10 @@ Energy level: [8] {my:energyLevel ^^xsd:integer}
 
 Met [Sam] {+my:sam .my:Person ?my:attendee} on my regular walk at [Central Park] {+my:central-park ?my:location .my:Place label @en} and talked about [Sunny] {my:weather} weather. 
 
-Activities: {?my:hasActivity .my:Activity label}
+Activities:
 
-- Walking {=#walking}
-- Reading {=#reading}
+- **Walking** {+ex:walking ?my:hasActivity .my:Activity label}
+- **Reading** {+ex:reading ?my:hasActivity .my:Activity label}
 
 ```
 
@@ -59,7 +59,7 @@ my:central-park a my:Place;
 
 ```
 
-Read the [FULL SPEC](./docs/Spec/Spec.md).
+Read the [FULL SPEC](./spec/Spec.md).
 
 ## Core Features
 
@@ -69,7 +69,6 @@ Read the [FULL SPEC](./docs/Spec/Spec.md).
 - **Four predicate forms**: `p` (S→L), `?p` (S→O), `!p` (O→S)
 - **Type declarations**: `.Class` for rdf:type triples
 - **Datatypes & language**: `^^xsd:date` and `@en` support
-- **Lists**: Explicit subject declarations and numbered ordered lists with `rdf:List` support
 - **Fragments**: Built-in document structuring with `{=#fragment}`
 - **Round-trip serialization**: Markdown ↔ RDF ↔ Markdown preserves structure
 
@@ -213,14 +212,15 @@ ex:armstrong a prov:Person .
 
 ### Lists
 
-Lists require explicit subjects per item. 
+Lists are pure Markdown structure. Each list item requires explicit annotations:
 
 ```markdown
 # Recipe {=ex:recipe}
 
-Ingredients: {?ex:ingredient .ex:Ingredient}
-- Flour {=ex:flour label}
-- Water {=ex:water label}
+Ingredients:
+
+- **Flour** {+ex:flour ?ex:ingredient .ex:Ingredient label}
+- **Water** {+ex:water ?ex:ingredient .ex:Ingredient label}
 ```
 
 ```turtle
@@ -229,6 +229,11 @@ ex:flour a ex:Ingredient ; rdfs:label "Flour" .
 ex:water a ex:Ingredient ; rdfs:label "Water" .
 ```
 
+**Key Rules:**
+- No semantic propagation from list scope
+- Each item must have explicit annotations
+- Use `+IRI` to maintain subject chaining for repeated object properties
+
 ### Code Blocks
 
 Code blocks are value carriers:
@@ -503,7 +508,7 @@ Only specific markdown elements can carry semantic values:
 
 **Block:**
 - Headings (`# Title`)
-- List items (`- item`, `1. item`) (single-level)
+- List items (`- item`, `1. item`) — pure Markdown structure
 - Blockquotes (`> quote`)
 - Code blocks (` ```lang `)
 
@@ -579,14 +584,14 @@ Therefore, the algebra is **closed**.
 
 # Meeting Notes {=alice:meeting-2024-01-15 .alice:Meeting}
 
-Attendees: {?alice:attendee label}
+Attendees:
 
-- Alice {=alice:alice}
-- Bob {=alice:bob}
+- **Alice** {+alice:alice ?alice:attendee label}
+- **Bob** {+alice:bob ?alice:attendee label}
 
-Action items: {?alice:actionItem label}
+Action items:
 
-- Review proposal {=alice:task-1}
+- **Review proposal** {+alice:task-1 ?alice:actionItem label}
 ```
 
 ### Developer Documentation
@@ -630,7 +635,7 @@ Tests validate:
 - Subject declaration and context
 - All predicate forms (p, ?p, !p)
 - Datatypes and language tags
-- List processing
+- Explicit list item annotations
 - Code blocks and blockquotes
 - Round-trip serialization
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mdld-parse",
-	"version": "0.5.6",
+	"version": "0.6.0",
 	"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",

package/src/applyDiff.js

@@ -15,25 +15,93 @@ import {
     addSoftFragmentToken,
     removeSoftFragmentToken,
     objectSignature,
-    expandIRI
+    expandIRI,
+    DataFactory
 } from './utils.js';
 
 function getBlockById(base, blockId) {
-    return blockId ? base?.blocks?.get(blockId) : null;
+    return blockId ? base?.quadMap?.get(blockId) : null;
 }
 
 function getEntryByQuadKey(base, quadKey) {
-    return quadKey ? base?.quadIndex?.get(quadKey) : null;
+    return quadKey ? base?.quadMap?.get(quadKey) : null;
+}
+
+// Helper functions for cleaner term type checking
+function isLiteral(term) {
+    return term?.termType === 'Literal';
+}
+
+function isNamedNode(term) {
+    return term?.termType === 'NamedNode';
+}
+
+function isRdfType(term) {
+    return term?.value === 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+}
+
+function createAnnotationForQuad(quad, ctx) {
+    const predShort = shortenIRI(quad.predicate.value, ctx);
+    if (isLiteral(quad.object)) {
+        const value = String(quad.object.value ?? '');
+        const ann = createLiteralAnnotation(value, predShort, quad.object.language, quad.object.datatype, ctx);
+        return { text: `[${value}] {${ann}}`, isLiteral: true };
+    } else if (isNamedNode(quad.object)) {
+        const objectShort = shortenIRI(quad.object.value, ctx);
+        const objectAnn = createObjectAnnotation(objectShort, predShort);
+        return { text: objectAnn, isLiteral: false };
+    }
+    return null;
+}
+
+function createSubjectBlockForQuad(quad, ctx) {
+    const subjectShort = shortenIRI(quad.subject.value, ctx);
+    const predShort = shortenIRI(quad.predicate.value, ctx);
+    const subjectName = extractLocalName(quad.subject.value);
+
+    if (isNamedNode(quad.object)) {
+        // IRI object: create object reference
+        const objectShort = shortenIRI(quad.object.value, ctx);
+        return { text: `\n\n# ${subjectName.charAt(0).toUpperCase() + subjectName.slice(1)} {=${subjectShort}}\n[${objectShort}] {${predShort}}\n`, isNewSubject: true };
+    } else {
+        // Literal object: create property on separate line
+        const value = String(quad.object.value ?? '');
+        const annotation = createLiteralAnnotation(value, predShort, quad.object.language, quad.object.datatype, ctx);
+        return { text: `\n\n# ${subjectName.charAt(0).toUpperCase() + subjectName.slice(1)} {=${subjectShort}}\n[${value}] {${annotation}}\n`, isNewSubject: true };
+    }
+}
+
+function extractLocalName(iri) {
+    return iri.split('/').pop() || iri.split('#').pop() || iri;
 }
 
 function isValidQuad(quad) {
     return quad && quad.subject && quad.predicate && quad.object;
 }
 
+function normalizeDiffQuads(quads, ctx) {
+    // Use DataFactory.fromQuad for proper RDF/JS compatibility
+    // But first expand any CURIEs in the quads to ensure proper matching
+    return quads.map(quad => {
+        // Expand CURIEs to full IRIs before normalization
+        const expandedQuad = {
+            subject: quad.subject.termType === 'NamedNode'
+                ? { ...quad.subject, value: expandIRI(quad.subject.value, ctx) }
+                : quad.subject,
+            predicate: quad.predicate.termType === 'NamedNode'
+                ? { ...quad.predicate, value: expandIRI(quad.predicate.value, ctx) }
+                : quad.predicate,
+            object: quad.object,
+            graph: quad.graph
+        };
+        return DataFactory.fromQuad(expandedQuad);
+    }).filter(isValidQuad);
+}
+
 function createLiteralAnnotation(value, predicate, language, datatype, ctx) {
     let ann = predicate;
     if (language) ann += ` @${language}`;
-    else if (datatype?.value && datatype.value !== 'http://www.w3.org/2001/XMLSchema#string') {
+    else if (datatype?.value && datatype.value !== DataFactory.literal('').datatype.value) {
         ann += ` ^^${shortenIRI(datatype.value, ctx)}`;
     }
     return ann;
@@ -126,23 +194,24 @@ function removeTokenFromSlot(entry, tokens, ctx, quad) {
 }
 
 function addTokenToSlot(tokens, ctx, quad) {
-    if (quad.predicate.value.endsWith('rdf-syntax-ns#type') && quad.object?.termType === 'NamedNode') {
+    // Use cleaner helper functions
+    if (isRdfType(quad.predicate) && isNamedNode(quad.object)) {
         const typeShort = shortenIRI(quad.object.value, ctx);
         const typeToken = typeShort.includes(':') || !typeShort.startsWith('http') ? `.${typeShort}` : null;
         if (typeToken && !tokens.includes(typeToken)) {
             return [...tokens, typeToken];
         }
-    } else if (quad.object.termType === 'NamedNode') {
+    } else if (isNamedNode(quad.object)) {
         const objectShort = shortenIRI(quad.object.value, ctx);
         const isSoftFragment = quad.object.value.includes('#');
         const fragment = isSoftFragment ? quad.object.value.split('#')[1] : null;
 
-        if (isSoftFragment) {
-            return addSoftFragmentToken(tokens, fragment);
+        if (fragment) {
+            return addSoftFragmentToken(tokens, objectShort, fragment);
         } else {
             return addObjectToken(tokens, objectShort);
         }
-    } else if (quad.object.termType === 'Literal') {
+    } else if (isLiteral(quad.object)) {
         const predShort = shortenIRI(quad.predicate.value, ctx);
         if (!tokens.includes(predShort)) {
             return [...tokens, predShort];
@@ -179,9 +248,9 @@ export function applyDiff({ text, diff, origin, options = {} }) {
 
 
 function planOperations(diff, base, ctx) {
-    // Normalize quads once
-    const normAdds = (diff.add || []).map(normalizeQuad).filter(isValidQuad);
-    const normDeletes = (diff.delete || []).map(normalizeQuad).filter(isValidQuad);
+    // Normalize quads using DataFactory for proper RDF/JS compatibility
+    const normAdds = normalizeDiffQuads(diff.add || [], ctx);
+    const normDeletes = normalizeDiffQuads(diff.delete || [], ctx);
 
     const plan = {
         literalUpdates: [],
@@ -206,8 +275,7 @@ function planOperations(diff, base, ctx) {
         const key = JSON.stringify([quad.subject.value, objectSignature(quad.object)]);
         const quadKey = quadToKeyForOrigin(quad);
         const entry = getEntryByQuadKey(base, quadKey);
-        const blockId = entry?.blockId || entry;
-        const block = getBlockById(base, blockId);
+        const block = entry; // In unified structure, entry is the block
         if (block?.attrsRange) {
             anchors.set(key, { block, entry });
         }
@@ -215,18 +283,18 @@ function planOperations(diff, base, ctx) {
 
     // Detect literal updates early
     for (const deleteQuad of normDeletes) {
-        if (deleteQuad.object.termType !== 'Literal') continue;
+        if (!isLiteral(deleteQuad.object)) continue;
 
         const k = JSON.stringify([deleteQuad.subject.value, deleteQuad.predicate.value]);
         const candidates = addBySP.get(k) || [];
         const addQuad = candidates.find(x =>
-            x?.object?.termType === 'Literal' && !plan.consumedAdds.has(quadToKeyForOrigin(x))
+            isLiteral(x?.object) && !plan.consumedAdds.has(quadToKeyForOrigin(x))
         );
 
         if (!addQuad) continue;
 
         const entry = resolveOriginEntry(deleteQuad, base);
-        const block = entry ? getBlockById(base, entry.blockId || entry) : null;
+        const block = entry; // In unified structure, the entry is the block
 
         if (block) {
             plan.literalUpdates.push({ deleteQuad, addQuad, entry, block });
@@ -236,13 +304,13 @@ function planOperations(diff, base, ctx) {
 
     // Find vacant slot occupations
     for (const quad of normAdds) {
-        if (quad.object.termType !== 'Literal') continue;
+        if (!isLiteral(quad.object)) continue;
         if (plan.consumedAdds.has(quadToKeyForOrigin(quad))) continue;
 
-        const vacantSlot = findVacantSlot(base?.quadIndex, quad.subject, quad.predicate);
+        const vacantSlot = findVacantSlot(base?.quadMap, quad.subject, quad.predicate);
         if (!vacantSlot) continue;
 
-        const block = base?.blocks?.get(vacantSlot.blockId);
+        const block = vacantSlot; // In unified structure, the slot is the block
         if (block) {
             plan.vacantSlotOccupations.push({ quad, vacantSlot, block });
             plan.consumedAdds.add(quadToKeyForOrigin(quad));
@@ -251,7 +319,7 @@ function planOperations(diff, base, ctx) {
 
     // Plan remaining deletes
     for (const quad of normDeletes) {
-        if (quad.object.termType === 'Literal') {
+        if (isLiteral(quad.object)) {
             const isUpdated = plan.literalUpdates.some(u =>
                 u.deleteQuad.subject.value === quad.subject.value &&
                 u.deleteQuad.predicate.value === quad.predicate.value &&
@@ -261,7 +329,7 @@ function planOperations(diff, base, ctx) {
         }
 
         const entry = resolveOriginEntry(quad, base);
-        const block = entry ? getBlockById(base, entry.blockId || entry) : null;
+        const block = entry; // In unified structure, entry is the block
         if (block) {
             plan.deletes.push({ quad, entry, block });
         }
@@ -348,7 +416,7 @@ function materializeEdits(plan, text, ctx, base) {
             };
             vacantSlot.blockInfo = blockInfo;
             const key = quadToKeyForOrigin(quad);
-            if (key) base.quadIndex.set(key, vacantSlot);
+            if (key) base.quadMap.set(key, vacantSlot);
         }
 
         const span = readSpan(block, text, 'attrs');
@@ -382,56 +450,45 @@ function materializeEdits(plan, text, ctx, base) {
             continue;
         }
 
-        if (quad.object.termType === 'Literal' || quad.object.termType === 'NamedNode') {
+        if (isLiteral(quad.object) || isNamedNode(quad.object)) {
             if (!targetBlock) {
-                const predShort = shortenIRI(quad.predicate.value, ctx);
-                if (quad.object.termType === 'Literal') {
-                    const value = String(quad.object.value ?? '');
-                    const ann = createLiteralAnnotation(value, predShort, quad.object.language, quad.object.datatype, ctx);
-                    edits.push({ start: text.length, end: text.length, text: `\n[${value}] {${ann}}` });
+                // No target block - check if subject already exists in document
+                const subjectExists = Array.from(base?.quadMap?.values() || [])
+                    .some(block => block.subject?.value === quad.subject.value);
+
+                let annotation;
+                if (!subjectExists && isNamedNode(quad.object)) {
+                    // New subject with IRI object - create subject block
+                    annotation = createSubjectBlockForQuad(quad, ctx);
+                } else if (subjectExists) {
+                    // Existing subject - create simple annotation
+                    annotation = createAnnotationForQuad(quad, ctx);
                 } else {
-                    const objectShort = shortenIRI(quad.object.value, ctx);
-                    edits.push({ start: text.length, end: text.length, text: createObjectAnnotation(objectShort, predShort) });
+                    // New subject with literal - create subject block
+                    annotation = createSubjectBlockForQuad(quad, ctx);
                 }
-                continue;
-            }
 
-            const span = readSpan(targetBlock, text, 'attrs');
-            if (!span) continue;
-
-            // Check if this is a subject-only block (like {=ex:order-123})
-            const tokens = normalizeAttrsTokens(span.text);
-            const hasSubjectToken = tokens.some(t => t.startsWith('='));
-            const hasPredicateTokens = tokens.some(t => !t.startsWith('=') && !t.startsWith('.'));
-
-            if (tokens.length === 1 && tokens[0].startsWith('=')) {
-                // This is a subject-only block, create new annotation
-                const predShort = shortenIRI(quad.predicate.value, ctx);
-                if (quad.object.termType === 'Literal') {
-                    const value = String(quad.object.value ?? '');
-                    const ann = createLiteralAnnotation(value, predShort, quad.object.language, quad.object.datatype, ctx);
-                    edits.push({ start: text.length, end: text.length, text: `\n[${value}] {${ann}}` });
-                } else {
-                    const objectShort = shortenIRI(quad.object.value, ctx);
-                    edits.push({ start: text.length, end: text.length, text: createObjectAnnotation(objectShort, predShort) });
+                if (annotation) {
+                    edits.push({ start: text.length, end: text.length, text: annotation.text });
                 }
                 continue;
             }
 
-            // Normal annotation block, add tokens
-            const existingTokens = blockTokensFromEntries(targetBlock) || tokens;
-            let updated = addTokenToSlot(existingTokens, ctx, quad);
+            // Insert annotation after target block's range
+            const annotation = createAnnotationForQuad(quad, ctx);
+            if (annotation) {
+                // Find the end of the target block's content, not just its range
+                const targetBlockEnd = targetBlock.range.end;
+                let insertPos = targetBlockEnd;
 
-            // For literal predicates with datatypes, we need to add datatype token too
-            if (quad.object.termType === 'Literal' && quad.object.datatype && quad.object.datatype.value !== 'http://www.w3.org/2001/XMLSchema#string') {
-                const datatypeToken = `^^${shortenIRI(quad.object.datatype.value, ctx)}`;
-                if (!updated.includes(datatypeToken)) {
-                    updated = [...updated, datatypeToken];
+                // Skip past the target block's content to find the right insertion point
+                while (insertPos < text.length && text[insertPos] !== '\n') {
+                    insertPos++;
                 }
-            }
 
-            if (updated.length !== existingTokens.length) {
-                edits.push({ start: span.start, end: span.end, text: writeAttrsTokens(updated) });
+                // Insert after the target block's content
+                const finalInsertPos = insertPos < text.length ? insertPos : text.length;
+                edits.push({ start: finalInsertPos, end: finalInsertPos, text: `\n${annotation.text}` });
             }
         }
     }
@@ -450,7 +507,7 @@ function applyEdits(text, edits, ctx, base) {
 
     // Extract vacant slots before reparsing
     const vacantSlots = new Map();
-    base?.quadIndex?.forEach((slot, key) => {
+    base?.quadMap?.forEach((slot, key) => {
         if (slot.isVacant) vacantSlots.set(key, slot);
     });
 
@@ -458,7 +515,7 @@ function applyEdits(text, edits, ctx, base) {
 
     // Merge vacant slots back
     vacantSlots.forEach((vacantSlot, key) => {
-        if (!reparsed.origin.blocks.has(vacantSlot.blockId) && vacantSlot.blockInfo) {
+        if (!reparsed.origin.quadMap.has(vacantSlot.id) && vacantSlot.blockInfo) {
             const { blockInfo } = vacantSlot;
             const emptyBlock = {
                 id: blockInfo.id,
@@ -469,12 +526,11 @@ function applyEdits(text, edits, ctx, base) {
                 subject: blockInfo.subject || '',
                 types: [],
                 predicates: [],
-                entries: [],
                 context: blockInfo.context || { ...ctx }
             };
-            reparsed.origin.blocks.set(vacantSlot.blockId, emptyBlock);
+            reparsed.origin.quadMap.set(vacantSlot.id, emptyBlock);
         }
-        reparsed.origin.quadIndex.set(key, vacantSlot);
+        reparsed.origin.quadMap.set(key, vacantSlot);
     });
 
     return { text: result, origin: reparsed.origin };
@@ -483,11 +539,11 @@ function applyEdits(text, edits, ctx, base) {
 // Helper functions for origin lookup
 function resolveOriginEntry(quad, base) {
     const key = quadToKeyForOrigin(quad);
-    let entry = key ? base?.quadIndex?.get(key) : null;
+    let entry = key ? base?.quadMap?.get(key) : null;
 
-    if (!entry && quad.object?.termType === 'Literal') {
+    if (!entry && isLiteral(quad.object)) {
         // Fallback: search by value
-        for (const [k, e] of base?.quadIndex || []) {
+        for (const [k, e] of base?.quadMap || []) {
             const parsed = parseQuadIndexKey(k);
             if (parsed && parsed.s === quad.subject.value &&
                 parsed.p === quad.predicate.value &&
@@ -507,12 +563,21 @@ function findTargetBlock(quad, base, anchors) {
     const anchored = anchors.get(anchorKey);
     if (anchored?.block) return anchored.block;
 
-    // Block affinity: prefer same block, then same subject
-    for (const [, block] of base?.blocks || []) {
-        if (block.subject === quad.subject.value && block.attrsRange) {
-            return block;
-        }
+    // Find the best position within the subject's section
+    // Look for blocks with the same subject and sort by position
+    const subjectBlocks = Array.from(base?.quadMap?.values() || [])
+        .filter(block => block.subject?.value === quad.subject.value)
+        .sort((a, b) => a.range.start - b.range.start);
+
+    if (subjectBlocks.length === 0) return null;
+
+    // Strategy: Find the last block with attrsRange to maintain consistency
+    // For identical subject blocks, prefer the first one to avoid creating duplicates
+    const blocksWithAttrs = subjectBlocks.filter(block => block.attrsRange);
+    if (blocksWithAttrs.length > 0) {
+        return blocksWithAttrs[blocksWithAttrs.length - 1]; // Return last matching block
     }
 
-    return null;
+    // Fallback: return the last block in the subject's section
+    return subjectBlocks[subjectBlocks.length - 1];
 }

package/src/generate.js

@@ -1,4 +1,17 @@
-import { shortenIRI, expandIRI, quadIndexKey, createSlotInfo, DEFAULT_CONTEXT } from './utils.js';
+import { shortenIRI, expandIRI, quadIndexKey, createUnifiedSlot, DEFAULT_CONTEXT, DataFactory } from './utils.js';
+
+// Helper functions for cleaner term type checking
+function isLiteral(term) {
+    return term?.termType === 'Literal';
+}
+
+function isNamedNode(term) {
+    return term?.termType === 'NamedNode';
+}
+
+function isRdfType(term) {
+    return term?.value === 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+}
 
 
 function extractLocalName(iri) {
@@ -25,37 +38,37 @@ export function generate(quads, context = {}) {
 
     const subjectGroups = groupQuadsBySubject(normalizedQuads);
 
-    const { text, blocks, quadIndex } = buildDeterministicMDLD(subjectGroups, fullContext);
+    const { text, quadMap } = buildDeterministicMDLD(subjectGroups, fullContext);
 
     return {
         text,
-        origin: { blocks, quadIndex },
+        origin: { quadMap },
         context: fullContext
     };
 }
 
 function normalizeAndSortQuads(quads) {
     return quads
-        .map(quad => ({
-            subject: { termType: quad.subject.termType, value: quad.subject.value },
-            predicate: { termType: quad.predicate.termType, value: quad.predicate.value },
-            object: quad.object.termType === 'Literal'
-                ? {
-                    termType: 'Literal',
-                    value: quad.object.value,
-                    language: quad.object.language || null,
-                    datatype: quad.object.datatype || { termType: 'NamedNode', value: 'http://www.w3.org/2001/XMLSchema#string' }
-                }
-                : { termType: 'NamedNode', value: quad.object.value }
-        }))
+        .map(quad => {
+            // Use DataFactory.fromTerm to ensure proper RDF/JS compatibility
+            const normSubject = DataFactory.fromTerm(quad.subject);
+            const normPredicate = DataFactory.fromTerm(quad.predicate);
+            const normObject = DataFactory.fromTerm(quad.object);
+
+            return {
+                subject: normSubject,
+                predicate: normPredicate,
+                object: normObject
+            };
+        })
         .sort((a, b) => {
             // Deterministic sorting: subject -> predicate -> object
             const sComp = a.subject.value.localeCompare(b.subject.value);
             if (sComp !== 0) return sComp;
             const pComp = a.predicate.value.localeCompare(b.predicate.value);
             if (pComp !== 0) return pComp;
-            const oA = a.object.termType === 'Literal' ? a.object.value : a.object.value;
-            const oB = b.object.termType === 'Literal' ? b.object.value : b.object.value;
+            const oA = isLiteral(a.object) ? a.object.value : a.object.value;
+            const oB = isLiteral(b.object) ? b.object.value : b.object.value;
             return oA.localeCompare(oB);
         });
 }
@@ -74,8 +87,7 @@ function groupQuadsBySubject(quads) {
 function buildDeterministicMDLD(subjectGroups, context) {
     let text = '';
     let currentPos = 0;
-    const blocks = new Map();
-    const quadIndex = new Map();
+    const quadMap = new Map();
 
     // Add prefixes first (deterministic order), but exclude default context prefixes
     const sortedPrefixes = Object.entries(context).sort(([a], [b]) => a.localeCompare(b));
@@ -83,14 +95,6 @@ function buildDeterministicMDLD(subjectGroups, context) {
         // Skip default context prefixes - they're implicit in MDLD
         if (prefix !== '@vocab' && !prefix.startsWith('@') && !DEFAULT_CONTEXT[prefix]) {
             const prefixDecl = `[${prefix}] <${namespace}>\n`;
-            const blockId = generateBlockId();
-            blocks.set(blockId, {
-                id: blockId,
-                range: { start: currentPos, end: currentPos + prefixDecl.length },
-                subject: null,
-                entries: [{ kind: 'prefix', prefix, namespace, raw: prefixDecl.trim() }],
-                carrierType: 'prefix'
-            });
             text += prefixDecl;
             currentPos += prefixDecl.length;
         }
@@ -108,10 +112,10 @@ function buildDeterministicMDLD(subjectGroups, context) {
         const subjectQuads = subjectGroups.get(subjectIRI);
         const shortSubject = shortenIRI(subjectIRI, context);
 
-        // Separate types, literals, and objects
-        const types = subjectQuads.filter(q => q.predicate.value === 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type');
-        const literals = subjectQuads.filter(q => q.object.termType === 'Literal' && q.predicate.value !== 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type');
-        const objects = subjectQuads.filter(q => q.object.termType === 'NamedNode' && q.predicate.value !== 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type');
+        // Separate types, literals, and objects using helper functions
+        const types = subjectQuads.filter(q => isRdfType(q.predicate));
+        const literals = subjectQuads.filter(q => isLiteral(q.object) && !isRdfType(q.predicate));
+        const objects = subjectQuads.filter(q => isNamedNode(q.object) && !isRdfType(q.predicate));
 
         // Generate heading
         const localSubjectName = extractLocalName(subjectIRI);
@@ -120,28 +124,23 @@ function buildDeterministicMDLD(subjectGroups, context) {
             : '';
 
         const headingText = `# ${localSubjectName} {=${shortSubject}${typeAnnotations}}\n\n`;
-        const blockId = generateBlockId();
+
         const headingBlock = {
-            id: blockId,
+            id: generateBlockId(),
             range: { start: currentPos, end: currentPos + headingText.length },
             subject: subjectIRI,
-            entries: [
-                { kind: 'subject', raw: `=${shortSubject}`, expandedSubject: subjectIRI },
-                ...types.map((t, i) => ({
-                    kind: 'type',
-                    raw: '.' + extractLocalName(t.object.value),
-                    expandedType: t.object.value,
-                    entryIndex: i
-                }))
-            ],
-            carrierType: 'heading'
+            types: types.map(t => t.object.value),
+            predicates: [],
+            context: { ...context },
+            carrierType: 'heading',
+            attrsRange: { start: currentPos + headingText.indexOf('{'), end: currentPos + headingText.indexOf('}') + 1 },
+            valueRange: { start: currentPos + 2, end: currentPos + 2 + localSubjectName.length }
         };
-        blocks.set(blockId, headingBlock);
 
-        // Add type quads to index
+        // Add type quads to quadMap
         types.forEach((quad, i) => {
             const key = quadIndexKey(quad.subject, quad.predicate, quad.object);
-            quadIndex.set(key, createSlotInfo(blockId, i, {
+            quadMap.set(key, createUnifiedSlot(headingBlock, i, {
                 kind: 'type',
                 subject: quad.subject,
                 predicate: quad.predicate,
@@ -158,34 +157,30 @@ function buildDeterministicMDLD(subjectGroups, context) {
             const predShort = shortenIRI(quad.predicate.value, context);
             let annotation = predShort;
 
+            // Use DataFactory XSD constants for datatype comparison
+            const xsdString = 'http://www.w3.org/2001/XMLSchema#string';
             if (quad.object.language) {
                 annotation += ` @${quad.object.language}`;
-            } else if (quad.object.datatype.value !== 'http://www.w3.org/2001/XMLSchema#string') {
+            } else if (quad.object.datatype.value !== xsdString) {
                 annotation += ` ^^${shortenIRI(quad.object.datatype.value, context)}`;
             }
 
             const literalText = `[${quad.object.value}] {${annotation}}\n`;
-            const literalBlockId = generateBlockId();
             const literalBlock = {
-                id: literalBlockId,
+                id: generateBlockId(),
                 range: { start: currentPos, end: currentPos + literalText.length },
                 subject: subjectIRI,
-                entries: [{
-                    kind: 'property',
-                    raw: annotation,
-                    expandedPredicate: quad.predicate.value,
-                    form: '',
-                    entryIndex: 0
-                }],
+                types: [],
+                predicates: [{ iri: quad.predicate.value, form: '' }],
+                context: { ...context },
                 carrierType: 'span',
                 valueRange: { start: currentPos + 1, end: currentPos + 1 + quad.object.value.length },
                 attrsRange: { start: currentPos + literalText.indexOf('{'), end: currentPos + literalText.indexOf('}') + 1 }
             };
-            blocks.set(literalBlockId, literalBlock);
 
-            // Add to quad index
+            // Add to quadMap
             const key = quadIndexKey(quad.subject, quad.predicate, quad.object);
-            quadIndex.set(key, createSlotInfo(literalBlockId, 0, {
+            quadMap.set(key, createUnifiedSlot(literalBlock, 0, {
                 kind: 'pred',
                 subject: quad.subject,
                 predicate: quad.predicate,
@@ -200,29 +195,25 @@ function buildDeterministicMDLD(subjectGroups, context) {
         // Add objects (deterministic order)
         const sortedObjects = objects.sort((a, b) => a.predicate.value.localeCompare(b.predicate.value));
         for (const quad of sortedObjects) {
-            const predShort = shortenIRI(quad.predicate.value, context);
             const objShort = shortenIRI(quad.object.value, context);
-            const localName = extractLocalName(quad.object.value);
+            const predShort = shortenIRI(quad.predicate.value, context);
+            const objectText = `[${objShort}] {+${objShort} ?${predShort}}\n`;
 
-            const objectText = `[${localName}] {+${objShort} ?${predShort}}\n`;
-            const objectBlockId = generateBlockId();
             const objectBlock = {
-                id: objectBlockId,
+                id: generateBlockId(),
                 range: { start: currentPos, end: currentPos + objectText.length },
                 subject: subjectIRI,
-                entries: [{
-                    kind: 'object',
-                    raw: objShort,
-                    expandedObject: quad.object.value,
-                    entryIndex: 0
-                }],
-                carrierType: 'span'
+                types: [],
+                predicates: [{ iri: quad.predicate.value, form: '?' }],
+                context: { ...context },
+                carrierType: 'span',
+                valueRange: { start: currentPos + 1, end: currentPos + 1 + objShort.length },
+                attrsRange: { start: currentPos + objectText.indexOf('{'), end: currentPos + objectText.indexOf('}') + 1 }
             };
-            blocks.set(objectBlockId, objectBlock);
 
-            // Add to quad index
+            // Add to quadMap
             const key = quadIndexKey(quad.subject, quad.predicate, quad.object);
-            quadIndex.set(key, createSlotInfo(objectBlockId, 0, {
+            quadMap.set(key, createUnifiedSlot(objectBlock, 0, {
                 kind: 'pred',
                 subject: quad.subject,
                 predicate: quad.predicate,
@@ -234,13 +225,11 @@ function buildDeterministicMDLD(subjectGroups, context) {
             currentPos += objectText.length;
         }
 
-        if (sortedLiterals.length > 0 || sortedObjects.length > 0) {
-            text += '\n';
-            currentPos += 1;
-        }
+        text += '\n';
+        currentPos += 1;
     }
 
-    return { text: text.trim(), blocks, quadIndex };
+    return { text, quadMap };
 }
 
 function generateBlockId() {

package/src/index.js

@@ -2,6 +2,7 @@ export { parse } from './parse.js';
 export { applyDiff } from './applyDiff.js';
 export { generate } from './generate.js';
 export { locate } from './locate.js';
+export { render } from './render.js';
 export {
     DEFAULT_CONTEXT,
     DataFactory,

package/src/locate.js

@@ -17,7 +17,7 @@ export function locate(quad, origin, text = '', context = {}) {
         origin = parseResult.origin;
     }
 
-    if (!quad || !origin || !origin.quadIndex || !origin.blocks) {
+    if (!quad || !origin || !origin.quadMap) {
         return null;
     }
 
@@ -27,57 +27,40 @@ export function locate(quad, origin, text = '', context = {}) {
         return null;
     }
 
-    // Generate the quad key to lookup in quadIndex
+    // Generate the quad key to lookup in quadMap
     const quadKey = quadIndexKey(normalizedQuad.subject, normalizedQuad.predicate, normalizedQuad.object);
 
-    // Find the slot information in quadIndex
-    const slotInfo = origin.quadIndex.get(quadKey);
+    // Find the slot information in quadMap
+    const slotInfo = origin.quadMap.get(quadKey);
     if (!slotInfo) {
         return null;
     }
 
-    // Get the block information
-    const block = origin.blocks.get(slotInfo.blockId);
-    if (!block) {
-        return null;
-    }
+    // In unified structure, slotInfo contains all block information
+    const block = slotInfo;
 
-    // Extract the actual text content based on carrier type and entry
+    // Extract the actual text content based on carrier type
     let contentRange = null;
     let content = '';
 
     if (block.carrierType === 'heading') {
-        // For headings, use the block's main range
-        contentRange = block.range;
-        content = text.substring(block.range.start, block.range.end);
-    } else if (block.carrierType === 'blockquote' || block.carrierType === 'list' || block.carrierType === 'span') {
-        // For blockquotes, lists, and spans, extract from block range
-        contentRange = block.range;
-        content = text.substring(block.range.start, block.range.end);
-
-        // For blockquotes, try to extract the specific carrier content from entries
-        if (slotInfo.entryIndex != null && block.entries && block.entries[slotInfo.entryIndex]) {
-            const entry = block.entries[slotInfo.entryIndex];
-            if (entry.raw) {
-                // For blockquotes, the entry.raw contains the full carrier text
-                // Extract just the content part before the annotation
-                const annotationStart = entry.raw.indexOf('{');
-                if (annotationStart !== -1) {
-                    const carrierContent = entry.raw.substring(0, annotationStart).trim();
-                    // Find this content in the block text
-                    const contentStart = text.indexOf(carrierContent, block.range.start);
-                    if (contentStart !== -1) {
-                        const contentEnd = contentStart + carrierContent.length;
-                        contentRange = { start: contentStart, end: contentEnd };
-                        content = text.substring(contentStart, contentEnd);
-                    }
-                }
-            }
+        // For headings, use the value range for the heading text
+        contentRange = block.valueRange;
+        content = text.substring(block.valueRange.start, block.valueRange.end);
+    } else if (block.carrierType === 'emphasis' || block.carrierType === 'blockquote' || block.carrierType === 'list' || block.carrierType === 'span') {
+        // For emphasis, blockquotes, lists, and spans, use the value range
+        if (block.valueRange) {
+            contentRange = block.valueRange;
+            content = text.substring(block.valueRange.start, block.valueRange.end);
+        } else {
+            // Fallback to block range
+            contentRange = block.range;
+            content = text.substring(block.range.start, block.range.end);
         }
     }
 
     return {
-        blockId: slotInfo.blockId,
+        blockId: slotInfo.id,
         entryIndex: slotInfo.entryIndex,
         kind: slotInfo.kind,
         subject: normalizedQuad.subject,

package/src/parse.js

@@ -4,7 +4,7 @@ import {
     expandIRI,
     parseSemanticBlock,
     quadIndexKey,
-    createSlotInfo,
+    createUnifiedSlot,
     createLiteral,
     hash
 } from './utils.js';
@@ -16,7 +16,6 @@ const HEADING_REGEX = /^(#{1,6})\s+(.+?)(?:\s*(\{[^}]+\}))?$/;
 const UNORDERED_LIST_REGEX = /^(\s*)([-*+]|\d+\.)\s+(.+?)(?:\s*(\{[^}]+\}))?\s*$/;
 const BLOCKQUOTE_REGEX = /^>\s+(.+?)(?:\s*(\{[^}]+\}))?$/;
 const STANDALONE_SUBJECT_REGEX = /^\s*\{=(.*?)\}\s*$/;
-const LIST_CONTEXT_REGEX = /^(.+?)\s*\{([^}]+)\}$/;
 const INLINE_CARRIER_PATTERNS = {
     EMPHASIS: /[*__`]+(.+?)[*__`]+\s*\{([^}]+)\}/y,
     CODE_SPAN: /``(.+?)``\s*\{([^}]+)\}/y
@@ -87,13 +86,12 @@ function getCarriers(token) {
     return token._carriers || (token._carriers = extractInlineCarriers(token.text, token.range[0]));
 }
 
-const createListToken = (type, line, lineStart, pos, match, indent = null) => {
+const createListToken = (type, line, lineStart, pos, match) => {
     const attrs = match[4] || null;
     const prefix = match[1].length + (match[2] ? match[2].length : 0);
     const rangeInfo = calcRangeInfo(line, attrs, lineStart, prefix, match[3].length);
-    const extra = indent !== null ? { indent } : { indent: match[1].length };
     return createToken(type, [lineStart, pos - 1], match[3].trim(), attrs,
-        rangeInfo.attrsRange, rangeInfo.valueRange, extra);
+        rangeInfo.attrsRange, rangeInfo.valueRange, { indent: match[1].length });
 };
 
 function scanTokens(text) {
@@ -173,7 +171,7 @@ function scanTokens(text) {
 
     function handleList(line, lineStart, pos) {
         const match = UNORDERED_LIST_REGEX.exec(line);
-        tokens.push(createListToken('list', line, lineStart, pos, match, match[1].length));
+        tokens.push(createListToken('list', line, lineStart, pos, match));
         return true;
     }
 
@@ -277,14 +275,14 @@ function extractInlineCarriers(text, baseOffset = 0) {
 }
 
 function calcCarrierRanges(match, baseOffset, matchStart) {
-    const valueStart = baseOffset + matchStart;
+    const valueStart = baseOffset + matchStart + match[0].indexOf(match[1]);
     const valueEnd = valueStart + match[1].length;
     const attrsStart = baseOffset + matchStart + match[0].indexOf('{');
     const attrsEnd = attrsStart + match[2].length + 2; // +2 for { and }
     return {
         valueRange: [valueStart, valueEnd],
         attrsRange: [attrsStart + 1, attrsEnd - 1], // Exclude braces
-        range: [valueStart, attrsEnd],
+        range: [baseOffset + matchStart, attrsEnd],
         pos: matchStart + match[0].length // pos should be relative to current text, not document
     };
 }
@@ -345,7 +343,7 @@ function determineCarrierType(url) {
     return { carrierType: 'span', resourceIRI: null };
 }
 
-function createBlock(subject, types, predicates, entries, range, attrsRange, valueRange, carrierType, ctx) {
+function createBlock(subject, types, predicates, range, attrsRange, valueRange, carrierType, ctx) {
     const expanded = {
         subject,
         types: types.map(t => expandIRI(typeof t === 'string' ? t : t.iri, ctx)),
@@ -364,23 +362,26 @@ function createBlock(subject, types, predicates, entries, range, attrsRange, val
         subject,
         types: expanded.types,
         predicates: expanded.predicates,
-        entries: entries || [],
-        context: { ...ctx }
+        context: ctx
     };
 }
 
-function emitQuad(quads, quadIndex, blockId, subject, predicate, object, dataFactory, meta = null) {
+function emitQuad(quads, quadMap, block, subject, predicate, object, dataFactory, meta = null) {
     if (!subject || !predicate || !object) return;
+
     const quad = dataFactory.quad(subject, predicate, object);
     quads.push(quad);
 
-    const slotInfo = createSlotInfo(blockId, meta?.entryIndex, {
+    const unifiedSlot = createUnifiedSlot(block, meta?.entryIndex, {
         ...meta,
-        subject, predicate, object
+        subject,
+        predicate,
+        object
     });
 
-    quadIndex.set(quadIndexKey(quad.subject, quad.predicate, quad.object), slotInfo);
+    quadMap.set(quadIndexKey(quad.subject, quad.predicate, quad.object), unifiedSlot);
 }
+
 const resolveFragment = (fragment, state) => {
     if (!state.currentSubject) return null;
     const baseIRI = state.currentSubject.value.split('#')[0];
@@ -403,10 +404,10 @@ function resolveObject(sem, state) {
     return state.df.namedNode(expandIRI(sem.object, state.ctx));
 }
 
-const createTypeQuad = (typeIRI, subject, state, blockId, entryIndex = null) => {
+const createTypeQuad = (typeIRI, subject, state, block, entryIndex = null) => {
     const expandedType = expandIRI(typeIRI, state.ctx);
     emitQuad(
-        state.quads, state.origin.quadIndex, blockId,
+        state.quads, state.origin.quadMap, block,
         subject,
         state.df.namedNode(expandIRI('rdf:type', state.ctx)),
         state.df.namedNode(expandedType),
@@ -419,9 +420,9 @@ function processTypeAnnotations(sem, newSubject, localObject, carrierO, S, block
     sem.types.forEach(t => {
         const typeIRI = typeof t === 'string' ? t : t.iri;
         const entryIndex = typeof t === 'string' ? null : t.entryIndex;
-        // Type subject priority: explicit subject > soft object > URL > current subject
+        // Type subject priority: explicit subject > soft object > carrier URL > current subject
         let typeSubject = newSubject || localObject || carrierO || S;
-        createTypeQuad(typeIRI, typeSubject, state, block.id, entryIndex);
+        createTypeQuad(typeIRI, typeSubject, state, block, entryIndex);
     });
 }
 
@@ -452,7 +453,7 @@ function processPredicateAnnotations(sem, newSubject, previousSubject, localObje
         const role = determinePredicateRole(pred, carrier, newSubject, previousSubject, localObject, newSubjectOrCarrierO, S, L);
         if (role) {
             const P = state.df.namedNode(expandIRI(pred.iri, state.ctx));
-            emitQuad(state.quads, state.origin.quadIndex, block.id,
+            emitQuad(state.quads, state.origin.quadMap, block,
                 role.subject, P, role.object, state.df,
                 { kind: 'pred', token: `${pred.form}${pred.iri}`, form: pred.form, expandedPredicate: P.value, entryIndex: pred.entryIndex }
             );
@@ -480,11 +481,10 @@ function processAnnotation(carrier, sem, state, options = {}) {
     if (!S) return;
 
     const block = createBlock(
-        S.value, sem.types, sem.predicates, sem.entries,
+        S.value, sem.types, sem.predicates,
         carrier.range, carrier.attrsRange || null, carrier.valueRange || null,
         carrier.type || null, state.ctx
     );
-    state.origin.blocks.set(block.id, block);
 
     const L = createLiteral(carrier.text, sem.datatype, sem.language, state.ctx, state.df);
     const carrierO = carrier.url ? state.df.namedNode(expandIRI(carrier.url, state.ctx)) : null;
@@ -494,171 +494,12 @@ function processAnnotation(carrier, sem, state, options = {}) {
     processPredicateAnnotations(sem, newSubject, previousSubject, localObject, newSubjectOrCarrierO, S, L, block, state, carrier);
 }
 
-export function findItemSubject(listToken, carriers, state) {
-    const sem = parseSemCached(listToken.attrs);
-    if (sem.subject && sem.subject !== 'RESET') {
-        const subject = resolveSubject(sem, state);
-        if (subject) {
-            return {
-                subject,
-                carrier: { type: 'list', text: listToken.text, attrs: listToken.attrs, range: listToken.range }
-            };
-        }
-    }
 
-    for (const carrier of carriers) {
-        const carrierSem = parseSemCached(carrier.attrs);
-        if (carrierSem.subject && carrierSem.subject !== 'RESET') {
-            const subject = resolveSubject(carrierSem, state);
-            if (subject) {
-                return { subject, carrier };
-            }
-        }
-    }
 
-    return null;
-}
 
-const processContextSem = ({ sem, itemSubject, contextSubject, inheritLiterals = false, state, blockId = 'list-context' }) => {
-    sem.types.forEach(t => {
-        const typeIRI = typeof t === 'string' ? t : t.iri;
-        emitQuad(
-            state.quads, state.origin.quadIndex, blockId,
-            itemSubject,
-            state.df.namedNode(expandIRI('rdf:type', state.ctx)),
-            state.df.namedNode(expandIRI(typeIRI, state.ctx)),
-            state.df
-        );
-    });
 
-    sem.predicates.forEach(pred => {
-        const P = state.df.namedNode(expandIRI(pred.iri, state.ctx));
-        if (pred.form === '!') {
-            emitQuad(state.quads, state.origin.quadIndex, blockId, itemSubject, P, contextSubject, state.df);
-        } else if (pred.form === '?') {
-            emitQuad(state.quads, state.origin.quadIndex, blockId, contextSubject, P, itemSubject, state.df);
-        }
-    });
 
-    if (inheritLiterals) {
-        const literalPredicates = sem.predicates.filter(p => p.form === '');
-        if (literalPredicates.length > 0) {
-            return {
-                subject: null, object: null, types: [],
-                predicates: literalPredicates.map(p => ({ iri: p.iri, form: p.form, entryIndex: p.entryIndex })),
-                datatype: null, language: null, entries: []
-            };
-        }
-    }
-    return null;
-};
 
-const manageListStack = (token, state) => {
-    while (state.listStack.length && token.indent < state.listStack[state.listStack.length - 1].indent) {
-        state.listStack.pop();
-    }
-
-    if (state.pendingListContext) {
-        state.listStack.push({
-            indent: token.indent,
-            anchorSubject: state.pendingListContext.subject,
-            contextSubject: state.pendingListContext.subject,
-            contextSem: state.pendingListContext.sem,
-            contextText: state.pendingListContext.contextText,
-            contextToken: state.pendingListContext.contextToken // Store context token for origins
-        });
-        state.pendingListContext = null;
-    } else if (state.listStack.length === 0 || token.indent > state.listStack[state.listStack.length - 1].indent) {
-        const parentFrame = state.listStack.length > 0 ? state.listStack[state.listStack.length - 1] : null;
-        state.listStack.push({
-            indent: token.indent,
-            anchorSubject: parentFrame?.anchorSubject || null,
-            contextSubject: parentFrame?.anchorSubject || null,
-            contextSem: null
-        });
-    }
-};
-
-const combineSemanticInfo = (token, carriers, listFrame, state, itemSubject) => {
-    const combinedSem = { subject: null, object: null, types: [], predicates: [], datatype: null, language: null, entries: [] };
-    const addSem = (sem) => {
-        const entryIndex = combinedSem.entries.length;
-        combinedSem.types.push(...sem.types);
-        combinedSem.predicates.push(...sem.predicates);
-        combinedSem.entries.push(...sem.entries.map(entry => ({ ...entry, entryIndex })));
-    };
-
-    if (listFrame?.contextSem) {
-        const inheritedSem = processContextSem({ sem: listFrame.contextSem, itemSubject, contextSubject: listFrame.contextSubject, inheritLiterals: true, state });
-        if (inheritedSem) addSem(inheritedSem);
-    }
-
-    if (token.attrs) addSem(parseSemCached(token.attrs));
-    carriers.forEach(carrier => { if (carrier.attrs) addSem(parseSemCached(carrier.attrs)); });
-
-    return combinedSem;
-};
-
-const processListItem = (token, state) => {
-    const carriers = getCarriers(token);
-    const itemInfo = findItemSubject(token, carriers, state);
-    if (!itemInfo) return;
-
-    const { subject: itemSubject } = itemInfo;
-    if (state.listStack.length > 0) state.listStack[state.listStack.length - 1].anchorSubject = itemSubject;
-
-    const listFrame = state.listStack[state.listStack.length - 1];
-    const combinedSem = combineSemanticInfo(token, carriers, listFrame, state, itemSubject);
-
-    if (combinedSem.entries.length > 0) {
-        const prevSubject = state.currentSubject;
-        state.currentSubject = itemSubject;
-
-        processAnnotation({ type: 'list', text: token.text, range: token.range, attrsRange: token.attrsRange || null, valueRange: token.valueRange || null }, combinedSem, state, { preserveGlobalSubject: !state.listStack.length, implicitSubject: itemSubject });
-
-        state.currentSubject = prevSubject;
-    }
-};
-
-
-function processListContextFromParagraph(token, state) {
-    const contextMatch = LIST_CONTEXT_REGEX.exec(token.text);
-    if (!contextMatch) return;
-
-    const contextSem = parseSemCached(`{${contextMatch[2]}}`);
-    let contextSubject = state.currentSubject || state.documentSubject;
-
-    if (!contextSubject && state.tokens) {
-        for (let i = state.currentTokenIndex - 1; i >= 0; i--) {
-            const prevToken = state.tokens[i];
-            if (prevToken.type === 'heading' && prevToken.attrs) {
-                const prevSem = parseSemCached(prevToken.attrs);
-                if (prevSem.subject) {
-                    const resolvedSubject = resolveSubject(prevSem, state);
-                    if (resolvedSubject) {
-                        contextSubject = resolvedSubject.value;
-                        break;
-                    }
-                }
-            }
-        }
-    }
-
-    const nextToken = state.tokens?.[state.currentTokenIndex + 1];
-    if (state.listStack.length > 0 && nextToken && nextToken.type === 'list') {
-        const currentFrame = state.listStack[state.listStack.length - 1];
-        if (currentFrame.anchorSubject && nextToken.indent > currentFrame.indent) {
-            contextSubject = currentFrame.anchorSubject;
-        }
-    }
-
-    state.pendingListContext = {
-        sem: contextSem,
-        subject: contextSubject,
-        contextText: contextMatch[1].replace(':', '').trim(),
-        contextToken: token // Store the context token for origin ranges
-    };
-}
 
 function processTokenAnnotations(token, state, tokenType) {
     if (token.attrs) {
@@ -692,13 +533,6 @@ function processStandaloneSubject(token, state) {
 
 const TOKEN_PROCESSORS = {
     heading: (token, state) => {
-        if (token.attrs) {
-            const headingSem = parseSemCached(token.attrs);
-            if (headingSem.subject) {
-                const subject = resolveSubject(headingSem, state);
-                if (subject) state.documentSubject = subject;
-            }
-        }
         processTokenAnnotations(token, state, token.type);
     },
     code: (token, state) => {
@@ -709,12 +543,10 @@ const TOKEN_PROCESSORS = {
     },
     para: (token, state) => {
         processStandaloneSubject(token, state);
-        processListContextFromParagraph(token, state);
         processTokenAnnotations(token, state, token.type);
     },
     list: (token, state) => {
-        manageListStack(token, state);
-        processListItem(token, state);
+        processTokenAnnotations(token, state, token.type);
     },
 };
 
@@ -723,11 +555,8 @@ export function parse(text, options = {}) {
         ctx: { ...DEFAULT_CONTEXT, ...(options.context || {}) },
         df: options.dataFactory || DataFactory,
         quads: [],
-        origin: { blocks: new Map(), quadIndex: new Map() },
+        origin: { quadMap: new Map() },
         currentSubject: null,
-        documentSubject: null,
-        listStack: [],
-        pendingListContext: null,
         tokens: null,
         currentTokenIndex: -1
     };

package/src/utils.js

@@ -218,6 +218,15 @@ export const DataFactory = {
     fromQuad: (inQuad) => {
         if (inQuad instanceof Quad) return inQuad;
         if (inQuad.termType !== 'Quad') {
+            // Handle plain object quads by treating them as quads
+            if (inQuad.subject && inQuad.predicate && inQuad.object) {
+                return new Quad(
+                    DataFactory.fromTerm(inQuad.subject),
+                    DataFactory.fromTerm(inQuad.predicate),
+                    DataFactory.fromTerm(inQuad.object),
+                    DataFactory.fromTerm(inQuad.graph || DataFactory.defaultGraph())
+                );
+            }
             throw new Error(`Unexpected termType: ${inQuad.termType}`);
         }
         return new Quad(
@@ -265,9 +274,18 @@ export function expandIRI(term, 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);
+
+    // Find the best matching prefix - more precise matching
     for (const [prefix, namespace] of Object.entries(ctx)) {
         if (prefix !== '@vocab' && iri.startsWith(namespace)) {
-            return prefix + ':' + iri.substring(namespace.length);
+            // Check if this is the best match (longest namespace)
+            const isBestMatch = Object.entries(ctx)
+                .filter(([p, ns]) => p !== '@vocab' && iri.startsWith(ns))
+                .every(([p, ns]) => namespace.length >= ns.length || (p === prefix && ns.length === namespace.length));
+
+            if (isBestMatch) {
+                return prefix + ':' + iri.substring(namespace.length);
+            }
         }
     }
     return iri;
@@ -407,16 +425,29 @@ export function parseQuadIndexKey(key) {
     }
 }
 
-// Direct slot management functions - no factory needed
-export function createSlotInfo(blockId, entryIndex, meta = {}) {
+// Direct slot management functions - unified with block data
+export function createUnifiedSlot(block, entryIndex, meta = {}) {
     const slotId = meta.subject && meta.predicate ? hash(`${meta.subject.value}|${meta.predicate.value}`) : null;
     return {
-        blockId,
+        // Block metadata
+        id: block.id,
+        range: block.range,
+        attrsRange: block.attrsRange,
+        valueRange: block.valueRange,
+        carrierType: block.carrierType,
+        subject: block.subject,
+        types: block.types,
+        predicates: block.predicates,
+        context: block.context,
+
+        // Slot metadata
         entryIndex,
         slotId,
         isVacant: false,
         lastValue: null,
         vacantSince: null,
+
+        // Quad metadata
         ...meta
     };
 }
@@ -430,9 +461,9 @@ export function markSlotAsVacant(slotInfo, deletedValue) {
     } : null;
 }
 
-export function findVacantSlot(quadIndex, subject, predicate) {
+export function findVacantSlot(quadMap, subject, predicate) {
     const targetSlotId = hash(`${subject.value}|${predicate.value}`);
-    return Array.from(quadIndex.values())
+    return Array.from(quadMap.values())
         .find(slot => slot.slotId === targetSlotId && slot.isVacant);
 }