mdld-parse 0.5.0 → 0.5.1

package/README.md

@@ -1,4 +1,4 @@
-# MD-LD Parse v0.4.1
+# MD-LD
 
 **Markdown-Linked Data (MD-LD)** — a deterministic, streaming-friendly RDF authoring format that extends Markdown with explicit `{...}` annotations.
 
@@ -184,33 +184,20 @@ ex:armstrong a schema:Person .
 
 ### Lists
 
-Lists require explicit subjects per item.  Use numbered ordered lists for `rdf:List` structures:
+Lists require explicit subjects per item. 
 
 ```markdown
 # Recipe {=ex:recipe}
 
 Ingredients: {?ingredient .Ingredient}
-
 - Flour {=ex:flour name}
 - Water {=ex:water name}
-
-## Status Values {=ex:statusValues}
-Status values: {?ex:in .ex:StatusType label}
-1. Active {=ex:Active}
-2. Pending {=ex:Pending}
-3. Inactive {=ex:Inactive}
 ```
 
 ```turtle
 ex:recipe schema:ingredient ex:flour, ex:water .
 ex:flour a schema:Ingredient ; schema:name "Flour" .
 ex:water a schema:Ingredient ; schema:name "Water" .
-
-# Ordered list generates W3C RDF Collections
-ex:statusValues ex:in ex:statusValues#list-1-1 .
-ex:statusValues#list-1-1 rdf:first ex:Active ; rdf:rest ex:statusValues#list-1-2 .
-ex:statusValues#list-1-2 rdf:first ex:Pending ; rdf:rest ex:statusValues#list-1-3 .
-ex:statusValues#list-1-3 rdf:first ex:Inactive ; rdf:rest rdf:nil .
 ```
 
 ### Code Blocks

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mdld-parse",
-	"version": "0.5.0",
+	"version": "0.5.1",
 	"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/parse.js

@@ -13,8 +13,7 @@ const URL_REGEX = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
 const FENCE_REGEX = /^(`{3,})(.*)/;
 const PREFIX_REGEX = /^\[([^\]]+)\]\s*<([^>]+)>/;
 const HEADING_REGEX = /^(#{1,6})\s+(.+?)(?:\s*(\{[^}]+\}))?$/;
-const UNORDERED_LIST_REGEX = /^(\s*)([-*+])\s+(.+?)(?:\s*(\{[^}]+\}))?\s*$/;
-const ORDERED_LIST_REGEX = /^(\s*)(\d+\.)\s+(.+?)(?:\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*\{([^}]+)\}$/;
@@ -69,7 +68,7 @@ const createListToken = (type, line, lineStart, pos, match, indent = null) => {
     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, number: parseInt(match[2]) };
+    const extra = indent !== null ? { indent } : { indent: match[1].length };
     return createToken(type, [lineStart, pos - 1], match[3].trim(), attrs,
         rangeInfo.attrsRange, rangeInfo.valueRange, extra);
 };
@@ -149,15 +148,7 @@ function scanTokens(text) {
             test: line => UNORDERED_LIST_REGEX.test(line),
             process: (line, lineStart, pos) => {
                 const match = UNORDERED_LIST_REGEX.exec(line);
-                tokens.push(createListToken('unordered-list', line, lineStart, pos, match, match[1].length));
-                return true;
-            }
-        },
-        {
-            test: line => ORDERED_LIST_REGEX.test(line),
-            process: (line, lineStart, pos) => {
-                const match = ORDERED_LIST_REGEX.exec(line);
-                tokens.push(createListToken('ordered-list', line, lineStart, pos, match));
+                tokens.push(createListToken('list', line, lineStart, pos, match, match[1].length));
                 return true;
             }
         },
@@ -507,19 +498,6 @@ export function findItemSubject(listToken, carriers, state) {
     return null;
 }
 
-function hasOwnPredicates(listToken, carriers) {
-    if (listToken.attrs) {
-        const attrs = parseSemCached(listToken.attrs);
-        if (attrs.predicates.some(p => !p.subject && p.iri !== 'RESET')) {
-            return true;
-        }
-    }
-    return carriers.some(carrier => {
-        const carrierAttrs = parseSemCached(carrier.attrs);
-        return carrierAttrs.predicates.some(p => !p.subject && p.iri !== 'RESET');
-    });
-}
-
 const processContextSem = ({ sem, itemSubject, contextSubject, inheritLiterals = false, state, blockId = 'list-context' }) => {
     sem.types.forEach(t => {
         const typeIRI = typeof t === 'string' ? t : t.iri;
@@ -616,190 +594,6 @@ const processListItem = (token, state) => {
     }
 };
 
-const applyListAnchorAnnotations = (itemSubject, contextSem, state, listItemText, contextToken) => {
-    // Use the context token's ranges for proper origin tracking
-    const baseToken = contextToken || { range: [0, 0], attrsRange: [0, 0] };
-
-    const paragraphText = baseToken.text || '';
-    const annotationMatch = paragraphText.match(/\{[^}]+\}/);
-
-    let annotationStart;
-    if (annotationMatch && baseToken.range) {
-        // Found annotation in paragraph, calculate its absolute position
-        const relativeStart = paragraphText.indexOf(annotationMatch[0]);
-        annotationStart = baseToken.range[0] + relativeStart;
-    } else {
-        // Fallback to start of token
-        annotationStart = baseToken.range ? baseToken.range[0] : 0;
-    }
-
-    // Apply types with proper ranges
-    contextSem.types.forEach(type => {
-        const entry = contextSem.entries.find(e => e.kind === 'type' && e.iri === type.iri);
-        if (entry && entry.relRange) {
-            // Calculate absolute range: annotation start + relative range within annotation
-            const typeRange = [annotationStart + entry.relRange.start, annotationStart + entry.relRange.end];
-
-            emitQuad(state.quads, state.origin.quadIndex, 'list-anchor-type',
-                itemSubject,
-                state.df.namedNode(expandIRI('rdf:type', state.ctx)),
-                state.df.namedNode(expandIRI(type.iri, state.ctx)),
-                state.df,
-                { type: 'list-anchor', range: typeRange, entryIndex: type.entryIndex }
-            );
-        }
-    });
-
-    // Apply predicates with proper ranges
-    contextSem.predicates.forEach(pred => {
-        if (pred.form !== '?' && pred.form !== '!') { // Skip context predicates
-            const entry = contextSem.entries.find(e => e.kind === 'property' && e.iri === pred.iri);
-            if (entry && entry.relRange) {
-                // Calculate absolute range: annotation start + relative range within annotation
-                const predRange = [annotationStart + entry.relRange.start, annotationStart + entry.relRange.end];
-
-                const P = state.df.namedNode(expandIRI(pred.iri, state.ctx));
-
-                // For literal predicates, the value comes from the list item text
-                let objectValue;
-                if (pred.form === '') {
-                    objectValue = state.df.literal(listItemText || '');
-                } else {
-                    // For other forms, this would need more complex handling
-                    objectValue = state.df.literal(listItemText || '');
-                }
-
-                emitQuad(state.quads, state.origin.quadIndex, 'list-anchor-predicate',
-                    itemSubject, P, objectValue, state.df,
-                    { type: 'list-anchor', range: predRange, entryIndex: pred.entryIndex }
-                );
-            }
-        }
-    });
-}
-
-function processOrderedListItem(token, state) {
-    if (!state.isProcessingOrderedList) {
-        state.listCounter = (state.listCounter || 0) + 1;
-        state.rdfListIndex = 0;
-        state.firstListNode = null;
-        state.previousListNode = null;
-        state.contextConnected = false;
-        state.isProcessingOrderedList = true;
-    }
-
-    generateRdfListTriples(token, state);
-
-    const listFrame = state.listStack[state.listStack.length - 1];
-    if (listFrame?.contextSem) {
-        const carriers = getCarriers(token);
-        const itemInfo = findItemSubject(token, carriers, state);
-        if (itemInfo?.subject) {
-            applyListAnchorAnnotations(itemInfo.subject, listFrame.contextSem, state, token.text, listFrame.contextToken);
-        }
-    }
-
-    if (listFrame?.contextSem && listFrame?.contextSubject && !state.contextConnected) {
-        listFrame.contextSem.predicates.forEach(pred => {
-            if (pred.form === '?') {
-                const P = state.df.namedNode(expandIRI(pred.iri, state.ctx));
-                const firstListNode = state.firstListNode;
-                if (firstListNode) {
-                    emitQuad(state.quads, state.origin.quadIndex, 'ordered-list-context',
-                        listFrame.contextSubject, P, state.df.namedNode(firstListNode), state.df);
-                    state.contextConnected = true;
-                }
-            }
-        });
-    }
-}
-
-function generateRdfListTriples(token, state) {
-    const carriers = getCarriers(token);
-    const listIndex = (state.rdfListIndex || 0) + 1;
-    state.rdfListIndex = listIndex;
-    const listNodeName = `list-${state.listCounter}-${listIndex}`;
-
-    const listFrame = state.listStack[state.listStack.length - 1];
-    const contextSubject = listFrame?.contextSubject || state.currentSubject || state.documentSubject;
-    const baseIRI = contextSubject ? contextSubject.value : (state.ctx[''] || '');
-
-    const listNodeIri = baseIRI.includes('#')
-        ? `${baseIRI.split('#')[0]}#${listNodeName}`
-        : `${baseIRI}#${listNodeName}`;
-
-    if (!state.firstListNode) state.firstListNode = listNodeIri;
-
-    // Emit rdf:type triple with origin tracking
-    emitQuad(state.quads, state.origin.quadIndex, 'ordered-list-rdf-type',
-        DataFactory.namedNode(listNodeIri),
-        DataFactory.namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#type'),
-        DataFactory.namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#List'),
-        DataFactory,
-        { type: 'ordered-list', range: token.valueRange || token.range, listNodeName }
-    );
-
-    const itemInfo = findItemSubject(token, carriers, state);
-    let firstObject;
-    if (itemInfo?.value) {
-        firstObject = itemInfo.value;
-    } else if (itemInfo?.subject) {
-        firstObject = itemInfo.subject;
-    } else {
-        firstObject = DataFactory.literal(token.text);
-    }
-
-    // Determine the appropriate range based on object type
-    let originRange;
-    if (itemInfo?.subject) {
-        // For IRIs, target the annotation range
-        originRange = token.attrsRange || token.valueRange || token.range;
-    } else {
-        // For literals, target the value range
-        originRange = token.valueRange || token.range;
-    }
-
-    // Emit rdf:first triple with origin tracking
-    emitQuad(state.quads, state.origin.quadIndex, 'ordered-list-rdf-first',
-        DataFactory.namedNode(listNodeIri),
-        DataFactory.namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#first'),
-        firstObject,
-        DataFactory,
-        { type: 'ordered-list', range: originRange, listNodeName }
-    );
-
-    if (state.previousListNode) {
-        // Find and remove the previous rdf:rest -> rdf:nil quad, then emit a new one
-        const prevRestQuadIndex = state.quads.findIndex(q =>
-            q.subject.value === state.previousListNode &&
-            q.predicate.value === 'http://www.w3.org/1999/02/22-rdf-syntax-ns#rest'
-        );
-        if (prevRestQuadIndex !== -1) {
-            // Remove the old quad
-            state.quads.splice(prevRestQuadIndex, 1);
-
-            // Emit new rdf:rest quad with proper origin tracking
-            emitQuad(state.quads, state.origin.quadIndex, 'ordered-list-rdf-rest-update',
-                DataFactory.namedNode(state.previousListNode),
-                DataFactory.namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#rest'),
-                DataFactory.namedNode(listNodeIri),
-                DataFactory,
-                { type: 'ordered-list', range: token.valueRange || token.range, listNodeName: state.previousListNode }
-            );
-        }
-    }
-
-    // Emit rdf:rest triple with origin tracking
-    emitQuad(state.quads, state.origin.quadIndex, 'ordered-list-rdf-rest',
-        DataFactory.namedNode(listNodeIri),
-        DataFactory.namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#rest'),
-        DataFactory.namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#nil'),
-        DataFactory,
-        { type: 'ordered-list', range: token.valueRange || token.range, listNodeName }
-    );
-
-    state.previousListNode = listNodeIri;
-}
 
 function processListContextFromParagraph(token, state) {
     const contextMatch = LIST_CONTEXT_REGEX.exec(token.text);
@@ -825,7 +619,7 @@ function processListContextFromParagraph(token, state) {
     }
 
     const nextToken = state.tokens?.[state.currentTokenIndex + 1];
-    if (state.listStack.length > 0 && nextToken && (nextToken.type === 'unordered-list' || nextToken.type === 'ordered-list')) {
+    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;
@@ -872,7 +666,6 @@ function processStandaloneSubject(token, state) {
 
 const TOKEN_PROCESSORS = {
     heading: (token, state) => {
-        state.isProcessingOrderedList = false;
         if (token.attrs) {
             const headingSem = parseSemCached(token.attrs);
             if (headingSem.subject) {
@@ -883,30 +676,20 @@ const TOKEN_PROCESSORS = {
         processTokenAnnotations(token, state, token.type);
     },
     code: (token, state) => {
-        state.isProcessingOrderedList = false;
         processTokenAnnotations(token, state, token.type);
     },
     blockquote: (token, state) => {
-        state.isProcessingOrderedList = false;
         processTokenAnnotations(token, state, token.type);
     },
     para: (token, state) => {
-        if (!token.text.includes('{?') && !token.text.includes('{!')) {
-            state.isProcessingOrderedList = false;
-        }
         processStandaloneSubject(token, state);
         processListContextFromParagraph(token, state);
         processTokenAnnotations(token, state, token.type);
     },
-    'unordered-list': (token, state) => {
-        state.isProcessingOrderedList = false;
+    list: (token, state) => {
         manageListStack(token, state);
         processListItem(token, state);
     },
-    'ordered-list': (token, state) => {
-        manageListStack(token, state);
-        processOrderedListItem(token, state);
-    }
 };
 
 export function parse(text, options = {}) {
@@ -920,13 +703,7 @@ export function parse(text, options = {}) {
         listStack: [],
         pendingListContext: null,
         tokens: null,
-        currentTokenIndex: -1,
-        listCounter: 0,
-        rdfListIndex: 0,
-        firstListNode: null,
-        previousListNode: null,
-        contextConnected: false,
-        isProcessingOrderedList: false
+        currentTokenIndex: -1
     };
 
     state.tokens = scanTokens(text);

package/src/serialize.js

@@ -177,175 +177,6 @@ export function serialize({ text, diff, origin, options = {} }) {
     return applyEdits(text, edits, ctx, base);
 }
 
-function determineListOperation(listData, normAdds, normDeletes, base) {
-    // Check if this is list modification (has both adds and deletes for list structure)
-    const hasListAdds = normAdds.some(quad =>
-        quad.subject.value.includes('#list-') ||
-        quad.predicate.value.endsWith('#first') ||
-        quad.predicate.value.endsWith('#rest') ||
-        quad.predicate.value.endsWith('#type') && quad.object.value.endsWith('#List')
-    );
-
-    const hasListDeletes = normDeletes.some(quad =>
-        quad.subject.value.includes('#list-') ||
-        quad.predicate.value.endsWith('#first') ||
-        quad.predicate.value.endsWith('#rest') ||
-        quad.predicate.value.endsWith('#type') && quad.object.value.endsWith('#List')
-    );
-
-    if (hasListAdds || hasListDeletes) {
-        return { type: 'modify' };
-    }
-
-    // Check if this is a list creation (all list structure quads are in adds)
-    const allListQuads = [];
-    listData.items.forEach(item => {
-        if (item.typeQuad) allListQuads.push(item.typeQuad);
-        if (item.firstQuad) allListQuads.push(item.firstQuad);
-        if (item.restQuad) allListQuads.push(item.restQuad);
-    });
-    if (listData.headQuad) allListQuads.push(listData.headQuad);
-
-    const allInAdds = allListQuads.every(quad =>
-        normAdds.some(add =>
-            add.subject.value === quad.subject.value &&
-            add.predicate.value === quad.predicate.value &&
-            add.object.value === quad.object.value
-        )
-    );
-
-    if (allInAdds) {
-        return { type: 'create' };
-    }
-
-    // Check if this is a list deletion (all list structure quads are in deletes)
-    const allInDeletes = allListQuads.every(quad =>
-        normDeletes.some(del =>
-            del.subject.value === quad.subject.value &&
-            del.predicate.value === quad.predicate.value &&
-            del.object.value === quad.object.value
-        )
-    );
-
-    if (allInDeletes) {
-        return { type: 'delete' };
-    }
-
-    // Default to modify for any list changes
-    return { type: 'modify' };
-}
-
-function detectRdfLists(quads, base, ctx) {
-    const lists = new Map();
-
-    // Find all rdf:List instances (W3C standard approach)
-    const listNodes = quads.filter(q =>
-        q.predicate.value.endsWith('#type') &&
-        q.object.value === 'http://www.w3.org/1999/02/22-rdf-syntax-ns#List'
-    );
-
-    // Find parent subjects that point to list nodes
-    const parentToListNodes = new Map();
-
-    for (const listNode of listNodes) {
-        const listSubject = listNode.subject.value;
-
-        // Find the parent subject that points to this list node
-        const parentQuad = quads.find(q =>
-            q.object.value === listSubject &&
-            q.subject.value !== listSubject // Don't match self-references
-        );
-
-        if (parentQuad) {
-            const parentSubject = parentQuad.subject.value;
-            if (!parentToListNodes.has(parentSubject)) {
-                parentToListNodes.set(parentSubject, []);
-            }
-            parentToListNodes.get(parentSubject).push(listSubject);
-        }
-    }
-
-    // For each parent, build the complete list
-    for (const [parentSubject, listNodeSubjects] of parentToListNodes) {
-        const allListItems = [];
-
-        for (const listNodeSubject of listNodeSubjects) {
-            // Find all quads for this list node
-            const listNodeQuads = quads.filter(q => q.subject.value === listNodeSubject);
-
-            const firstQuad = listNodeQuads.find(q =>
-                q.predicate.value === 'http://www.w3.org/1999/02/22-rdf-syntax-ns#first'
-            );
-
-            const restQuad = listNodeQuads.find(q =>
-                q.predicate.value === 'http://www.w3.org/1999/02/22-rdf-syntax-ns#rest'
-            );
-
-            if (firstQuad) {
-                allListItems.push({
-                    listNode: listNodeSubject,
-                    item: firstQuad.object,
-                    typeQuad: listNode,
-                    firstQuad,
-                    restQuad
-                });
-            }
-        }
-
-        // Sort items by following rdf:rest chains to maintain order
-        const orderedItems = [];
-        const processed = new Set();
-
-        // Find the head (item not referenced as a rest)
-        const restTargets = new Set(
-            allListItems
-                .filter(item => item.restQuad?.object?.value !== 'http://www.w3.org/1999/02/22-rdf-syntax-ns#nil')
-                .map(item => item.restQuad.object.value)
-        );
-
-        const headItems = allListItems.filter(item => !restTargets.has(item.listNode));
-
-        if (headItems.length > 0) {
-            // Start from head and follow rest chain
-            let currentItem = headItems[0];
-            let index = 0;
-
-            while (currentItem && !processed.has(currentItem.listNode)) {
-                currentItem.itemIndex = index++;
-                orderedItems.push(currentItem);
-                processed.add(currentItem.listNode);
-
-                // Find next item in chain
-                const nextListNode = currentItem.restQuad?.object?.value;
-                currentItem = allListItems.find(item => item.listNode === nextListNode);
-            }
-        } else {
-            // Fallback: sort by list node number
-            allListItems.sort((a, b) => {
-                const aNum = parseInt(a.listNode.split('-').pop()) || 0;
-                const bNum = parseInt(b.listNode.split('-').pop()) || 0;
-                return aNum - bNum;
-            });
-
-            allListItems.forEach((item, index) => {
-                item.itemIndex = index;
-                orderedItems.push(item);
-            });
-        }
-
-        // Store the unified list under the parent subject
-        lists.set(parentSubject, {
-            subject: parentSubject,
-            items: orderedItems,
-            headQuad: quads.find(q =>
-                q.subject.value === parentSubject &&
-                listNodeSubjects.includes(q.object.value)
-            )
-        });
-    }
-
-    return lists;
-}
 
 function planOperations(diff, base, ctx) {
     // Normalize quads once
@@ -357,7 +188,6 @@ function planOperations(diff, base, ctx) {
         vacantSlotOccupations: [],
         deletes: [],
         adds: [],
-        listOperations: [], // NEW: Support for ordered list operations
         consumedAdds: new Set()
     };
 
@@ -445,55 +275,6 @@ function planOperations(diff, base, ctx) {
         plan.adds.push({ quad, targetBlock });
     }
 
-    // NEW: Detect RDF lists and plan list operations
-    const allQuads = [...normAdds, ...normDeletes];
-    const rdfLists = detectRdfLists(allQuads, base, ctx);
-
-    for (const [listSubject, listData] of rdfLists) {
-        const operation = determineListOperation(listData, normAdds, normDeletes, base);
-        if (operation) {
-            plan.listOperations.push({
-                type: 'rdf-list',
-                subject: listSubject,
-                items: listData.items,
-                operation,
-                headQuad: listData.headQuad,
-                normAdds, // Pass through for reconstruction
-                normDeletes // Pass through for reconstruction
-            });
-
-            // Mark all list-related quads as consumed to prevent double processing
-            const allListQuads = [];
-            listData.items.forEach(item => {
-                if (item.typeQuad) allListQuads.push(item.typeQuad);
-                if (item.firstQuad) allListQuads.push(item.firstQuad);
-                if (item.restQuad) allListQuads.push(item.restQuad);
-            });
-            if (listData.headQuad) allListQuads.push(listData.headQuad);
-
-            // Also mark list item annotation quads as consumed
-            Array.from(base.quadIndex.entries()).forEach(([key, entry]) => {
-                const parsed = parseQuadIndexKey(key);
-                if (parsed && listData.items.some(item => item.item.value === parsed.s)) {
-                    plan.consumedAdds.add(key);
-                }
-            });
-
-            // Also mark any quads with list item subjects as consumed
-            normAdds.forEach(quad => {
-                if (listData.items.some(item => item.item.value === quad.subject.value)) {
-                    const quadKey = quadToKeyForOrigin(quad);
-                    plan.consumedAdds.add(quadKey);
-                }
-            });
-
-            allListQuads.forEach(quad => {
-                const quadKey = quadToKeyForOrigin(quad);
-                plan.consumedAdds.add(quadKey);
-            });
-        }
-    }
-
     return plan;
 }
 
@@ -596,7 +377,6 @@ function materializeEdits(plan, text, ctx, base) {
 
     // Materialize adds
     for (const { quad, targetBlock } of plan.adds) {
-        // Skip if this quad was consumed by list operations
         const quadKey = quadToKeyForOrigin(quad);
         if (plan.consumedAdds.has(quadKey)) {
             continue;
@@ -656,310 +436,9 @@ function materializeEdits(plan, text, ctx, base) {
         }
     }
 
-    // NEW: Materialize list operations
-    if (plan.listOperations) {
-        for (const listOp of plan.listOperations) {
-            const listEdits = materializeListOperation(listOp, text, ctx, base);
-            edits.push(...listEdits);
-        }
-    }
-
-    return edits;
-}
-
-function findInsertionPointForSubject(subject, text, base) {
-    // Try to find the subject's block in the origin data
-    for (const [blockId, block] of base.blocks.entries()) {
-        if (block.subject === subject && block.range) {
-            // Found the subject block, insert after it
-            return block.range.end;
-        }
-    }
-
-    // Fallback: try to find the subject in the text directly
-    const subjectShort = subject.includes('#') ? subject.split('#').pop() : subject.split('/').pop();
-    const subjectRegex = new RegExp(`##\\s+[^{]*\\{=\\s*${subjectShort.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*[^}]*\\}`, 'm');
-    const match = text.match(subjectRegex);
-
-    if (match && match.index !== undefined) {
-        // Find the end of this line
-        const lineEnd = text.indexOf('\n', match.index);
-        return lineEnd !== -1 ? lineEnd + 1 : match.index + match.length;
-    }
-
-    // Final fallback: end of document
-    return text.length;
-}
-
-function findExistingListRange(subject, text, base) {
-    // Try to find existing list items under this subject in the origin data
-    for (const [blockId, block] of base.blocks.entries()) {
-        if (block.subject === subject && block.range) {
-            // Look for ordered list items that come after this subject
-            const linesAfter = text.substring(block.range.end).split('\n');
-            let listStart = -1;
-            let listEnd = -1;
-
-            for (let i = 0; i < linesAfter.length; i++) {
-                const line = linesAfter[i].trim();
-
-                // Check if this line starts a numbered list
-                if (/^\d+\./.test(line)) {
-                    if (listStart === -1) {
-                        listStart = block.range.end + linesAfter.slice(0, i).join('\n').length + i;
-                    }
-                    listEnd = block.range.end + linesAfter.slice(0, i + 1).join('\n').length + i + 1;
-                } else if (listStart !== -1 && !line.startsWith(' ') && line !== '') {
-                    // End of list
-                    break;
-                }
-            }
-
-            if (listStart !== -1 && listEnd !== -1) {
-                return { start: listStart, end: listEnd };
-            }
-        }
-    }
-
-    return null;
-}
-
-function reconstructListFromDiff(listData, normAdds, normDeletes, base) {
-    // Start with the existing list items
-    let currentItems = [...listData.items];
-
-    // Apply deletes first - remove items that are being deleted
-    const deletedItems = new Set();
-    normDeletes.forEach(quad => {
-        // Find list items that match the delete quad
-        currentItems.forEach(item => {
-            if ((item.firstQuad && quadMatches(item.firstQuad, quad)) ||
-                (item.typeQuad && quadMatches(item.typeQuad, quad)) ||
-                (item.restQuad && quadMatches(item.restQuad, quad))) {
-                deletedItems.add(item.listNode);
-            }
-        });
-    });
-
-    // Remove deleted items
-    currentItems = currentItems.filter(item => !deletedItems.has(item.listNode));
-
-    // Apply adds - add new list items
-    normAdds.forEach(quad => {
-        if (quad.predicate.value.endsWith('#type') &&
-            quad.object.value === 'http://www.w3.org/1999/02/22-rdf-syntax-ns#List') {
-            // This is a new list node
-            const listNodeQuads = normAdds.filter(q => q.subject.value === quad.subject.value);
-            const firstQuad = listNodeQuads.find(q => q.predicate.value.endsWith('#first'));
-
-            if (firstQuad) {
-                currentItems.push({
-                    listNode: quad.subject.value,
-                    item: firstQuad.object,
-                    typeQuad: quad,
-                    firstQuad,
-                    restQuad: listNodeQuads.find(q => q.predicate.value.endsWith('#rest'))
-                });
-            }
-        }
-    });
-
-    // Apply modifications to existing items
-    normAdds.forEach(quad => {
-        currentItems.forEach(item => {
-            if (quadMatches(item.firstQuad, quad)) {
-                item.firstQuad = quad;
-                item.item = quad.object;
-            }
-        });
-    });
-
-    // Reorder by list node name to maintain some order
-    currentItems.sort((a, b) => {
-        const aNum = parseInt(a.listNode.split('-').pop()) || 0;
-        const bNum = parseInt(b.listNode.split('-').pop()) || 0;
-        return aNum - bNum;
-    });
-
-    // Reassign indices
-    currentItems.forEach((item, index) => {
-        item.itemIndex = index;
-    });
-
-    return {
-        subject: listData.subject,
-        items: currentItems,
-        headQuad: listData.headQuad
-    };
-}
-
-function quadMatches(quad1, quad2) {
-    if (!quad1 || !quad2) return false;
-    return quad1.subject.value === quad2.subject.value &&
-        quad1.predicate.value === quad2.predicate.value &&
-        quad1.object.value === quad2.object.value;
-}
-
-function materializeListOperation(listOp, text, ctx, base) {
-    const edits = [];
-    const { subject, items, operation, normAdds, normDeletes } = listOp;
-
-    switch (operation.type) {
-        case 'create':
-            // Create new ordered list
-            const listText = serializeListItems(items, ctx, base);
-            const contextText = serializeListContext(subject, ctx, base);
-
-            // Find insertion point under the correct subject
-            const insertPoint = findInsertionPointForSubject(subject, text, base);
-
-            let fullListText = '';
-            if (contextText) {
-                fullListText += '\n' + contextText;
-            }
-            fullListText += '\n' + listText.map(item => item.text).join('\n');
-
-            edits.push({
-                start: insertPoint,
-                end: insertPoint,
-                text: fullListText
-            });
-            break;
-
-        case 'modify':
-            // For modifications, find and replace the existing list entirely
-            const listData = { subject, items, headQuad: listOp.headQuad };
-            const reconstructedList = reconstructListFromDiff(listData, normAdds, normDeletes, base);
-            const modifyListText = serializeListItems(reconstructedList.items, ctx, base);
-
-            // Use the parent subject for finding the existing list
-            const parentSubject = listOp.headQuad?.subject?.value || subject;
-
-            // Find existing list range to replace
-            const existingListRange = findExistingListRange(parentSubject, text, base);
-
-            let modifyFullListText = '\n' + modifyListText.map(item => item.text).join('\n');
-
-            if (existingListRange) {
-                // Replace existing list
-                edits.push({
-                    start: existingListRange.start,
-                    end: existingListRange.end,
-                    text: modifyFullListText
-                });
-            } else {
-                // Insert after subject (fallback)
-                const modifyInsertPoint = findInsertionPointForSubject(parentSubject, text, base);
-                edits.push({
-                    start: modifyInsertPoint,
-                    end: modifyInsertPoint,
-                    text: modifyFullListText
-                });
-            }
-            break;
-
-        case 'delete':
-            // Find and delete the entire list
-            // TODO: Implement proper list range detection
-            break;
-    }
-
     return edits;
 }
 
-function serializeListItems(items, ctx, base) {
-    const serializedItems = [];
-
-    for (let i = 0; i < items.length; i++) {
-        const { item, listNode } = items[i];
-
-        // Find list item annotations (types, predicates) from origin data
-        const itemAnnotations = [];
-
-        // Find type annotations for this list item
-        Array.from(base.quadIndex.entries()).forEach(([key, entry]) => {
-            const parsed = parseQuadIndexKey(key);
-            if (parsed?.s === item.value &&
-                parsed?.p.endsWith('#type') &&
-                entry.type === 'list-anchor-type') {
-                itemAnnotations.push({
-                    type: 'type',
-                    iri: parsed.o.v,
-                    range: entry.range
-                });
-            }
-        });
-
-        // Find predicate annotations for this list item  
-        Array.from(base.quadIndex.entries()).forEach(([key, entry]) => {
-            const parsed = parseQuadIndexKey(key);
-            if (parsed?.s === item.value &&
-                entry.type === 'list-anchor-predicate') {
-                itemAnnotations.push({
-                    type: 'predicate',
-                    iri: parsed.p,
-                    value: parsed.o.v,
-                    range: entry.range
-                });
-            }
-        });
-
-        // Serialize the list item as proper ordered list syntax
-        let itemText = `${i + 1}. `;
-
-        if (item.termType === 'NamedNode') {
-            const itemShort = shortenIRI(item.value, ctx);
-            itemText += `${itemShort}`;
-
-            // Add subject annotation if we have one
-            itemText += ` {=${itemShort}}`;
-        } else {
-            itemText += item.value;
-        }
-
-        // Add list anchor annotations
-        const annotationTokens = [];
-        for (const ann of itemAnnotations) {
-            if (ann.type === 'type') {
-                const typeShort = shortenIRI(ann.iri, ctx);
-                annotationTokens.push(`.${typeShort}`);
-            } else if (ann.type === 'predicate') {
-                const predShort = shortenIRI(ann.iri, ctx);
-                annotationTokens.push(predShort);
-            }
-        }
-
-        if (annotationTokens.length > 0) {
-            itemText += ` {${annotationTokens.join(' ')}}`;
-        }
-
-        serializedItems.push({
-            text: itemText,
-            listNode,
-            item,
-            annotations: itemAnnotations
-        });
-    }
-
-    return serializedItems;
-}
-
-function serializeListContext(listSubject, ctx, base) {
-    // Find context quads for this list
-    const contextQuads = Array.from(base.quadIndex.entries())
-        .filter(([key, entry]) => {
-            const parsed = parseQuadIndexKey(key);
-            return parsed?.s === listSubject &&
-                parsed?.p.endsWith('#in');
-        });
-
-    if (contextQuads.length === 0) return null;
-
-    // For now, return a generic context
-    // TODO: Reconstruct actual context text from origin data
-    return "Status values: {?sh:in .ex:StatusType label}";
-}
-
 function applyEdits(text, edits, ctx, base) {
     let result = text;