@sprig-and-prose/sprig-universe 0.4.1 → 0.4.2

package/src/universe/scene-manifest.js

@@ -0,0 +1,856 @@
+/**
+ * @fileoverview Converter from AST to Scene Manifest JSON
+ */
+
+/**
+ * @typedef {import('../ast.js').FileAST} FileAST
+ * @typedef {import('../ast.js').SceneDecl} SceneDecl
+ * @typedef {import('../ast.js').ActorDecl} ActorDecl
+ * @typedef {import('../ast.js').UsingBlock} UsingBlock
+ * @typedef {import('../ast.js').DescribeBlock} DescribeBlock
+ * @typedef {import('../ast.js').TypeBlock} TypeBlock
+ * @typedef {import('../ast.js').IdentityBlock} IdentityBlock
+ * @typedef {import('../ast.js').SourceBlock} SourceBlock
+ * @typedef {import('../ast.js').TransformsBlock} TransformsBlock
+ * @typedef {import('../ast.js').TransformBlock} TransformBlock
+ * @typedef {import('../ast.js').UnknownBlock} UnknownBlock
+ */
+
+/**
+ * Normalizes describe block text (similar to universe layer)
+ * @param {string} raw - Raw text content
+ * @returns {string} Normalized text
+ */
+function normalizeDescribe(raw) {
+  // Trim leading/trailing whitespace and normalize internal whitespace
+  return raw
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+    .join(' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+/**
+ * Converts a source span to location format
+ * @param {import('../ast.js').SourceSpan} source
+ * @returns {{ file: string, start: { line: number, col: number, offset: number }, end: { line: number, col: number, offset: number } }}
+ */
+function sourceToLocation(source) {
+  return {
+    file: source.file,
+    start: source.start,
+    end: source.end,
+  };
+}
+
+/**
+ * Parses a type expression into a structured AST
+ * @param {string} typeExpr - Type expression string
+ * @returns {Object} Structured type AST
+ */
+function parseTypeExpression(typeExpr) {
+  const trimmed = typeExpr.trim();
+  
+  // Handle optional wrapper: "optional T"
+  const optionalMatch = trimmed.match(/^optional\s+(.+)$/i);
+  if (optionalMatch) {
+    return {
+      kind: 'optional',
+      of: parseTypeExpression(optionalMatch[1]),
+    };
+  }
+  
+  // Handle array: "[ T ]"
+  const arrayMatch = trimmed.match(/^\[\s*(.+?)\s*\]$/);
+  if (arrayMatch) {
+    return {
+      kind: 'array',
+      elementType: parseTypeExpression(arrayMatch[1]),
+    };
+  }
+  
+  // Handle enum/union: "one of { ... }"
+  const oneOfMatch = trimmed.match(/^one\s+of\s+\{\s*(.+?)\s*\}$/i);
+  if (oneOfMatch) {
+    const valuesStr = oneOfMatch[1];
+    // Parse values (can be strings, numbers, or identifiers)
+    const values = [];
+    const valueParts = valuesStr.split(',').map((v) => v.trim());
+    
+    for (const part of valueParts) {
+      // Check if it's a quoted string
+      const stringMatch = part.match(/^['"](.+?)['"]$/);
+      if (stringMatch) {
+        values.push({ kind: 'string', value: stringMatch[1] });
+      } else if (/^\d+$/.test(part)) {
+        // Number
+        values.push({ kind: 'number', value: parseInt(part, 10) });
+      } else {
+        // Identifier or other
+        values.push({ kind: 'identifier', value: part });
+      }
+    }
+    
+    // Infer value type from first value
+    const valueType = values.length > 0 ? values[0].kind : 'unknown';
+    
+    return {
+      kind: 'oneOf',
+      values: values.map((v) => v.value),
+      valueType,
+    };
+  }
+  
+  // Handle primitive types or type references
+  const primitiveTypes = new Set(['integer', 'string', 'boolean', 'number', 'float', 'double']);
+  if (primitiveTypes.has(trimmed.toLowerCase())) {
+    return {
+      kind: 'primitive',
+      name: trimmed.toLowerCase(),
+    };
+  }
+  
+  // Type reference (e.g., "Tool", "Item")
+  if (/^[A-Z][A-Za-z0-9_]*$/.test(trimmed)) {
+    return {
+      kind: 'reference',
+      name: trimmed,
+    };
+  }
+  
+  // Fallback: unknown type
+  return {
+    kind: 'unknown',
+    raw: trimmed,
+  };
+}
+
+/**
+ * Extracts a light structure from type block raw content
+ * Attempts to parse simple field definitions but keeps it minimal
+ * @param {string} raw - Raw type block content
+ * @param {import('../ast.js').SourceSpan} typeBlockLocation - Location of the type block
+ * @returns {{ fields?: Array<{ name: string, typeExpr: string, type: Object, required: boolean, location?: Object }> } | null}
+ */
+function extractTypeFields(raw, typeBlockLocation) {
+  // Very light extraction - just try to find field: type patterns
+  // This is forward-compatible and doesn't do full type parsing
+  const fields = [];
+  const lines = raw.split('\n');
+  
+  // Track line offset relative to type block start
+  // The start line is the opening brace line, and the first field is on the next line
+  // So we initialize to start.line and increment before processing each line
+  let currentLine = typeBlockLocation.start.line;
+  let lineOffset = 0;
+  
+  // Track indentation levels to detect nested structures
+  const getIndentLevel = (line) => {
+    const match = line.match(/^(\s*)/);
+    return match ? match[1].length : 0;
+  };
+  
+  // Find the minimum indentation level (base indent)
+  // This handles cases where the first line has no indent but subsequent lines do
+  let baseIndent = Infinity;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed && !trimmed.startsWith('//') && !trimmed.startsWith('--')) {
+      const indent = getIndentLevel(line);
+      if (indent < baseIndent) {
+        baseIndent = indent;
+      }
+    }
+  }
+  
+  // If we couldn't find a base indent, default to 0
+  if (baseIndent === Infinity) {
+    baseIndent = 0;
+  }
+  
+  let skipUntilIndent = -1; // Track when to skip nested content
+  
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    
+    // Update current line for each line we process
+    // This ensures the first field gets the correct line number
+    currentLine++;
+    
+    if (!trimmed || trimmed.startsWith('//') || trimmed.startsWith('--')) {
+      // Update line offset even for empty lines
+      lineOffset += line.length + 1;
+      continue;
+    }
+    
+    const indentLevel = getIndentLevel(line);
+    
+    // Skip nested content (indented more than base)
+    if (skipUntilIndent >= 0) {
+      if (indentLevel > skipUntilIndent) {
+        // Still in nested content, skip
+        lineOffset += line.length + 1;
+        continue;
+      } else {
+        // Back to base level, stop skipping
+        skipUntilIndent = -1;
+      }
+    }
+    
+    // Look for pattern: identifier { typeExpr } or identifier : typeExpr
+    // Pattern 1: fieldName { typeExpr } - handle nested braces
+    const braceStartMatch = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*\{\s*/);
+    if (braceStartMatch) {
+      const fieldName = braceStartMatch[1];
+      const fieldStartCol = line.indexOf(fieldName) + 1; // 1-indexed
+      const startPos = braceStartMatch[0].length;
+      
+      // Find matching closing brace by tracking depth on the same line
+      let depth = 1;
+      let pos = startPos;
+      let endPos = startPos;
+      
+      while (pos < trimmed.length && depth > 0) {
+        if (trimmed[pos] === '{') {
+          depth++;
+        } else if (trimmed[pos] === '}') {
+          depth--;
+          if (depth === 0) {
+            endPos = pos;
+            break;
+          }
+        }
+        pos++;
+      }
+      
+      // If not closed on same line, check if next line has nested content
+      if (depth > 0 && i + 1 < lines.length) {
+        const nextLine = lines[i + 1];
+        const nextIndent = getIndentLevel(nextLine);
+        const nextTrimmed = nextLine.trim();
+        
+        // If next line is more indented than current line and not empty, it's a nested object
+        if (nextIndent > indentLevel && nextTrimmed && !nextTrimmed.startsWith('//') && !nextTrimmed.startsWith('--')) {
+          // Check if the nested content starts with "optional {"
+          // This indicates the field itself is optional, not just a nested object
+          const isOptionalField = nextTrimmed.match(/^optional\s*\{/i) !== null;
+          
+          // Extract nested fields from the nested object structure
+          // Find the content inside the nested braces (or inside optional { ... })
+          let nestedContentStart = i + 1;
+          let nestedContentEnd = i + 1;
+          let nestedIndent = nextIndent;
+          
+          // If it starts with "optional {", find the content inside optional block
+          if (isOptionalField) {
+            // Find the closing brace of the optional block
+            let optionalDepth = 1;
+            nestedContentStart = i + 1;
+            let foundClosingBrace = false;
+            for (let j = i + 1; j < lines.length; j++) {
+              const testLine = lines[j];
+              const testTrimmed = testLine.trim();
+              
+              // Count braces to find end of optional block (check this first)
+              for (const ch of testTrimmed) {
+                if (ch === '{') optionalDepth++;
+                if (ch === '}') {
+                  optionalDepth--;
+                  if (optionalDepth === 0) {
+                    // Found the closing brace of the optional block
+                    nestedContentEnd = j;
+                    foundClosingBrace = true;
+                    break;
+                  }
+                }
+              }
+              
+              if (foundClosingBrace) break;
+              
+              // Check if we've gone back to base level (only after checking for closing brace)
+              const testIndent = getIndentLevel(testLine);
+              if (testIndent <= indentLevel && testTrimmed && !testTrimmed.startsWith('//') && !testTrimmed.startsWith('--')) {
+                // Back to base level without finding closing brace - this shouldn't happen normally
+                break;
+              }
+            }
+            
+            // The nested fields are inside the optional block, starting from the line after "optional {"
+            nestedContentStart = i + 2; // Skip "optional {" line
+            
+            // If nestedContentEnd points to lines that only contain closing braces,
+            // exclude them from the content to extract (work backwards)
+            while (nestedContentEnd >= nestedContentStart && nestedContentEnd < lines.length) {
+              const endLineTrimmed = lines[nestedContentEnd]?.trim() || '';
+              // If the end line is just a closing brace (possibly with whitespace), exclude it
+              if (endLineTrimmed === '}' || endLineTrimmed.match(/^\s*\}\s*$/)) {
+                nestedContentEnd = nestedContentEnd - 1;
+              } else {
+                break; // Found a line with actual content
+              }
+            }
+            
+            nestedIndent = getIndentLevel(lines[nestedContentStart] || '');
+          } else {
+            // Find where the nested object block ends
+            let objectDepth = 1;
+            for (let j = i + 1; j < lines.length; j++) {
+              const testLine = lines[j];
+              const testIndent = getIndentLevel(testLine);
+              const testTrimmed = testLine.trim();
+              
+              if (testIndent <= indentLevel && testTrimmed && !testTrimmed.startsWith('//') && !testTrimmed.startsWith('--')) {
+                nestedContentEnd = j - 1;
+                break;
+              }
+              
+              // Count braces
+              for (const ch of testTrimmed) {
+                if (ch === '{') objectDepth++;
+                if (ch === '}') {
+                  objectDepth--;
+                  if (objectDepth === 0) {
+                    nestedContentEnd = j;
+                    break;
+                  }
+                }
+              }
+              
+              if (objectDepth === 0) {
+                nestedContentEnd = j;
+                break;
+              }
+            }
+          }
+          
+          // Extract nested fields from the nested content
+          let nestedFields = null;
+          if (nestedContentStart <= nestedContentEnd && nestedContentStart < lines.length) {
+            // Build a sub-raw content for the nested object
+            const nestedLines = [];
+            for (let j = nestedContentStart; j <= nestedContentEnd && j < lines.length; j++) {
+              nestedLines.push(lines[j]);
+            }
+            const nestedRaw = nestedLines.join('\n');
+            
+            // Create a location for the nested type block (relative to parent)
+            const nestedLocation = {
+              file: typeBlockLocation.file,
+              start: {
+                line: currentLine + (nestedContentStart - i),
+                col: 1,
+                offset: typeBlockLocation.start.offset + lineOffset + (nestedContentStart > i ? lines.slice(i + 1, nestedContentStart).reduce((sum, l) => sum + l.length + 1, 0) : 0),
+              },
+              end: {
+                line: currentLine + (nestedContentEnd - i),
+                col: 1,
+                offset: typeBlockLocation.start.offset + lineOffset + nestedLines.reduce((sum, l) => sum + l.length + 1, 0),
+              },
+            };
+            
+            // Recursively extract fields from nested content
+            nestedFields = extractTypeFields(nestedRaw, nestedLocation);
+            // Note: The optional { } wrapper makes the parent field optional,
+            // but nested fields inside are still required when the parent is present
+          }
+          
+          // This is a nested object structure - treat as object type
+          const typeExpr = isOptionalField ? 'optional { ... }' : '{ ... }';
+          const fieldEndCol = fieldStartCol + trimmed.length;
+          
+          const fieldDef = {
+            name: fieldName,
+            typeExpr: typeExpr,
+            type: { kind: 'object', nested: true },
+            required: !isOptionalField, // Optional if it starts with "optional {"
+            location: {
+              file: typeBlockLocation.file,
+              start: {
+                line: currentLine,
+                col: fieldStartCol,
+                offset: typeBlockLocation.start.offset + lineOffset + line.indexOf(fieldName),
+              },
+              end: {
+                line: currentLine,
+                col: fieldEndCol,
+                offset: typeBlockLocation.start.offset + lineOffset + trimmed.length,
+              },
+            },
+          };
+          
+          // Add nested fields if we extracted them
+          if (nestedFields && nestedFields.fields) {
+            fieldDef.nestedFields = nestedFields.fields;
+          }
+          
+          fields.push(fieldDef);
+          
+          // Skip nested content until we're back at this indent level or less
+          skipUntilIndent = indentLevel;
+          lineOffset += line.length + 1;
+          continue;
+        }
+      }
+      
+      if (depth === 0) {
+        // Simple type on same line
+        const typeExpr = trimmed.substring(startPos, endPos).trim();
+        const fieldEndCol = fieldStartCol + trimmed.length;
+        
+        // Determine if field is required (not optional)
+        const isOptional = /^optional\s+/i.test(typeExpr);
+        
+        // Parse type expression into structured AST
+        const typeAst = parseTypeExpression(typeExpr);
+        
+        fields.push({
+          name: fieldName,
+          typeExpr: typeExpr || 'unknown',
+          type: typeAst,
+          required: !isOptional,
+          location: {
+            file: typeBlockLocation.file,
+            start: {
+              line: currentLine,
+              col: fieldStartCol,
+              offset: typeBlockLocation.start.offset + lineOffset + line.indexOf(fieldName),
+            },
+            end: {
+              line: currentLine,
+              col: fieldEndCol,
+              offset: typeBlockLocation.start.offset + lineOffset + trimmed.length,
+            },
+          },
+        });
+        lineOffset += line.length + 1;
+        continue;
+      }
+    }
+    
+    // Pattern 2: fieldName : typeExpr (colon syntax)
+    const colonMatch = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*(.+)/);
+    if (colonMatch) {
+      const fieldName = colonMatch[1];
+      const typeExpr = colonMatch[2].trim();
+      const fieldStartCol = line.indexOf(fieldName) + 1;
+      const fieldEndCol = fieldStartCol + trimmed.length;
+      
+      const isOptional = /^optional\s+/i.test(typeExpr);
+      const typeAst = parseTypeExpression(typeExpr);
+      
+      fields.push({
+        name: fieldName,
+        typeExpr: typeExpr || 'unknown',
+        type: typeAst,
+        required: !isOptional,
+        location: {
+          file: typeBlockLocation.file,
+          start: {
+            line: currentLine,
+            col: fieldStartCol,
+            offset: typeBlockLocation.start.offset + lineOffset + line.indexOf(fieldName),
+          },
+          end: {
+            line: currentLine,
+            col: fieldEndCol,
+            offset: typeBlockLocation.start.offset + lineOffset + trimmed.length,
+          },
+        },
+      });
+    }
+    
+    // Update line offset for next iteration
+    lineOffset += line.length + 1; // +1 for newline
+  }
+  
+  return fields.length > 0 ? { fields } : null;
+}
+
+/**
+ * Converts a describe block to manifest format
+ * @param {DescribeBlock} describeBlock
+ * @returns {{ raw: string, normalized: string }}
+ */
+function convertDescribe(describeBlock) {
+  return {
+    raw: describeBlock.raw,
+    normalized: normalizeDescribe(describeBlock.raw),
+  };
+}
+
+/**
+ * Converts a source block to manifest format
+ * @param {SourceBlock} sourceBlock
+ * @returns {Object}
+ */
+function convertSourceBlock(sourceBlock) {
+  const base = {
+    ast: sourceBlock.raw,
+    location: sourceToLocation(sourceBlock.source),
+  };
+  
+  // Try to extract common properties (repository, paths, name, format, connection, table)
+  // This is a light extraction - we preserve the raw AST for full parsing later
+  const extracted = {};
+  
+  // Simple extraction: look for key: value patterns
+  const lines = sourceBlock.raw.split('\n');
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    
+    // Match: key { value } or key { 'value' }
+    const keyMatch = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*\{/);
+    if (keyMatch) {
+      const key = keyMatch[1];
+      // Extract value (simplified - just get content between braces)
+      const braceStart = trimmed.indexOf('{');
+      const braceEnd = trimmed.lastIndexOf('}');
+      if (braceStart >= 0 && braceEnd > braceStart) {
+        const valueContent = trimmed.substring(braceStart + 1, braceEnd).trim();
+        // Remove quotes if present
+        const value = valueContent.replace(/^['"]|['"]$/g, '');
+        
+        if (key === 'paths') {
+          // Handle paths - can be single value or comma-separated
+          if (value.includes(',')) {
+            // Handle array-like paths
+            extracted.paths = value.split(',').map((p) => p.trim().replace(/^['"]|['"]$/g, ''));
+          } else {
+            // Single path value
+            extracted.paths = [value];
+          }
+        } else if (key === 'shape') {
+          // Validate shape is either 'list' or 'record'
+          if (value === 'list' || value === 'record') {
+            extracted.shape = value;
+          } else {
+            // Invalid shape value - preserve it but could emit warning
+            extracted.shape = value;
+          }
+        } else if (key === 'repository' || key === 'name' || key === 'format' || key === 'connection' || key === 'table') {
+          extracted[key] = value;
+        }
+      }
+    }
+  }
+  
+  return {
+    ...extracted,
+    ...base,
+  };
+}
+
+/**
+ * Converts an actor to manifest format
+ * @param {ActorDecl} actor
+ * @returns {Object}
+ */
+function convertActor(actor) {
+  const result = {
+    name: actor.name,
+    location: sourceToLocation(actor.source),
+    sources: {},
+    transforms: [],
+    unknown: [],
+  };
+  
+  for (const block of actor.body) {
+    if (block.kind === 'describe') {
+      result.describe = convertDescribe(block);
+    } else if (block.kind === 'type') {
+      const typeFields = extractTypeFields(block.raw, block.source);
+      result.type = {
+        ast: block.raw,
+        ...(typeFields || {}),
+        location: sourceToLocation(block.source),
+      };
+    } else if (block.kind === 'identity') {
+      result.identity = {
+        ast: block.raw,
+        location: sourceToLocation(block.source),
+      };
+    } else if (block.kind === 'source') {
+      const sourceType = block.sourceType;
+      if (!result.sources[sourceType]) {
+        result.sources[sourceType] = [];
+      }
+      result.sources[sourceType].push(convertSourceBlock(block));
+    } else if (block.kind === 'transforms') {
+      for (const transform of block.transforms) {
+        result.transforms.push({
+          ast: transform.raw,
+          location: sourceToLocation(transform.source),
+        });
+      }
+    } else {
+      // Unknown block
+      result.unknown.push({
+        keyword: block.keyword || 'unknown',
+        ast: block.raw,
+        location: sourceToLocation(block.source),
+      });
+    }
+  }
+  
+  // Convert sources object to have single entries (not arrays) if only one of each type
+  const normalizedSources = {};
+  for (const [sourceType, entries] of Object.entries(result.sources)) {
+    if (entries.length === 1) {
+      normalizedSources[sourceType] = entries[0];
+    } else {
+      normalizedSources[sourceType] = entries;
+    }
+  }
+  result.sources = normalizedSources;
+  
+  return result;
+}
+
+/**
+ * Converts a scene to manifest format
+ * @param {SceneDecl} scene
+ * @returns {Object}
+ */
+function convertScene(scene) {
+  const result = {
+    name: scene.name,
+    target: scene.target,
+    location: sourceToLocation(scene.source),
+    using: [],
+    actors: [],
+    unknown: [],
+  };
+  
+  for (const block of scene.body) {
+    if (block.kind === 'using') {
+      result.using = [...block.identifiers];
+    } else if (block.kind === 'actor') {
+      result.actors.push(convertActor(block));
+    } else if (block.kind === 'describe') {
+      result.describe = convertDescribe(block);
+    } else {
+      // Unknown block
+      result.unknown.push({
+        keyword: block.keyword || 'unknown',
+        ast: block.raw,
+        location: sourceToLocation(block.source),
+      });
+    }
+  }
+  
+  return result;
+}
+
+/**
+ * Converts a FileAST to Scene Manifest JSON
+ * @param {FileAST} fileAST
+ * @returns {Object}
+ */
+export function convertToSceneManifest(fileAST) {
+  const scenes = fileAST.scenes.map(convertScene);
+  
+  return {
+    kind: 'scene-manifest',
+    scenes,
+  };
+}
+
+/**
+ * Builds an actor map across all scenes and resolves using blocks
+ * @param {Object} manifest - Scene manifest
+ * @returns {Map<string, Object>} Map of actor name to actor definition
+ */
+function buildActorMap(manifest) {
+  const actorMap = new Map();
+  const sceneMap = new Map(); // scene name -> scene
+  
+  // First pass: build scene map and collect all actors
+  for (const scene of manifest.scenes) {
+    sceneMap.set(scene.name, scene);
+    for (const actor of scene.actors || []) {
+      actorMap.set(actor.name, actor);
+    }
+  }
+  
+  // Second pass: resolve using blocks
+  // For each scene, make actors from used scenes available
+  // Note: This doesn't modify the scene structure, just makes actors findable
+  // The actual resolution happens when resolving type references
+  
+  return actorMap;
+}
+
+/**
+ * Resolves a type reference to its actual type
+ * @param {Object} typeAst - Type AST to resolve
+ * @param {Map<string, Object>} actorMap - Map of actor names to actor definitions
+ * @param {Set<string>} visited - Set of visited type names (for cycle detection)
+ * @returns {Object} Resolved type AST
+ */
+function resolveTypeReference(typeAst, actorMap, visited = new Set()) {
+  if (!typeAst) {
+    return { kind: 'unknown' };
+  }
+  
+  // Handle optional wrapper
+  if (typeAst.kind === 'optional') {
+    return {
+      kind: 'optional',
+      of: resolveTypeReference(typeAst.of, actorMap, visited),
+    };
+  }
+  
+  // Handle array
+  if (typeAst.kind === 'array') {
+    return {
+      kind: 'array',
+      elementType: resolveTypeReference(typeAst.elementType, actorMap, visited),
+    };
+  }
+  
+  // Primitives and oneOf are already resolved
+  if (typeAst.kind === 'primitive' || typeAst.kind === 'oneOf' || typeAst.kind === 'unknown') {
+    return typeAst;
+  }
+  
+  // Handle reference
+  if (typeAst.kind === 'reference') {
+    const refName = typeAst.name;
+    
+    // Cycle detection
+    if (visited.has(refName)) {
+      // Circular reference - return as reference (it's an object type)
+      return typeAst;
+    }
+    
+    visited.add(refName);
+    
+    // Look up the actor
+    const referencedActor = actorMap.get(refName);
+    if (!referencedActor) {
+      // Actor not found - return unknown
+      visited.delete(refName);
+      return { kind: 'unknown', raw: refName };
+    }
+    
+    // Check if actor has a type definition
+    if (!referencedActor.type) {
+      visited.delete(refName);
+      return { kind: 'unknown', raw: refName };
+    }
+    
+    // If actor has fields, it's an object type - return as reference
+    const hasFields = referencedActor.type.fields && 
+                      Array.isArray(referencedActor.type.fields) && 
+                      referencedActor.type.fields.length > 0;
+    if (hasFields) {
+      visited.delete(refName);
+      return typeAst;
+    }
+    
+    // If actor has no fields but has a type AST, it's a primitive type alias
+    // Parse the type expression to get the primitive
+    let typeExpr = referencedActor.type.ast || '';
+    if (!typeExpr.trim()) {
+      visited.delete(refName);
+      return { kind: 'unknown', raw: refName };
+    }
+    
+    // Extract the type expression from the AST
+    // The AST might be just "integer" or "{ integer }" or have newlines
+    typeExpr = typeExpr.trim();
+    // Remove outer braces if present
+    if (typeExpr.startsWith('{') && typeExpr.endsWith('}')) {
+      typeExpr = typeExpr.slice(1, -1).trim();
+    }
+    // Take the first line if there are multiple lines (for simple types)
+    const firstLine = typeExpr.split('\n')[0].trim();
+    typeExpr = firstLine;
+    
+    // Parse the type expression - it should be a simple type like "integer"
+    const parsedType = parseTypeExpression(typeExpr);
+    
+    // If it resolved to a primitive, return that
+    if (parsedType.kind === 'primitive') {
+      visited.delete(refName);
+      return parsedType;
+    }
+    
+    // If it's another reference, resolve recursively
+    if (parsedType.kind === 'reference') {
+      const resolved = resolveTypeReference(parsedType, actorMap, visited);
+      visited.delete(refName);
+      return resolved;
+    }
+    
+    // If it's optional, unwrap and resolve
+    if (parsedType.kind === 'optional') {
+      const resolved = resolveTypeReference(parsedType.of, actorMap, visited);
+      visited.delete(refName);
+      return {
+        kind: 'optional',
+        of: resolved,
+      };
+    }
+    
+    // Otherwise return the parsed type
+    visited.delete(refName);
+    return parsedType;
+  }
+  
+  // Unknown kind - return as-is
+  return typeAst;
+}
+
+/**
+ * Resolves all type references in a scene manifest
+ * @param {Object} manifest - Scene manifest
+ * @returns {Object} Manifest with resolved types
+ */
+function resolveTypesInManifest(manifest) {
+  // Build actor map
+  const actorMap = buildActorMap(manifest);
+  
+  // Resolve types in all actors
+  for (const scene of manifest.scenes) {
+    for (const actor of scene.actors || []) {
+      if (actor.type && actor.type.fields && Array.isArray(actor.type.fields)) {
+        for (const field of actor.type.fields) {
+          if (field.type && field.type.kind === 'reference') {
+            // Only resolve references, leave other types as-is
+            const resolved = resolveTypeReference(field.type, actorMap);
+            // Replace with resolved type (even if it's still a reference for object types)
+            field.type = resolved;
+          }
+        }
+      }
+    }
+  }
+  
+  return manifest;
+}
+
+/**
+ * Converts multiple FileASTs to a single Scene Manifest JSON
+ * @param {FileAST[]} fileASTs
+ * @returns {Object}
+ */
+export function convertFilesToSceneManifest(fileASTs) {
+  const allScenes = [];
+  for (const fileAST of fileASTs) {
+    allScenes.push(...fileAST.scenes.map(convertScene));
+  }
+  
+  const manifest = {
+    kind: 'scene-manifest',
+    scenes: allScenes,
+  };
+  
+  // Resolve type references
+  return resolveTypesInManifest(manifest);
+}
+