@blackwell-systems/gcf 2.1.2 → 2.2.1

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAClF,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC1D,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEtD,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC5F,OAAO,EAAE,aAAa,EAAE,KAAK,YAAY,EAAE,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AACnF,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAClF,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC1D,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEtD,OAAO,EAAE,aAAa,EAAE,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC5F,OAAO,EAAE,aAAa,EAAE,KAAK,YAAY,EAAE,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AACnF,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC1D,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACtD,sIAAsI;AACtI,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC5F,OAAO,EAAE,aAAa,EAAyC,MAAM,aAAa,CAAC;AACnF,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC1D,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACtD,sIAAsI;AACtI,OAAO,EAAE,aAAa,EAAuB,MAAM,cAAc,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC5F,OAAO,EAAE,aAAa,EAAyC,MAAM,aAAa,CAAC;AACnF,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@blackwell-systems/gcf",
-  "version": "2.1.2",
-  "description": "Drop-in JSON replacement for AI pipelines. 79% fewer tokens. 90.7% comprehension across 10 models. Zero dependencies.",
+  "version": "2.2.1",
+  "description": "The AI-native wire format for structured data. 50-92% fewer tokens than JSON. 100% comprehension on every frontier model. Zero dependencies.",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/decode_generic.ts

@@ -258,11 +258,73 @@ function findClosingBrace(s: string): number {
   return -1;
 }
 
+function unflattenPaths(
+  pathColumns: Map<string, string[]>,
+  flatValues: Map<string, any>,
+  flatAbsent: Set<string>,
+): Record<string, any> {
+  // Group by top-level parent.
+  const groups = new Map<string, string[]>();
+  const groupOrder: string[] = [];
+  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: Record<string, any> = {};
+
+  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: string[], start: number, depth: number, fields: string[], expectedCount: number): [any[], number] {
   const ind = '  '.repeat(depth);
   const rows: any[] = [];
   let i = start;
 
+  // Detect path columns: fields containing ">".
+  const pathColumnMap = new Map<string, string[]>();
+  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<string, string[]>();
   const sharedArraySchemas = new Map<string, string[]>();
@@ -303,9 +365,24 @@ function parseTabularBody(lines: string[], start: number, depth: number, fields:
     const inlineAttOrder: string[] = [];
     const missingFields = new Set<string>();
 
+    // Collect path column values for unflattening.
+    const flatValues = new Map<string, any>();
+    const flatAbsent = new Set<string>();
+
     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);
@@ -344,10 +421,10 @@ function parseTabularBody(lines: string[], start: number, depth: number, fields:
     const allAttFields = [...traditionalAttFields, ...inlineAttFields];
     const attachmentValues = new Map<string, any>();
 
-    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: string | null = null;
         if (depth === 0 || aLine.startsWith(ind)) {
@@ -459,11 +536,16 @@ function parseTabularBody(lines: string[], start: number, depth: number, fields:
       if (attachmentValues.has(f)) { row[f] = attachmentValues.get(f); 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;
       }
     }
 
@@ -553,6 +635,14 @@ function parseAttachment(lines: string[], lineIdx: number, rest: string, depth:
     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}`);
 }
 

package/src/generic.ts

@@ -7,30 +7,39 @@ function indent(depth: number): string {
   return '  '.repeat(depth);
 }
 
-export function encodeGeneric(data: unknown): string {
+/** Options for controlling generic encoding behavior. */
+export interface GenericOptions {
+  /** When true, disables promotion of fixed-shape nested objects to path
+   *  columns (e.g. "customer>name"). Nested objects use attachment syntax
+   *  instead. Set when targeting open-weight models that show lower
+   *  comprehension on flattened encoding. */
+  noFlatten?: boolean;
+}
+
+export function encodeGeneric(data: unknown, opts?: GenericOptions): string {
   let out = 'GCF profile=generic\n';
-  out += encodeRootValue(data);
+  out += encodeRootValue(data, opts);
   return out;
 }
 
-function encodeRootValue(v: unknown): string {
+function encodeRootValue(v: unknown, opts?: GenericOptions): string {
   if (v === null || v === undefined) return '=-\n';
-  if (Array.isArray(v)) return encodeRootArray(v);
-  if (typeof v === 'object') return encodeObject(v as Record<string, unknown>, 0);
+  if (Array.isArray(v)) return encodeRootArray(v, opts);
+  if (typeof v === 'object') return encodeObject(v as Record<string, unknown>, 0, opts);
   return `=${formatScalar(v, 0)}\n`;
 }
 
-function encodeObject(obj: Record<string, unknown>, depth: number): string {
+function encodeObject(obj: Record<string, unknown>, depth: number, opts?: GenericOptions): string {
   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}\n`;
-      out += encodeObject(value as Record<string, unknown>, depth + 1);
+      out += encodeObject(value as Record<string, unknown>, depth + 1, opts);
     } else {
       out += `${prefix}${fk}=${formatScalar(value, 0)}\n`;
     }
@@ -38,18 +47,18 @@ function encodeObject(obj: Record<string, unknown>, depth: number): string {
   return out;
 }
 
-function encodeRootArray(arr: unknown[]): string {
+function encodeRootArray(arr: unknown[], opts?: GenericOptions): string {
   if (arr.length === 0) return '## [0]\n';
   if (allPrimitives(arr)) {
     const vals = arr.map(v => formatScalar(v, 0x2c));
     return `## [${arr.length}]: ${vals.join(',')}\n`;
   }
   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: string, arr: unknown[], depth: number): string {
+function encodeNamedArray(name: string, arr: unknown[], depth: number, opts?: GenericOptions): string {
   const prefix = indent(depth);
   if (arr.length === 0) return `${prefix}## ${name} [0]\n`;
   if (allPrimitives(arr)) {
@@ -57,8 +66,8 @@ function encodeNamedArray(name: string, arr: unknown[], depth: number): string {
     return `${prefix}${name}[${arr.length}]: ${vals.join(',')}\n`;
   }
   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: unknown[]): string[] | null {
@@ -141,21 +150,169 @@ function sharedArraySchema(arr: unknown[], fieldName: string): string[] | null {
   return canonicalFields;
 }
 
-function encodeTabular(headerPrefix: string, arr: unknown[], fields: string[], depth: number): string {
+// ── Nested object flattening (v3.2) ──────────────────────────────────────
+
+interface FlatLeaf {
+  path: string;     // ">" separated path (e.g. "customer>name")
+  keys: string[];   // key chain to traverse from row object
+}
+
+function analyzeFlattenable(arr: unknown[], fieldName: string, parentPath: string): FlatLeaf[] | null {
+  // Field names containing ">" cannot be flattened (would create ambiguous paths).
+  if (fieldName.includes('>')) return null;
+  let canonicalShape: Record<string, 'scalar' | 'nested'> | null = null;
+
+  for (const item of arr) {
+    const obj = item as Record<string, unknown>;
+    if (!(fieldName in obj) || obj[fieldName] === null || obj[fieldName] === undefined) continue;
+    const v = obj[fieldName];
+    if (typeof v !== 'object' || Array.isArray(v)) return null;
+
+    const keys = Object.keys(v as Record<string, unknown>);
+
+    if (!canonicalShape) {
+      canonicalShape = {};
+      for (const k of keys) {
+        if (k.includes('>')) return null;
+        const val = (v as Record<string, unknown>)[k];
+        if (val !== null && val !== undefined && 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 as Record<string, unknown>)[k];
+        const expected = canonicalShape[k];
+        if (expected === 'scalar') {
+          if (val !== null && val !== undefined && typeof val === 'object') return null;
+        } else if (expected === 'nested') {
+          if (val !== null && val !== undefined) {
+            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: FlatLeaf[] = [];
+  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 as Record<string, unknown>;
+        if (!(fieldName in obj) || obj[fieldName] === null || obj[fieldName] === undefined) return {};
+        return obj[fieldName];
+      });
+      const subLeaves = analyzeFlattenable(subArr as unknown[], k, currentPath);
+      if (!subLeaves || subLeaves.length === 0) return null;
+      leaves.push(...subLeaves);
+    }
+  }
+
+  // Guard: reject if any row has non-null object with all-null leaves.
+  if (leaves.length > 0) {
+    for (const item of arr) {
+      const obj = item as Record<string, unknown>;
+      if (!(fieldName in obj) || obj[fieldName] === null || obj[fieldName] === undefined) 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: unknown, keys: string[]): { value: unknown; exists: boolean } {
+  if (keys.length === 0) return { value: undefined, exists: false };
+  const obj = item as Record<string, unknown>;
+  if (typeof obj !== 'object' || obj === null) return { value: undefined, exists: false };
+  if (!(keys[0] in obj)) return { value: undefined, exists: false };
+  let current: unknown = obj[keys[0]];
+  if (current === null || current === undefined) return { value: current, exists: true };
+  for (let i = 1; i < keys.length; i++) {
+    if (typeof current !== 'object' || current === null) return { value: undefined, exists: false };
+    const c = current as Record<string, unknown>;
+    if (!(keys[i] in c)) return { value: undefined, exists: false };
+    current = c[keys[i]];
+  }
+  return { value: current, exists: true };
+}
+
+// ── End flattening helpers ───────────────────────────────────────────────
+
+function encodeTabular(headerPrefix: string, arr: unknown[], fields: string[], depth: number, opts?: GenericOptions): string {
   const prefix = indent(depth);
 
-  // Pre-compute inline schemas and shared array schemas.
+  // Phase 0: Analyze fields for flattening.
+  const flattenMap = new Map<string, FlatLeaf[]>();
+  if (!opts?.noFlatten) {
+    for (const f of fields) {
+      const leaves = analyzeFlattenable(arr, f, '');
+      if (leaves && leaves.length > 0) {
+        flattenMap.set(f, leaves);
+      }
+    }
+  }
+
+  // Fields whose names contain ">" must not appear as tabular columns
+  // because the decoder would interpret them as flattened path columns.
+  // Track them for per-row attachment emission (spec rule 7.4.6.1.4).
+  const gtFields = new Set<string>();
+  for (const f of fields) {
+    if (!flattenMap.has(f) && f.includes('>')) {
+      gtFields.add(f);
+    }
+  }
+
+  // Build expanded column list.
+  type ColType = 'flat' | 'original';
+  interface FlatColumn { headerName: string; colType: ColType; field: string; keys: string[]; }
+  const columns: FlatColumn[] = [];
+  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 all fields were excluded (all contain ">"), fall back to expanded.
+  if (columns.length === 0) {
+    return encodeExpanded(headerPrefix, arr, depth, opts);
+  }
+
+  // Pre-compute inline schemas and shared array schemas (skip flattened fields).
   const inlineSchemas = new Map<string, string[]>();
   const sharedArrSchemas = new Map<string, string[]>();
   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(',')}}\n`;
+  const headerFields = columns.map(c => c.headerName);
+  let out = `${headerPrefix}[${arr.length}]{${headerFields.join(',')}}\n`;
 
   for (let i = 0; i < arr.length; i++) {
     const obj = arr[i] as Record<string, unknown>;
@@ -163,14 +320,38 @@ function encodeTabular(headerPrefix: string, arr: unknown[], fields: string[], d
     const attachments: { name: string; value: unknown; inline: boolean; inlineFields?: string[] }[] = [];
     let rowHasAttachment = false;
 
-    for (const f of fields) {
+    for (const col of columns) {
+      if (col.colType === 'flat') {
+        // Resolve value via key chain.
+        if (!(col.keys[0] in obj)) {
+          cells.push('~');
+        } else {
+          // Check if top-level field is null.
+          const topVal = obj[col.keys[0]];
+          if (topVal === null || topVal === undefined) {
+            cells.push(topVal === null ? '-' : '~');
+          } else {
+            const resolved = resolveKeyChain(obj, col.keys);
+            if (!resolved.exists) {
+              cells.push('~');
+            } else if (resolved.value === null || resolved.value === undefined) {
+              cells.push('-');
+            } else {
+              cells.push(formatScalar(resolved.value, 0x7c));
+            }
+          }
+        }
+        continue;
+      }
+
+      // Original (non-flattened) field.
+      const f = col.field;
       if (!(f in obj)) { cells.push('~'); continue; }
       const v = obj[f];
       if (v === null || v === undefined) { cells.push('-'); continue; }
       if (typeof v === 'object') {
         const ifs = inlineSchemas.get(f);
         if (ifs && !Array.isArray(v)) {
-          // Inline schema: first row declares, subsequent use bare ^.
           if (i === 0) {
             const fmtIF = ifs.map(k => formatKey(k));
             cells.push(`^{${fmtIF.join(',')}}`);
@@ -188,6 +369,15 @@ function encodeTabular(headerPrefix: string, arr: unknown[], fields: string[], d
       }
     }
 
+    // Emit fields with ">" in their names as per-row attachments.
+    for (const f of fields) {
+      if (!gtFields.has(f)) continue;
+      const obj = arr[i] as Record<string, unknown>;
+      if (!(f in obj)) continue;
+      rowHasAttachment = true;
+      attachments.push({ name: f, value: obj[f], inline: false });
+    }
+
     const row = cells.join('|');
     if (rowHasAttachment) {
       out += `${prefix}@${i} ${row}\n`;
@@ -209,31 +399,38 @@ function encodeTabular(headerPrefix: string, arr: unknown[], fields: string[], d
         // Shared array schema: omit {fields} on subsequent rows.
         const sas = sharedArrSchemas.get(att.name);
         if (sas && i > 0) {
-          out += encodeAttachmentArrayShared(prefix, fk, att.value as unknown[], depth + 2, sas);
+          out += encodeAttachmentArrayShared(prefix, fk, att.value as unknown[], depth + 2, sas, opts);
         } else {
-          out += encodeAttachmentArray(prefix, fk, att.value as unknown[], depth + 2);
+          out += encodeAttachmentArray(prefix, fk, att.value as unknown[], depth + 2, opts);
         }
-      } else {
+      } else if (typeof att.value === 'object' && att.value !== null) {
         out += `${prefix}.${fk} {}\n`;
-        out += encodeObject(att.value as Record<string, unknown>, depth + 2);
+        out += encodeObject(att.value as Record<string, unknown>, depth + 2, opts);
+      } else {
+        // Scalar attachment (e.g. field names containing ">").
+        if (att.value === null || att.value === undefined) {
+          out += `${prefix}.${fk} =-\n`;
+        } else {
+          out += `${prefix}.${fk} =${formatScalar(att.value, 0)}\n`;
+        }
       }
     }
   }
   return out;
 }
 
-function encodeAttachmentArray(attPrefix: string, fk: string, arr: unknown[], depth: number): string {
+function encodeAttachmentArray(attPrefix: string, fk: string, arr: unknown[], depth: number, opts?: GenericOptions): string {
   if (arr.length === 0) return `${attPrefix}.${fk} [0]\n`;
   if (allPrimitives(arr)) {
     const vals = arr.map(v => formatScalar(v, 0x2c));
     return `${attPrefix}.${fk} [${arr.length}]: ${vals.join(',')}\n`;
   }
   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: string, fk: string, arr: unknown[], depth: number, sharedFields: string[]): string {
+function encodeAttachmentArrayShared(attPrefix: string, fk: string, arr: unknown[], depth: number, sharedFields: string[], opts?: GenericOptions): string {
   if (arr.length === 0) return `${attPrefix}.${fk} [0]\n`;
   if (allPrimitives(arr)) {
     const vals = arr.map(v => formatScalar(v, 0x2c));
@@ -257,19 +454,19 @@ function encodeAttachmentArrayShared(attPrefix: string, fk: string, arr: unknown
     return out;
   }
   // Fields don't match: fall back to full encoding.
-  return encodeAttachmentArray(attPrefix, fk, arr, depth);
+  return encodeAttachmentArray(attPrefix, fk, arr, depth, opts);
 }
 
-function encodeExpanded(headerPrefix: string, arr: unknown[], depth: number): string {
+function encodeExpanded(headerPrefix: string, arr: unknown[], depth: number, opts?: GenericOptions): string {
   const prefix = indent(depth);
   let out = `${headerPrefix}[${arr.length}]\n`;
   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} {}\n`;
-      out += encodeObject(item as Record<string, unknown>, depth + 1);
+      out += encodeObject(item as Record<string, unknown>, depth + 1, opts);
     } else {
       out += `${prefix}@${i} =${formatScalar(item, 0)}\n`;
     }
@@ -277,15 +474,15 @@ function encodeExpanded(headerPrefix: string, arr: unknown[], depth: number): st
   return out;
 }
 
-function encodeExpandedArrayItem(prefix: string, idx: number, arr: unknown[], depth: number): string {
+function encodeExpandedArrayItem(prefix: string, idx: number, arr: unknown[], depth: number, opts?: GenericOptions): string {
   if (arr.length === 0) return `${prefix}@${idx} [0]\n`;
   if (allPrimitives(arr)) {
     const vals = arr.map(v => formatScalar(v, 0x2c));
     return `${prefix}@${idx} [${arr.length}]: ${vals.join(',')}\n`;
   }
   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: unknown[]): boolean {

package/src/index.ts

@@ -5,7 +5,7 @@ export { decode } from './decode.js';
 export { Session, encodeWithSession } from './session.js';
 export { encodeDelta, verifyDelta } from './delta.js';
 // packRoot is Node-only (uses crypto.createHash). Import directly: import { packRoot } from '@blackwell-systems/gcf/dist/packroot.js'
-export { encodeGeneric } from './generic.js';
+export { encodeGeneric, type GenericOptions } from './generic.js';
 export { decodeGeneric } from './decode_generic.js';
 export { formatScalar, formatKey, parseScalar, needsQuote, quoteString } from './scalar.js';
 export { StreamEncoder, type StreamWriter, type StreamOptions } from './stream.js';

package/dist/cjs/browser.d.ts

@@ -1,9 +0,0 @@
-export type { Symbol, Edge, Payload, DeltaPayload, Components } from './types.js';
-export { KIND_ABBREV, KIND_EXPAND } from './constants.js';
-export { encode } from './encode.js';
-export { decode } from './decode.js';
-export { encodeGeneric } from './generic.js';
-export { decodeGeneric } from './decode_generic.js';
-export { formatScalar, formatKey, parseScalar, needsQuote, quoteString } from './scalar.js';
-export { StreamEncoder, type StreamWriter, type StreamOptions } from './stream.js';
-export { GenericStreamEncoder } from './stream_generic.js';

package/dist/cjs/browser.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GenericStreamEncoder = exports.StreamEncoder = exports.quoteString = exports.needsQuote = exports.parseScalar = exports.formatKey = exports.formatScalar = exports.decodeGeneric = exports.encodeGeneric = exports.decode = exports.encode = exports.KIND_EXPAND = exports.KIND_ABBREV = void 0;
-var constants_js_1 = require("./constants.js");
-Object.defineProperty(exports, "KIND_ABBREV", { enumerable: true, get: function () { return constants_js_1.KIND_ABBREV; } });
-Object.defineProperty(exports, "KIND_EXPAND", { enumerable: true, get: function () { return constants_js_1.KIND_EXPAND; } });
-var encode_js_1 = require("./encode.js");
-Object.defineProperty(exports, "encode", { enumerable: true, get: function () { return encode_js_1.encode; } });
-var decode_js_1 = require("./decode.js");
-Object.defineProperty(exports, "decode", { enumerable: true, get: function () { return decode_js_1.decode; } });
-var generic_js_1 = require("./generic.js");
-Object.defineProperty(exports, "encodeGeneric", { enumerable: true, get: function () { return generic_js_1.encodeGeneric; } });
-var decode_generic_js_1 = require("./decode_generic.js");
-Object.defineProperty(exports, "decodeGeneric", { enumerable: true, get: function () { return decode_generic_js_1.decodeGeneric; } });
-var scalar_js_1 = require("./scalar.js");
-Object.defineProperty(exports, "formatScalar", { enumerable: true, get: function () { return scalar_js_1.formatScalar; } });
-Object.defineProperty(exports, "formatKey", { enumerable: true, get: function () { return scalar_js_1.formatKey; } });
-Object.defineProperty(exports, "parseScalar", { enumerable: true, get: function () { return scalar_js_1.parseScalar; } });
-Object.defineProperty(exports, "needsQuote", { enumerable: true, get: function () { return scalar_js_1.needsQuote; } });
-Object.defineProperty(exports, "quoteString", { enumerable: true, get: function () { return scalar_js_1.quoteString; } });
-var stream_js_1 = require("./stream.js");
-Object.defineProperty(exports, "StreamEncoder", { enumerable: true, get: function () { return stream_js_1.StreamEncoder; } });
-var stream_generic_js_1 = require("./stream_generic.js");
-Object.defineProperty(exports, "GenericStreamEncoder", { enumerable: true, get: function () { return stream_generic_js_1.GenericStreamEncoder; } });
-//# sourceMappingURL=browser.js.map

package/dist/cjs/browser.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"browser.js","sourceRoot":"","sources":["../../src/browser.ts"],"names":[],"mappings":";;;AAEA,+CAA0D;AAAjD,2GAAA,WAAW,OAAA;AAAE,2GAAA,WAAW,OAAA;AACjC,yCAAqC;AAA5B,mGAAA,MAAM,OAAA;AACf,yCAAqC;AAA5B,mGAAA,MAAM,OAAA;AACf,2CAA6C;AAApC,2GAAA,aAAa,OAAA;AACtB,yDAAoD;AAA3C,kHAAA,aAAa,OAAA;AACtB,yCAA4F;AAAnF,yGAAA,YAAY,OAAA;AAAE,sGAAA,SAAS,OAAA;AAAE,wGAAA,WAAW,OAAA;AAAE,uGAAA,UAAU,OAAA;AAAE,wGAAA,WAAW,OAAA;AACtE,yCAAmF;AAA1E,0GAAA,aAAa,OAAA;AACtB,yDAA2D;AAAlD,yHAAA,oBAAoB,OAAA"}

package/dist/cjs/cli.d.ts

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-/**
- * GCF command-line interface: encode, decode, stats.
- */
-export {};