@blackwell-systems/gcf 1.0.0 → 2.0.0

package/src/decode_generic.ts

@@ -5,7 +5,7 @@ import {
 } from './scalar.js';
 
 /**
- * Decode GCF v2.0 generic or graph profile text into a JS value.
+ * Decode GCF generic or graph profile text into a JS value.
  */
 export function decodeGeneric(input: string): any {
   input = input.trimEnd();
@@ -255,6 +255,10 @@ function parseTabularBody(lines: string[], start: number, depth: number, fields:
   const rows: any[] = [];
   let i = start;
 
+  // Track inline schemas and shared array schemas.
+  const inlineSchemas = new Map<string, string[]>();
+  const sharedArraySchemas = new Map<string, string[]>();
+
   while (i < lines.length) {
     const line = lines[i];
     const content = depth > 0 ? (line.startsWith(ind) ? line.slice(ind.length) : null) : line;
@@ -263,50 +267,161 @@ function parseTabularBody(lines: string[], start: number, depth: number, fields:
 
     if (content.length > 0 && content[0] === ' ') {
       const trimmed = content.trimStart();
-      if (trimmed.startsWith('.')) throw new Error(`orphan_attachment: ${trimmed}`);
+      if (trimmed.startsWith('.')) break; // attachment lines handled below
       break;
     }
 
+    // Strip @N prefix (must be @digits).
     let rowData = content;
     let rowHasID = false;
     if (rowData.startsWith('@')) {
       const sp = rowData.indexOf(' ');
-      if (sp > 0) { rowData = rowData.slice(sp + 1); rowHasID = true; }
+      if (sp > 0) {
+        const idStr = rowData.slice(1, sp);
+        if (/^\d+$/.test(idStr)) {
+          rowData = rowData.slice(sp + 1);
+          rowHasID = true;
+        }
+      }
     }
 
     const vals = splitRespectingQuotes(rowData, '|');
     if (vals.length !== fields.length) throw new Error(`row_width_mismatch: expected ${fields.length}, got ${vals.length}`);
 
-    const row: Record<string, any> = {};
-    const attachmentFields: string[] = [];
+    // Parse cells: scalars, traditional attachments, and inline schema attachments.
+    const cellValues = new Map<string, any>();
+    const traditionalAttFields: string[] = [];
+    const inlineAttFields: string[] = [];
+    const inlineAttOrder: string[] = [];
+    const missingFields = new Set<string>();
+
     for (let j = 0; j < fields.length; j++) {
-      const parsed = parseScalar(vals[j], true);
-      if (parsed === MISSING) continue;
-      if (parsed === ATTACHMENT) { attachmentFields.push(fields[j]); continue; }
-      row[fields[j]] = parsed;
+      const cellVal = vals[j];
+
+      // Check for ^{fields} inline schema declaration.
+      if (cellVal.startsWith('^{') && cellVal.endsWith('}')) {
+        const schemaStr = cellVal.slice(1);
+        const ifs = splitFieldDecl(schemaStr);
+        inlineSchemas.set(fields[j], ifs);
+        inlineAttFields.push(fields[j]);
+        inlineAttOrder.push(fields[j]);
+        continue;
+      }
+
+      const parsed = parseScalar(cellVal, true);
+      if (parsed === MISSING) { missingFields.add(fields[j]); continue; }
+      if (parsed === ATTACHMENT) {
+        // Check if this field has a stored inline schema.
+        if (inlineSchemas.has(fields[j])) {
+          inlineAttFields.push(fields[j]);
+          inlineAttOrder.push(fields[j]);
+        } else {
+          traditionalAttFields.push(fields[j]);
+        }
+        continue;
+      }
+      // Handle inline schema objects returned by parseScalar (for ^{...} that got through).
+      if (parsed && typeof parsed === 'object' && parsed.__inlineSchema) {
+        const ifs = splitFieldDecl(parsed.__inlineSchema);
+        inlineSchemas.set(fields[j], ifs);
+        inlineAttFields.push(fields[j]);
+        inlineAttOrder.push(fields[j]);
+        continue;
+      }
+      cellValues.set(fields[j], parsed);
     }
     i++;
 
-    if (rowHasID && attachmentFields.length > 0) {
-      const attIndent = ind + '  ';
-      const resolved = new Set<string>();
-      while (i < lines.length) {
-        const al = lines[i];
-        if (!al.startsWith(attIndent)) break;
-        const ac = al.slice(attIndent.length);
-        if (!ac.startsWith('.')) break;
-        const [name, val, consumed] = parseAttachment(lines, i, ac.slice(1), depth + 2);
-        if (resolved.has(name)) throw new Error(`duplicate_attachment: ${name}`);
-        resolved.add(name);
-        row[name] = val;
-        i += consumed;
+    // Parse attachments in line order.
+    const allAttFields = [...traditionalAttFields, ...inlineAttFields];
+    const attachmentValues = new Map<string, any>();
+
+    if (rowHasID && allAttFields.length > 0) {
+      let inlineIdx = 0;
+
+      while (i < lines.length && attachmentValues.size < allAttFields.length) {
+        const aLine = lines[i];
+        let aContent: string | null = null;
+        if (depth === 0 || aLine.startsWith(ind)) {
+          aContent = depth > 0 ? aLine.slice(ind.length) : aLine;
+        } else {
+          break;
+        }
+        if (aContent === null) break;
+
+        // Line starts with ".": traditional or prefixed inline attachment.
+        if (aContent.startsWith('.')) {
+          const rest = aContent.slice(1);
+          const [attName, afterName] = parseAttachmentName(rest);
+
+          // Check if this is an inline schema field with pipe-delimited data.
+          const ifs = inlineSchemas.get(attName);
+          if (ifs && !afterName.trimStart().startsWith('{}') && !afterName.trimStart().startsWith('[')) {
+            const data = afterName.trimStart();
+            const inlineVals = splitRespectingQuotes(data, '|');
+            if (inlineVals.length !== ifs.length) throw new Error(`inline_width_mismatch: ${attName} expected ${ifs.length}, got ${inlineVals.length}`);
+            const obj: Record<string, any> = {};
+            for (let k = 0; k < ifs.length; k++) {
+              const p = parseScalar(inlineVals[k], true);
+              if (p !== MISSING) obj[ifs[k]] = p;
+            }
+            attachmentValues.set(attName, obj);
+            i++;
+            continue;
+          }
+
+          // Traditional attachment.
+          const [name, val, consumed, parsedFields] = parseAttachment(lines, i, rest, depth + 2, sharedArraySchemas);
+          // Store shared array schema from first row.
+          if (rows.length === 0 && parsedFields) {
+            sharedArraySchemas.set(name, parsedFields);
+          }
+          attachmentValues.set(name, val);
+          i += consumed;
+          continue;
+        }
+
+        // No-prefix line: positional inline data.
+        let foundInline = false;
+        let nextInlineField = '';
+        while (inlineIdx < inlineAttOrder.length) {
+          const candidate = inlineAttOrder[inlineIdx];
+          if (!attachmentValues.has(candidate)) {
+            nextInlineField = candidate;
+            foundInline = true;
+            break;
+          }
+          inlineIdx++;
+        }
+        if (!foundInline) break;
+
+        const ifs = inlineSchemas.get(nextInlineField)!;
+        const inlineVals = splitRespectingQuotes(aContent, '|');
+        if (inlineVals.length !== ifs.length) throw new Error(`inline_width_mismatch: ${nextInlineField} expected ${ifs.length}, got ${inlineVals.length}`);
+        const obj: Record<string, any> = {};
+        for (let k = 0; k < ifs.length; k++) {
+          const p = parseScalar(inlineVals[k], true);
+          if (p !== MISSING) obj[ifs[k]] = p;
+        }
+        attachmentValues.set(nextInlineField, obj);
+        inlineIdx++;
+        i++;
       }
-      for (const f of attachmentFields) {
-        if (!resolved.has(f)) throw new Error(`missing_attachment: ${f}`);
+
+      for (const f of allAttFields) {
+        if (!attachmentValues.has(f)) throw new Error(`missing_attachment: ${f}`);
       }
     }
 
-    if (!rowHasID || attachmentFields.length === 0) {
+    // Build row in field declaration order.
+    const row: Record<string, any> = {};
+    for (const f of fields) {
+      if (missingFields.has(f)) continue;
+      if (cellValues.has(f)) { row[f] = cellValues.get(f); continue; }
+      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);
@@ -320,34 +435,86 @@ function parseTabularBody(lines: string[], start: number, depth: number, fields:
   return [rows, i - start];
 }
 
-function parseAttachment(lines: string[], lineIdx: number, rest: string, depth: number): [string, any, number] {
-  let name: string;
-  let afterName: string;
+function parseAttachmentName(rest: string): [string, string] {
   if (rest[0] === '"') {
-    let closeIdx = -1;
     for (let j = 1; j < rest.length; j++) {
       if (rest[j] === '\\') { j++; continue; }
-      if (rest[j] === '"') { closeIdx = j; break; }
+      if (rest[j] === '"') {
+        const name = parseQuotedString(rest.slice(0, j + 1));
+        return [name, rest.slice(j + 1)];
+      }
     }
-    if (closeIdx < 0) throw new Error('unterminated_quote');
-    name = parseQuotedString(rest.slice(0, closeIdx + 1));
-    afterName = rest.slice(closeIdx + 1).trimStart();
-  } else {
-    const sp = rest.indexOf(' ');
-    if (sp < 0) throw new Error(`invalid attachment: ${rest}`);
-    name = rest.slice(0, sp);
-    afterName = rest.slice(sp).trimStart();
+    return ['', rest];
   }
+  const sp = rest.indexOf(' ');
+  if (sp >= 0) return [rest.slice(0, sp), rest.slice(sp)];
+  return [rest, ''];
+}
+
+/** Attachment parser: returns [name, value, consumed, parsedFields]. parsedFields is set for tabular arrays with explicit {fields}. */
+function parseAttachment(lines: string[], lineIdx: number, rest: string, depth: number, sharedSchemas: Map<string, string[]>): [string, any, number, string[] | null] {
+  const [name, afterNameRaw] = parseAttachmentName(rest);
+  const afterName = afterNameRaw.trimStart();
 
   if (afterName.startsWith('{}')) {
     const nested: Record<string, any> = {};
     const consumed = parseObjectBody(lines, lineIdx + 1, depth, nested);
-    return [name, nested, consumed + 1];
+    return [name, nested, consumed + 1, null];
   }
+
   if (afterName.startsWith('[')) {
+    const closeBracket = afterName.indexOf(']');
+    if (closeBracket < 0) throw new Error('invalid_count: missing ]');
+    const afterClose = afterName.slice(closeBracket + 1);
+
+    // [N]{fields}: has its own schema.
+    if (afterClose.startsWith('{')) {
+      const endBrace = findClosingBrace(afterClose);
+      let parsedFields: string[] | null = null;
+      if (endBrace >= 0) {
+        try { parsedFields = splitFieldDecl(afterClose.slice(0, endBrace + 1)); } catch {}
+      }
+      const [arr, consumed] = parseArrayFromHeader(lines, lineIdx, depth, afterName);
+      return [name, arr, consumed, parsedFields];
+    }
+
+    // [N]: values or [N] (check for inline primitive array first).
+    const afterCloseForInline = afterName.slice(closeBracket + 1);
+    if (afterCloseForInline.startsWith(': ') || afterCloseForInline === ':') {
+      // Inline primitive array: don't use shared schema.
+      const [arr, consumed] = parseArrayFromHeader(lines, lineIdx, depth, afterName);
+      return [name, arr, consumed, null];
+    }
+
+    // [N] without {fields}: check for shared schema.
+    if (sharedSchemas.has(name)) {
+      const sf = sharedSchemas.get(name)!;
+      const countStr = afterName.slice(1, closeBracket);
+      let count = -1;
+      if (countStr !== '?') count = parseInt(countStr, 10);
+      if (count === 0) return [name, [], 1, null];
+
+      // Peek: if next line starts with @, it's expanded, not tabular.
+      const nextIdx = lineIdx + 1;
+      const ind = '  '.repeat(depth);
+      let useShared = true;
+      if (nextIdx < lines.length) {
+        let nextContent = lines[nextIdx];
+        if (depth > 0 && nextContent.startsWith(ind)) nextContent = nextContent.slice(ind.length);
+        if (nextContent.trimStart().startsWith('@')) useShared = false;
+      }
+      if (useShared) {
+        const [rows, consumed] = parseTabularBody(lines, lineIdx + 1, depth, sf, count);
+        if (count >= 0 && rows.length !== count) throw new Error(`count_mismatch: declared ${count}, got ${rows.length}`);
+        return [name, rows, consumed + 1, null];
+      }
+    }
+
+    // No shared schema: standard parsing.
     const [arr, consumed] = parseArrayFromHeader(lines, lineIdx, depth, afterName);
-    return [name, arr, consumed];
+    return [name, arr, consumed, null];
   }
+
   throw new Error(`invalid attachment form: ${afterName}`);
 }
 

package/src/delta.ts

@@ -1,5 +1,6 @@
-import type { DeltaPayload } from './types.js';
+import type { DeltaPayload, Symbol, Edge } from './types.js';
 import { KIND_ABBREV } from './constants.js';
+import { packRoot } from './packroot.js';
 
 /**
  * EncodeDelta serializes a DeltaPayload into GCF delta format.
@@ -53,3 +54,41 @@ export function encodeDelta(d: DeltaPayload): string {
 
   return lines.join('\n') + '\n';
 }
+
+/**
+ * Apply a delta to a base set of symbols/edges and verify the resulting pack root.
+ *
+ * Returns the new symbol and edge sets if the computed root matches expectedNewRoot.
+ * Throws if the root does not match.
+ */
+export function verifyDelta(
+  baseSymbols: Symbol[],
+  baseEdges: Edge[],
+  removedSymbols: Symbol[],
+  addedSymbols: Symbol[],
+  removedEdges: Edge[],
+  addedEdges: Edge[],
+  expectedNewRoot: string,
+): { symbols: Symbol[]; edges: Edge[] } {
+  // Remove symbols by qualifiedName.
+  const removedNames = new Set(removedSymbols.map((s) => s.qualifiedName));
+  const newSymbols = baseSymbols.filter((s) => !removedNames.has(s.qualifiedName)).concat(addedSymbols);
+
+  // Remove edges by (source, target, edgeType).
+  const removedEdgeKeys = new Set(
+    removedEdges.map((e) => `${e.source}\t${e.target}\t${e.edgeType}`),
+  );
+  const newEdges = baseEdges
+    .filter((e) => !removedEdgeKeys.has(`${e.source}\t${e.target}\t${e.edgeType}`))
+    .concat(addedEdges);
+
+  // Compute pack root and verify.
+  const computed = packRoot(newSymbols, newEdges);
+  if (computed !== expectedNewRoot) {
+    throw new Error(
+      `pack root mismatch: expected ${expectedNewRoot}, computed ${computed}`,
+    );
+  }
+
+  return { symbols: newSymbols, edges: newEdges };
+}

package/src/generic.ts

@@ -1,5 +1,5 @@
 /**
- * Generic encoder: converts any JS value into GCF v2.0 generic profile.
+ * Generic encoder: converts any JS value into GCF generic profile.
  */
 import { formatScalar, formatKey, ATTACHMENT } from './scalar.js';
 
@@ -74,15 +74,93 @@ function tabularFields(arr: unknown[]): string[] | null {
   return fieldOrder.length > 0 ? fieldOrder : null;
 }
 
+/** Check if a field is eligible for inline schema: all rows have same flat object shape with 3+ keys. */
+function inlineSchemaFields(arr: unknown[], fieldName: string): string[] | null {
+  // First row must have the field.
+  const first = arr[0] as Record<string, unknown> | undefined;
+  if (!first || !(fieldName in first)) return null;
+  const firstVal = first[fieldName];
+  if (firstVal === null || firstVal === undefined || typeof firstVal !== 'object' || Array.isArray(firstVal)) return null;
+
+  let canonicalKeys: string[] | 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>);
+    // All values must be scalars.
+    for (const k of keys) {
+      const val = (v as Record<string, unknown>)[k];
+      if (val !== null && val !== undefined && typeof val === 'object') return null;
+    }
+    if (!canonicalKeys) {
+      canonicalKeys = keys;
+    } else {
+      if (keys.length !== canonicalKeys.length) return null;
+      for (let i = 0; i < keys.length; i++) {
+        if (keys[i] !== canonicalKeys[i]) return null;
+      }
+    }
+  }
+  if (!canonicalKeys || canonicalKeys.length < 3) return null;
+  return canonicalKeys;
+}
+
+/** Check if array attachment has same tabular schema across all rows (first row must have it). All values must be scalars. */
+function sharedArraySchema(arr: unknown[], fieldName: string): string[] | null {
+  const first = arr[0] as Record<string, unknown> | undefined;
+  if (!first || !(fieldName in first)) return null;
+  const firstVal = first[fieldName];
+  if (!Array.isArray(firstVal)) return null;
+
+  let canonicalFields: string[] | 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 (!Array.isArray(v)) return null;
+    const fields = tabularFields(v);
+    if (!fields) return null;
+    // All values must be scalars.
+    for (const arrItem of v) {
+      if (typeof arrItem !== 'object' || arrItem === null) return null;
+      for (const val of Object.values(arrItem as Record<string, unknown>)) {
+        if (val !== null && val !== undefined && typeof val === 'object') return null;
+      }
+    }
+    if (!canonicalFields) {
+      canonicalFields = fields;
+    } else {
+      if (fields.length !== canonicalFields.length) return null;
+      for (let i = 0; i < fields.length; i++) {
+        if (fields[i] !== canonicalFields[i]) return null;
+      }
+    }
+  }
+  return canonicalFields;
+}
+
 function encodeTabular(headerPrefix: string, arr: unknown[], fields: string[], depth: number): string {
   const prefix = indent(depth);
+
+  // Pre-compute inline schemas and shared array schemas.
+  const inlineSchemas = new Map<string, string[]>();
+  const sharedArrSchemas = new Map<string, string[]>();
+  for (const f of fields) {
+    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`;
 
   for (let i = 0; i < arr.length; i++) {
     const obj = arr[i] as Record<string, unknown>;
     const cells: string[] = [];
-    const attachments: { name: string; value: unknown }[] = [];
+    const attachments: { name: string; value: unknown; inline: boolean; inlineFields?: string[] }[] = [];
     let rowHasAttachment = false;
 
     for (const f of fields) {
@@ -90,8 +168,20 @@ function encodeTabular(headerPrefix: string, arr: unknown[], fields: string[], d
       const v = obj[f];
       if (v === null || v === undefined) { cells.push('-'); continue; }
       if (typeof v === 'object') {
-        cells.push('^');
-        attachments.push({ name: f, value: v });
+        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(',')}}`);
+          } else {
+            cells.push('^');
+          }
+          attachments.push({ name: f, value: v, inline: true, inlineFields: ifs });
+        } else {
+          cells.push('^');
+          attachments.push({ name: f, value: v, inline: false });
+        }
         rowHasAttachment = true;
       } else {
         cells.push(formatScalar(v, 0x7c));
@@ -106,12 +196,25 @@ function encodeTabular(headerPrefix: string, arr: unknown[], fields: string[], d
     }
 
     for (const att of attachments) {
-      const attPrefix = prefix + '  ';
       const fk = formatKey(att.name);
-      if (Array.isArray(att.value)) {
-        out += encodeAttachmentArray(attPrefix, fk, att.value as unknown[], depth + 2);
+      if (att.inline && att.inlineFields) {
+        // Inline: single pipe-delimited row, no prefix, no indent.
+        const vals = att.inlineFields.map(inf => {
+          const val = (att.value as Record<string, unknown>)[inf];
+          if (val === undefined) return '~';
+          return formatScalar(val, 0x7c);
+        });
+        out += `${prefix}${vals.join('|')}\n`;
+      } else if (Array.isArray(att.value)) {
+        // 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);
+        } else {
+          out += encodeAttachmentArray(prefix, fk, att.value as unknown[], depth + 2);
+        }
       } else {
-        out += `${attPrefix}.${fk} {}\n`;
+        out += `${prefix}.${fk} {}\n`;
         out += encodeObject(att.value as Record<string, unknown>, depth + 2);
       }
     }
@@ -130,6 +233,33 @@ function encodeAttachmentArray(attPrefix: string, fk: string, arr: unknown[], de
   return encodeExpanded(`${attPrefix}.${fk} `, arr, depth);
 }
 
+function encodeAttachmentArrayShared(attPrefix: string, fk: string, arr: unknown[], depth: number, sharedFields: string[]): 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`;
+  }
+  // Verify fields match shared schema.
+  const fields = tabularFields(arr);
+  if (fields && fields.length === sharedFields.length && fields.every((f, i) => f === sharedFields[i])) {
+    // Omit {fields}, use shared schema.
+    const prefix = indent(depth);
+    let out = `${attPrefix}.${fk} [${arr.length}]\n`;
+    for (const item of arr) {
+      const obj = item as Record<string, unknown>;
+      const cells = sharedFields.map(f => {
+        if (!(f in obj)) return '~';
+        if (obj[f] === null || obj[f] === undefined) return '-';
+        return formatScalar(obj[f], 0x7c);
+      });
+      out += `${prefix}${cells.join('|')}\n`;
+    }
+    return out;
+  }
+  // Fields don't match: fall back to full encoding.
+  return encodeAttachmentArray(attPrefix, fk, arr, depth);
+}
+
 function encodeExpanded(headerPrefix: string, arr: unknown[], depth: number): string {
   const prefix = indent(depth);
   let out = `${headerPrefix}[${arr.length}]\n`;

package/src/index.ts

@@ -3,7 +3,8 @@ export { KIND_ABBREV, KIND_EXPAND } from './constants.js';
 export { encode } from './encode.js';
 export { decode } from './decode.js';
 export { Session, encodeWithSession } from './session.js';
-export { encodeDelta } from './delta.js';
+export { encodeDelta, verifyDelta } from './delta.js';
+export { packRoot } from './packroot.js';
 export { encodeGeneric } from './generic.js';
 export { decodeGeneric } from './decode_generic.js';
 export { formatScalar, formatKey, parseScalar, needsQuote, quoteString } from './scalar.js';

package/src/packroot.ts

@@ -0,0 +1,54 @@
+import { createHash } from 'node:crypto';
+import type { Symbol, Edge } from './types.js';
+import { KIND_ABBREV } from './constants.js';
+import { formatNumber } from './scalar.js';
+
+/**
+ * Compute a content-addressed PackRoot hash for a set of symbols and edges.
+ *
+ * Algorithm:
+ * 1. Build canonical symbol records: S\t{kind}\t{qname}\t{score}\t{provenance}\t{distance}\n
+ * 2. Build canonical edge records: E\t{srcKind}\t{source}\t{tgtKind}\t{target}\t{edgeType}\n
+ * 3. Sort both arrays independently by UTF-8 byte order
+ * 4. Concatenate: all symbols then all edges
+ * 5. SHA-256 hash
+ * 6. Return sha256:{hex}
+ */
+export function packRoot(symbols: Symbol[], edges: Edge[], symbolKinds?: Map<string, string>): string {
+  const symRecords: string[] = [];
+  const edgeRecords: string[] = [];
+
+  // Build symbol records.
+  for (const s of symbols) {
+    const kind = KIND_ABBREV[s.kind] || s.kind;
+    symRecords.push(`S\t${kind}\t${s.qualifiedName}\t${formatNumber(s.score)}\t${s.provenance}\t${s.distance}\n`);
+  }
+
+  // Build edge records.
+  // For edges, we need kind lookups for source and target.
+  // Build a map of qualifiedName -> kind from symbols.
+  const kindMap = symbolKinds ?? new Map<string, string>();
+  if (!symbolKinds) {
+    for (const s of symbols) {
+      const kind = KIND_ABBREV[s.kind] || s.kind;
+      kindMap.set(s.qualifiedName, kind);
+    }
+  }
+
+  for (const e of edges) {
+    const srcKind = kindMap.get(e.source) || 'fn';
+    const tgtKind = kindMap.get(e.target) || 'fn';
+    edgeRecords.push(`E\t${srcKind}\t${e.source}\t${tgtKind}\t${e.target}\t${e.edgeType}\n`);
+  }
+
+  // Sort both arrays by UTF-8 byte order.
+  symRecords.sort();
+  edgeRecords.sort();
+
+  // Concatenate.
+  const data = symRecords.join('') + edgeRecords.join('');
+
+  // SHA-256 hash.
+  const hash = createHash('sha256').update(data, 'utf8').digest('hex');
+  return `sha256:${hash}`;
+}

package/src/scalar.ts

@@ -1,10 +1,10 @@
 /**
- * Common scalar grammar for GCF v2.0.
+ * Common scalar grammar for GCF.
  * Shared between encoder, decoder, and streaming encoder.
  */
 
 const JSON_NUMBER_RE = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
-const NUMERIC_LIKE_RE = /^[+-]?\.?\d/;
+const NUMERIC_LIKE_RE = /^[+-]\.?\d|^\.\d|^0\d/;
 
 /** Check if a string value must be quoted per Section 2.4. */
 export function needsQuote(s: string): boolean {
@@ -13,11 +13,17 @@ export function needsQuote(s: string): boolean {
   if (JSON_NUMBER_RE.test(s)) return true;
   if (NUMERIC_LIKE_RE.test(s)) return true;
   if (s[0] === ' ' || s[s.length - 1] === ' ') return true;
-  if (s[0] === '#' || s[0] === '@') return true;
+  if (s[0] === '#' || s[0] === '@' || s[0] === '.') return true;
   for (let i = 0; i < s.length; i++) {
     const c = s.charCodeAt(i);
     if (c === 0x22 || c === 0x5c || c < 0x20 || c === 0x0a || c === 0x0d ||
-        c === 0x7c || c === 0x2c) return true; // " \ control \n \r | ,
+        c === 0x7c) return true; // " \ control \n \r |
+    // C1 control characters
+    if (c >= 0x80 && c <= 0x9f) return true;
+    // Unicode whitespace beyond ASCII
+    if (c > 0x7f && (c === 0xa0 || c === 0x2028 || c === 0x2029 || c === 0xfeff ||
+        c === 0x1680 || (c >= 0x2000 && c <= 0x200a) || c === 0x202f ||
+        c === 0x205f || c === 0x3000)) return true;
   }
   return false;
 }
@@ -108,10 +114,12 @@ export function parseScalar(s: string, tabularContext: boolean): any {
     return MISSING;
   }
 
-  // 4. Attachment (tabular only).
-  if (s === '^') {
+  // 4. Attachment (tabular only). Plain ^ or ^{fields} (inline schema).
+  if (s === '^' || (s.startsWith('^{') && s.endsWith('}'))) {
     if (!tabularContext) throw new Error('invalid_attachment_marker: ^ outside tabular row cell');
-    return ATTACHMENT;
+    if (s === '^') return ATTACHMENT;
+    // Inline schema: return the schema string for the caller to parse.
+    return { __inlineSchema: s.slice(1) }; // e.g. "{name,email,tier}"
   }
 
   // 5. Boolean.