@blackwell-systems/gcf 2.1.2 → 2.2.1

package/README.md

@@ -8,7 +8,7 @@
 
 TypeScript implementation of [GCF](https://gcformat.com/) — the most token-efficient wire format for LLMs. A drop-in alternative to JSON and TOON for any structured data.
 
-**100% comprehension on every frontier model tested. 25.5% fewer tokens than TOON, 53% fewer than JSON across 15 datasets. 90.7% on structurally complex code graphs (vs TOON 68.5%, JSON 53.6%). 1,700+ LLM evaluations. Zero training.**
+**100% comprehension on every frontier model tested. 29% fewer tokens than TOON, 56% fewer than JSON across 16 datasets. 91.2% on structurally complex code graphs (vs TOON 68.2%, JSON 53.4%). 2,400+ LLM evaluations. Zero training.**
 
 Docs: [gcformat.com](https://gcformat.com/) · [Playground](https://gcformat.com/playground.html) · [GCF vs TOON](https://gcformat.com/guide/vs-toon.html)
 
@@ -192,16 +192,16 @@ Works on objects, arrays, and primitives. Arrays of uniform objects get tabular
 
 ## Benchmarks
 
-1,700+ LLM evaluations across 10 models, 3 providers, and 51 independent test runs.
+2,400+ LLM evaluations across 10 models, 3 providers, and 51 independent test runs.
 
 | | GCF | TOON | JSON |
 |---|---|---|---|
-| **Comprehension** (23 runs, 10 models) | **90.7%** | 68.5% | 53.6% |
+| **Comprehension** (23 runs, 10 models) | **91.2%** | 68.2% | 53.4% |
 | **Generation** (28 runs, 9 models) | **5/5** | 1.0/5 | 5.0/5 |
 | **Input tokens** (500 symbols) | **11,090** | 16,378 | 53,341 |
 | **Output tokens** (100 symbols) | **5,976** | 8,937 | 16,121 |
 
-GCF wins 13/15 datasets on the expanded [token efficiency benchmark](https://github.com/blackwell-systems/toon/tree/gcf-comparison). Full results: [gcformat.com/guide/benchmarks](https://gcformat.com/guide/benchmarks.html)
+GCF wins 15/16 datasets on the expanded [token efficiency benchmark](https://github.com/blackwell-systems/toon/tree/gcf-comparison). Full results: [gcformat.com/guide/benchmarks](https://gcformat.com/guide/benchmarks.html)
 
 ## Implementations
 
@@ -220,9 +220,9 @@ GCF wins 13/15 datasets on the expanded [token efficiency benchmark](https://git
 | n8n | `npm install n8n-nodes-gcf` | [gcf-n8n-nodes](https://github.com/blackwell-systems/gcf-n8n-nodes) (workflow encode/decode) |
 | Tree-sitter | `npm install tree-sitter-gcf` | [tree-sitter-gcf](https://github.com/blackwell-systems/tree-sitter-gcf) |
 
-Zero runtime dependencies. MIT licensed. All implementations support both generic profile (`encodeGeneric`) and graph profile (`encode`). CLI included in all 6 languages.
+**Zero runtime dependencies. Permanently.** All six implementations depend only on their language's standard library. No transitive dependencies. No supply chain risk. This is a permanent commitment: GCF will never take on external runtime dependencies. MIT licensed. All implementations support both generic profile (`encodeGeneric`) and graph profile (`encode`). CLI included in all 6 languages.
 
-**Specification:** [SPEC v3.1 Stable](https://github.com/blackwell-systems/gcf/blob/main/SPEC.md) with 157 conformance fixtures, 33,000,000,000+ lossless round-trips verified across 5 formats and 6 languages. All implementations at v2.1.0+ (Go v1.2.0). Cross-language 6x6 matrix verified.
+**Specification:** [SPEC v3.2 Stable](https://github.com/blackwell-systems/gcf/blob/main/SPEC.md) with 173 conformance fixtures, 43,000,000,000+ lossless round-trips verified across 5 formats and 6 languages. All implementations at v2.2.0+ (Go v1.3.0). Cross-language 6x6 matrix verified.
 
 ## License
 

package/dist/cjs/index.cjs

@@ -790,30 +790,30 @@ function verifyDelta(baseSymbols, baseEdges, removedSymbols, addedSymbols, remov
 function indent(depth) {
   return "  ".repeat(depth);
 }
-function encodeGeneric(data) {
+function encodeGeneric(data, opts) {
   let out = "GCF profile=generic\n";
-  out += encodeRootValue(data);
+  out += encodeRootValue(data, opts);
   return out;
 }
-function encodeRootValue(v) {
+function encodeRootValue(v, opts) {
   if (v === null || v === void 0) return "=-\n";
-  if (Array.isArray(v)) return encodeRootArray(v);
-  if (typeof v === "object") return encodeObject(v, 0);
+  if (Array.isArray(v)) return encodeRootArray(v, opts);
+  if (typeof v === "object") return encodeObject(v, 0, opts);
   return `=${formatScalar(v, 0)}
 `;
 }
-function encodeObject(obj, depth) {
+function encodeObject(obj, depth, opts) {
   const prefix = indent(depth);
   let out = "";
   for (const key of Object.keys(obj)) {
     const value = obj[key];
     const fk = formatKey(key);
     if (Array.isArray(value)) {
-      out += encodeNamedArray(fk, value, depth);
+      out += encodeNamedArray(fk, value, depth, opts);
     } else if (typeof value === "object" && value !== null) {
       out += `${prefix}## ${fk}
 `;
-      out += encodeObject(value, depth + 1);
+      out += encodeObject(value, depth + 1, opts);
     } else {
       out += `${prefix}${fk}=${formatScalar(value, 0)}
 `;
@@ -821,7 +821,7 @@ function encodeObject(obj, depth) {
   }
   return out;
 }
-function encodeRootArray(arr) {
+function encodeRootArray(arr, opts) {
   if (arr.length === 0) return "## [0]\n";
   if (allPrimitives(arr)) {
     const vals = arr.map((v) => formatScalar(v, 44));
@@ -829,10 +829,10 @@ function encodeRootArray(arr) {
 `;
   }
   const fields = tabularFields(arr);
-  if (fields) return encodeTabular("## ", arr, fields, 0);
-  return encodeExpanded("## ", arr, 0);
+  if (fields) return encodeTabular("## ", arr, fields, 0, opts);
+  return encodeExpanded("## ", arr, 0, opts);
 }
-function encodeNamedArray(name, arr, depth) {
+function encodeNamedArray(name, arr, depth, opts) {
   const prefix = indent(depth);
   if (arr.length === 0) return `${prefix}## ${name} [0]
 `;
@@ -842,8 +842,8 @@ function encodeNamedArray(name, arr, depth) {
 `;
   }
   const fields = tabularFields(arr);
-  if (fields) return encodeTabular(`${prefix}## ${name} `, arr, fields, depth);
-  return encodeExpanded(`${prefix}## ${name} `, arr, depth);
+  if (fields) return encodeTabular(`${prefix}## ${name} `, arr, fields, depth, opts);
+  return encodeExpanded(`${prefix}## ${name} `, arr, depth, opts);
 }
 function tabularFields(arr) {
   if (arr.length === 0) return null;
@@ -918,25 +918,161 @@ function sharedArraySchema(arr, fieldName) {
   }
   return canonicalFields;
 }
-function encodeTabular(headerPrefix, arr, fields, depth) {
+function analyzeFlattenable(arr, fieldName, parentPath) {
+  if (fieldName.includes(">")) return null;
+  let canonicalShape = null;
+  for (const item of arr) {
+    const obj = item;
+    if (!(fieldName in obj) || obj[fieldName] === null || obj[fieldName] === void 0) continue;
+    const v = obj[fieldName];
+    if (typeof v !== "object" || Array.isArray(v)) return null;
+    const keys = Object.keys(v);
+    if (!canonicalShape) {
+      canonicalShape = {};
+      for (const k of keys) {
+        if (k.includes(">")) return null;
+        const val = v[k];
+        if (val !== null && val !== void 0 && typeof val === "object" && !Array.isArray(val)) {
+          canonicalShape[k] = "nested";
+        } else if (Array.isArray(val)) {
+          return null;
+        } else {
+          canonicalShape[k] = "scalar";
+        }
+      }
+    } else {
+      if (keys.length !== Object.keys(canonicalShape).length) return null;
+      for (const k of keys) {
+        if (!(k in canonicalShape)) return null;
+        const val = v[k];
+        const expected = canonicalShape[k];
+        if (expected === "scalar") {
+          if (val !== null && val !== void 0 && typeof val === "object") return null;
+        } else if (expected === "nested") {
+          if (val !== null && val !== void 0) {
+            if (typeof val !== "object" || Array.isArray(val)) return null;
+          }
+        }
+      }
+    }
+  }
+  if (!canonicalShape) return null;
+  const currentPath = parentPath ? parentPath + ">" + fieldName : fieldName;
+  const parentKeys = parentPath ? [...parentPath.split(">"), fieldName] : [fieldName];
+  const leaves = [];
+  for (const k of Object.keys(canonicalShape)) {
+    if (canonicalShape[k] === "scalar") {
+      leaves.push({ path: currentPath + ">" + k, keys: [...parentKeys, k] });
+    } else {
+      const subArr = arr.map((item) => {
+        const obj = item;
+        if (!(fieldName in obj) || obj[fieldName] === null || obj[fieldName] === void 0) return {};
+        return obj[fieldName];
+      });
+      const subLeaves = analyzeFlattenable(subArr, k, currentPath);
+      if (!subLeaves || subLeaves.length === 0) return null;
+      leaves.push(...subLeaves);
+    }
+  }
+  if (leaves.length > 0) {
+    for (const item of arr) {
+      const obj = item;
+      if (!(fieldName in obj) || obj[fieldName] === null || obj[fieldName] === void 0) continue;
+      const allNull = leaves.every((leaf) => {
+        const val = resolveKeyChain(item, leaf.keys);
+        return val.exists && val.value === null;
+      });
+      if (allNull) return null;
+    }
+  }
+  return leaves;
+}
+function resolveKeyChain(item, keys) {
+  if (keys.length === 0) return { value: void 0, exists: false };
+  const obj = item;
+  if (typeof obj !== "object" || obj === null) return { value: void 0, exists: false };
+  if (!(keys[0] in obj)) return { value: void 0, exists: false };
+  let current = obj[keys[0]];
+  if (current === null || current === void 0) return { value: current, exists: true };
+  for (let i = 1; i < keys.length; i++) {
+    if (typeof current !== "object" || current === null) return { value: void 0, exists: false };
+    const c = current;
+    if (!(keys[i] in c)) return { value: void 0, exists: false };
+    current = c[keys[i]];
+  }
+  return { value: current, exists: true };
+}
+function encodeTabular(headerPrefix, arr, fields, depth, opts) {
   const prefix = indent(depth);
+  const flattenMap = /* @__PURE__ */ new Map();
+  if (!opts?.noFlatten) {
+    for (const f of fields) {
+      const leaves = analyzeFlattenable(arr, f, "");
+      if (leaves && leaves.length > 0) {
+        flattenMap.set(f, leaves);
+      }
+    }
+  }
+  const gtFields = /* @__PURE__ */ new Set();
+  for (const f of fields) {
+    if (!flattenMap.has(f) && f.includes(">")) {
+      gtFields.add(f);
+    }
+  }
+  const columns = [];
+  for (const f of fields) {
+    if (gtFields.has(f)) continue;
+    const leaves = flattenMap.get(f);
+    if (leaves) {
+      for (const leaf of leaves) {
+        columns.push({ headerName: formatKey(leaf.path), colType: "flat", field: f, keys: leaf.keys });
+      }
+    } else {
+      columns.push({ headerName: formatKey(f), colType: "original", field: f, keys: [] });
+    }
+  }
+  if (columns.length === 0) {
+    return encodeExpanded(headerPrefix, arr, depth, opts);
+  }
   const inlineSchemas = /* @__PURE__ */ new Map();
   const sharedArrSchemas = /* @__PURE__ */ new Map();
   for (const f of fields) {
+    if (flattenMap.has(f)) continue;
     const ifs = inlineSchemaFields(arr, f);
     if (ifs) inlineSchemas.set(f, ifs);
     const sas = sharedArraySchema(arr, f);
     if (sas) sharedArrSchemas.set(f, sas);
   }
-  const fmtFields = fields.map((f) => formatKey(f));
-  let out = `${headerPrefix}[${arr.length}]{${fmtFields.join(",")}}
+  const headerFields = columns.map((c) => c.headerName);
+  let out = `${headerPrefix}[${arr.length}]{${headerFields.join(",")}}
 `;
   for (let i = 0; i < arr.length; i++) {
     const obj = arr[i];
     const cells = [];
     const attachments = [];
     let rowHasAttachment = false;
-    for (const f of fields) {
+    for (const col of columns) {
+      if (col.colType === "flat") {
+        if (!(col.keys[0] in obj)) {
+          cells.push("~");
+        } else {
+          const topVal = obj[col.keys[0]];
+          if (topVal === null || topVal === void 0) {
+            cells.push(topVal === null ? "-" : "~");
+          } else {
+            const resolved = resolveKeyChain(obj, col.keys);
+            if (!resolved.exists) {
+              cells.push("~");
+            } else if (resolved.value === null || resolved.value === void 0) {
+              cells.push("-");
+            } else {
+              cells.push(formatScalar(resolved.value, 124));
+            }
+          }
+        }
+        continue;
+      }
+      const f = col.field;
       if (!(f in obj)) {
         cells.push("~");
         continue;
@@ -965,6 +1101,13 @@ function encodeTabular(headerPrefix, arr, fields, depth) {
         cells.push(formatScalar(v, 124));
       }
     }
+    for (const f of fields) {
+      if (!gtFields.has(f)) continue;
+      const obj2 = arr[i];
+      if (!(f in obj2)) continue;
+      rowHasAttachment = true;
+      attachments.push({ name: f, value: obj2[f], inline: false });
+    }
     const row = cells.join("|");
     if (rowHasAttachment) {
       out += `${prefix}@${i} ${row}
@@ -986,20 +1129,28 @@ function encodeTabular(headerPrefix, arr, fields, depth) {
       } else if (Array.isArray(att.value)) {
         const sas = sharedArrSchemas.get(att.name);
         if (sas && i > 0) {
-          out += encodeAttachmentArrayShared(prefix, fk, att.value, depth + 2, sas);
+          out += encodeAttachmentArrayShared(prefix, fk, att.value, depth + 2, sas, opts);
         } else {
-          out += encodeAttachmentArray(prefix, fk, att.value, depth + 2);
+          out += encodeAttachmentArray(prefix, fk, att.value, depth + 2, opts);
         }
-      } else {
+      } else if (typeof att.value === "object" && att.value !== null) {
         out += `${prefix}.${fk} {}
 `;
-        out += encodeObject(att.value, depth + 2);
+        out += encodeObject(att.value, depth + 2, opts);
+      } else {
+        if (att.value === null || att.value === void 0) {
+          out += `${prefix}.${fk} =-
+`;
+        } else {
+          out += `${prefix}.${fk} =${formatScalar(att.value, 0)}
+`;
+        }
       }
     }
   }
   return out;
 }
-function encodeAttachmentArray(attPrefix, fk, arr, depth) {
+function encodeAttachmentArray(attPrefix, fk, arr, depth, opts) {
   if (arr.length === 0) return `${attPrefix}.${fk} [0]
 `;
   if (allPrimitives(arr)) {
@@ -1008,10 +1159,10 @@ function encodeAttachmentArray(attPrefix, fk, arr, depth) {
 `;
   }
   const fields = tabularFields(arr);
-  if (fields) return encodeTabular(`${attPrefix}.${fk} `, arr, fields, depth);
-  return encodeExpanded(`${attPrefix}.${fk} `, arr, depth);
+  if (fields) return encodeTabular(`${attPrefix}.${fk} `, arr, fields, depth, opts);
+  return encodeExpanded(`${attPrefix}.${fk} `, arr, depth, opts);
 }
-function encodeAttachmentArrayShared(attPrefix, fk, arr, depth, sharedFields) {
+function encodeAttachmentArrayShared(attPrefix, fk, arr, depth, sharedFields, opts) {
   if (arr.length === 0) return `${attPrefix}.${fk} [0]
 `;
   if (allPrimitives(arr)) {
@@ -1036,20 +1187,20 @@ function encodeAttachmentArrayShared(attPrefix, fk, arr, depth, sharedFields) {
     }
     return out;
   }
-  return encodeAttachmentArray(attPrefix, fk, arr, depth);
+  return encodeAttachmentArray(attPrefix, fk, arr, depth, opts);
 }
-function encodeExpanded(headerPrefix, arr, depth) {
+function encodeExpanded(headerPrefix, arr, depth, opts) {
   const prefix = indent(depth);
   let out = `${headerPrefix}[${arr.length}]
 `;
   for (let i = 0; i < arr.length; i++) {
     const item = arr[i];
     if (Array.isArray(item)) {
-      out += encodeExpandedArrayItem(prefix, i, item, depth);
+      out += encodeExpandedArrayItem(prefix, i, item, depth, opts);
     } else if (typeof item === "object" && item !== null) {
       out += `${prefix}@${i} {}
 `;
-      out += encodeObject(item, depth + 1);
+      out += encodeObject(item, depth + 1, opts);
     } else {
       out += `${prefix}@${i} =${formatScalar(item, 0)}
 `;
@@ -1057,7 +1208,7 @@ function encodeExpanded(headerPrefix, arr, depth) {
   }
   return out;
 }
-function encodeExpandedArrayItem(prefix, idx, arr, depth) {
+function encodeExpandedArrayItem(prefix, idx, arr, depth, opts) {
   if (arr.length === 0) return `${prefix}@${idx} [0]
 `;
   if (allPrimitives(arr)) {
@@ -1066,8 +1217,8 @@ function encodeExpandedArrayItem(prefix, idx, arr, depth) {
 `;
   }
   const fields = tabularFields(arr);
-  if (fields) return encodeTabular(`${prefix}@${idx} `, arr, fields, depth + 1);
-  return encodeExpanded(`${prefix}@${idx} `, arr, depth + 1);
+  if (fields) return encodeTabular(`${prefix}@${idx} `, arr, fields, depth + 1, opts);
+  return encodeExpanded(`${prefix}@${idx} `, arr, depth + 1, opts);
 }
 function allPrimitives(arr) {
   return arr.every((v) => typeof v !== "object" || v === null);
@@ -1295,10 +1446,59 @@ function findClosingBrace2(s) {
   }
   return -1;
 }
+function unflattenPaths(pathColumns, flatValues, flatAbsent) {
+  const groups = /* @__PURE__ */ new Map();
+  const groupOrder = [];
+  for (const [fieldName, paths] of pathColumns) {
+    if (paths.length === 0) continue;
+    const top = paths[0];
+    if (!groups.has(top)) {
+      groups.set(top, []);
+      groupOrder.push(top);
+    }
+    groups.get(top).push(fieldName);
+  }
+  const result = {};
+  for (const top of groupOrder) {
+    const fieldNames = groups.get(top);
+    const allAbsent = fieldNames.every((f) => flatAbsent.has(f));
+    const allNull = fieldNames.every((f) => {
+      if (flatAbsent.has(f)) return false;
+      const val = flatValues.get(f);
+      return val === null;
+    });
+    if (allAbsent) continue;
+    if (allNull) {
+      result[top] = null;
+      continue;
+    }
+    for (const fieldName of fieldNames) {
+      if (flatAbsent.has(fieldName)) continue;
+      const paths = pathColumns.get(fieldName);
+      const val = flatValues.has(fieldName) ? flatValues.get(fieldName) : null;
+      let current = result;
+      for (let k = 0; k < paths.length - 1; k++) {
+        if (!(paths[k] in current)) current[paths[k]] = {};
+        current = current[paths[k]];
+      }
+      current[paths[paths.length - 1]] = val;
+    }
+  }
+  return result;
+}
 function parseTabularBody(lines, start, depth, fields, expectedCount) {
   const ind = "  ".repeat(depth);
   const rows = [];
   let i = start;
+  const pathColumnMap = /* @__PURE__ */ new Map();
+  for (const f of fields) {
+    if (f.includes(">")) {
+      const parts = f.split(">");
+      if (parts.every((p) => p.length > 0)) {
+        pathColumnMap.set(f, parts);
+      }
+    }
+  }
   const inlineSchemas = /* @__PURE__ */ new Map();
   const sharedArraySchemas = /* @__PURE__ */ new Map();
   while (i < lines.length) {
@@ -1330,8 +1530,19 @@ function parseTabularBody(lines, start, depth, fields, expectedCount) {
     const inlineAttFields = [];
     const inlineAttOrder = [];
     const missingFields = /* @__PURE__ */ new Set();
+    const flatValues = /* @__PURE__ */ new Map();
+    const flatAbsent = /* @__PURE__ */ new Set();
     for (let j = 0; j < fields.length; j++) {
       const cellVal = vals[j];
+      if (pathColumnMap.has(fields[j])) {
+        const parsed2 = parseScalar(cellVal, true);
+        if (parsed2 === MISSING) {
+          flatAbsent.add(fields[j]);
+        } else {
+          flatValues.set(fields[j], parsed2);
+        }
+        continue;
+      }
       if (cellVal.startsWith("^{") && cellVal.endsWith("}")) {
         const schemaStr = cellVal.slice(1);
         const ifs = splitFieldDecl(schemaStr);
@@ -1366,9 +1577,9 @@ function parseTabularBody(lines, start, depth, fields, expectedCount) {
     i++;
     const allAttFields = [...traditionalAttFields, ...inlineAttFields];
     const attachmentValues = /* @__PURE__ */ new Map();
-    if (rowHasID && allAttFields.length > 0) {
+    if (rowHasID) {
       let inlineIdx = 0;
-      while (i < lines.length && attachmentValues.size < allAttFields.length) {
+      while (i < lines.length) {
         const aLine = lines[i];
         let aContent = null;
         if (depth === 0 || aLine.startsWith(ind)) {
@@ -1467,11 +1678,13 @@ function parseTabularBody(lines, start, depth, fields, expectedCount) {
         continue;
       }
     }
-    if (!rowHasID || allAttFields.length === 0) {
-      const attIndent = ind + "  ";
-      if (i < lines.length && lines[i].startsWith(attIndent)) {
-        const peek = lines[i].slice(attIndent.length);
-        if (peek.startsWith(".")) throw new Error(`orphan_attachment: ${peek}`);
+    for (const [k, v] of attachmentValues) {
+      if (!(k in row)) row[k] = v;
+    }
+    if (pathColumnMap.size > 0) {
+      const nested = unflattenPaths(pathColumnMap, flatValues, flatAbsent);
+      for (const [k, v] of Object.entries(nested)) {
+        row[k] = v;
       }
     }
     rows.push(row);
@@ -1549,6 +1762,12 @@ function parseAttachment(lines, lineIdx, rest, depth, sharedSchemas) {
     const [arr, consumed] = parseArrayFromHeader(lines, lineIdx, depth, afterName);
     return [name, arr, consumed, null];
   }
+  if (afterName.startsWith("=")) {
+    const valStr = afterName.slice(1);
+    const parsed = parseScalar(valStr, true);
+    if (parsed === MISSING) return [name, null, 1, null];
+    return [name, parsed, 1, null];
+  }
   throw new Error(`invalid attachment form: ${afterName}`);
 }
 function parseExpandedBody(lines, start, depth) {

package/dist/decode_generic.js

@@ -271,10 +271,68 @@ function findClosingBrace(s) {
     }
     return -1;
 }
+function unflattenPaths(pathColumns, flatValues, flatAbsent) {
+    // Group by top-level parent.
+    const groups = new Map();
+    const groupOrder = [];
+    for (const [fieldName, paths] of pathColumns) {
+        if (paths.length === 0)
+            continue;
+        const top = paths[0];
+        if (!groups.has(top)) {
+            groups.set(top, []);
+            groupOrder.push(top);
+        }
+        groups.get(top).push(fieldName);
+    }
+    const result = {};
+    for (const top of groupOrder) {
+        const fieldNames = groups.get(top);
+        const allAbsent = fieldNames.every(f => flatAbsent.has(f));
+        const allNull = fieldNames.every(f => {
+            if (flatAbsent.has(f))
+                return false;
+            const val = flatValues.get(f);
+            return val === null;
+        });
+        if (allAbsent)
+            continue;
+        if (allNull) {
+            result[top] = null;
+            continue;
+        }
+        for (const fieldName of fieldNames) {
+            if (flatAbsent.has(fieldName))
+                continue;
+            const paths = pathColumns.get(fieldName);
+            const val = flatValues.has(fieldName) ? flatValues.get(fieldName) : null;
+            let current = result;
+            for (let k = 0; k < paths.length - 1; k++) {
+                if (!(paths[k] in current))
+                    current[paths[k]] = {};
+                current = current[paths[k]];
+            }
+            current[paths[paths.length - 1]] = val;
+        }
+    }
+    return result;
+}
 function parseTabularBody(lines, start, depth, fields, expectedCount) {
     const ind = '  '.repeat(depth);
     const rows = [];
     let i = start;
+    // Detect path columns: fields containing ">".
+    const pathColumnMap = new Map();
+    for (const f of fields) {
+        if (f.includes('>')) {
+            const parts = f.split('>');
+            // Only treat as a path column if all segments are non-empty.
+            // A literal key like ">" would split into ["", ""].
+            if (parts.every(p => p.length > 0)) {
+                pathColumnMap.set(f, parts);
+            }
+        }
+    }
     // Track inline schemas and shared array schemas.
     const inlineSchemas = new Map();
     const sharedArraySchemas = new Map();
@@ -313,8 +371,22 @@ function parseTabularBody(lines, start, depth, fields, expectedCount) {
         const inlineAttFields = [];
         const inlineAttOrder = [];
         const missingFields = new Set();
+        // Collect path column values for unflattening.
+        const flatValues = new Map();
+        const flatAbsent = new Set();
         for (let j = 0; j < fields.length; j++) {
             const cellVal = vals[j];
+            // Path columns: store values for later unflattening.
+            if (pathColumnMap.has(fields[j])) {
+                const parsed = parseScalar(cellVal, true);
+                if (parsed === MISSING) {
+                    flatAbsent.add(fields[j]);
+                }
+                else {
+                    flatValues.set(fields[j], parsed);
+                }
+                continue;
+            }
             // Check for ^{fields} inline schema declaration.
             if (cellVal.startsWith('^{') && cellVal.endsWith('}')) {
                 const schemaStr = cellVal.slice(1);
@@ -354,9 +426,9 @@ function parseTabularBody(lines, start, depth, fields, expectedCount) {
         // Parse attachments in line order.
         const allAttFields = [...traditionalAttFields, ...inlineAttFields];
         const attachmentValues = new Map();
-        if (rowHasID && allAttFields.length > 0) {
+        if (rowHasID) {
             let inlineIdx = 0;
-            while (i < lines.length && attachmentValues.size < allAttFields.length) {
+            while (i < lines.length) {
                 const aLine = lines[i];
                 let aContent = null;
                 if (depth === 0 || aLine.startsWith(ind)) {
@@ -476,12 +548,16 @@ function parseTabularBody(lines, start, depth, fields, expectedCount) {
                 continue;
             }
         }
-        if (!rowHasID || allAttFields.length === 0) {
-            const attIndent = ind + '  ';
-            if (i < lines.length && lines[i].startsWith(attIndent)) {
-                const peek = lines[i].slice(attIndent.length);
-                if (peek.startsWith('.'))
-                    throw new Error(`orphan_attachment: ${peek}`);
+        // Also add any orphan attachment values (fields excluded from column list, e.g. ">" fields).
+        for (const [k, v] of attachmentValues) {
+            if (!(k in row))
+                row[k] = v;
+        }
+        // Unflatten path columns into nested objects.
+        if (pathColumnMap.size > 0) {
+            const nested = unflattenPaths(pathColumnMap, flatValues, flatAbsent);
+            for (const [k, v] of Object.entries(nested)) {
+                row[k] = v;
             }
         }
         rows.push(row);
@@ -574,6 +650,14 @@ function parseAttachment(lines, lineIdx, rest, depth, sharedSchemas) {
         const [arr, consumed] = parseArrayFromHeader(lines, lineIdx, depth, afterName);
         return [name, arr, consumed, null];
     }
+    // Scalar: =value (field names containing ">" excluded from tabular columns).
+    if (afterName.startsWith('=')) {
+        const valStr = afterName.slice(1);
+        const parsed = parseScalar(valStr, true);
+        if (parsed === MISSING)
+            return [name, null, 1, null];
+        return [name, parsed, 1, null];
+    }
     throw new Error(`invalid attachment form: ${afterName}`);
 }
 function parseExpandedBody(lines, start, depth) {