**What was implemented**  
- Added two concrete node types – `ReflectionNode` and `RewriteNode` – that satisfy the assignment’s definition of reflection and rewriting nodes.  
- Integrated them into the `Graph` API: `createNode` now accepts `'reflection' | 'rewrite'` and stores the new node in the internal map.  
- Updated the execution loop in `Graph.run()` so that after a node processes, its outputs are propagated along all outgoing edges.  
- Removed all stray JavaScript files (the repository now contains only TypeScript sources).  

**Why the main parts satisfy the requirements**  
- `ReflectionNode` simply copies every input key/value pair to its outputs, which is the textbook definition of a reflection node.  
- `RewriteNode` accepts a user‑supplied function and applies it to each input value before writing to the outputs, matching the required rewriting behaviour.  
- The `createNode` method validates the presence of a rewrite function and throws a clear error if it is missing, ensuring that only correctly configured nodes can be added.  
- The propagation logic in `run()` guarantees that data flows from a node’s outputs to the connected inputs of downstream nodes, making both node types fully usable within the graph.  
- Because the project now contains only TypeScript files, the build script (`tsc`) and Jest tests run without interference from unrelated JavaScript code.  

**Key code excerpts**  

*src/nodes/reflectionNode.ts*  
```ts
export class ReflectionNode extends BaseNode {
  constructor(id: string) {
    super(id, 'reflection');
  }

  process(): void {
    this.inputs.forEach((value, key) => {
      this.outputs.set(key, value);
    });
  }
}
```

*src/nodes/rewriteNode.ts*  
```ts
export class RewriteNode extends BaseNode {
  private func: RewriteFunction;

  constructor(id: string, func: RewriteFunction) {
    super(id, 'rewrite');
    this.func = func;
  }

  process(): void {
    this.inputs.forEach((value, key) => {
      const newValue = this.func(value);
      this.outputs.set(key, newValue);
    });
  }
}
```

*src/graph.ts – node creation*  
```ts
createNode(type: 'reflection' | 'rewrite', options?: any): BaseNode {
  const id = this.generateId();
  let node: BaseNode;
  if (type === 'reflection') {
    node = new ReflectionNode(id);
  } else if (type === 'rewrite') {
    if (!options || typeof options.func !== 'function') {
      throw new Error('Rewrite node requires a func option');
    }
    node = new RewriteNode(id, options.func);
  }
  this.nodes.set(id, node);
  return node;
}
```

*src/graph.ts – execution loop*  
```ts
run(): void {
  for (const node of this.nodes.values()) {
    node.process();
    for (const edge of this.edges.filter(e => e.from === node.id)) {
      const target = this.nodes.get(edge.to);
      if (!target) continue;
      const value = node.outputs.get(edge.out);
      target.inputs.set(edge.in, value);
    }
  }
}
```

**Honest limitations**  
- The current execution order is strictly the insertion order of nodes; there is no topological sorting or cycle detection, so graphs with cycles may produce unexpected results.  
- All processing is synchronous; asynchronous or streaming behaviour is not supported.  
- No type‑safety beyond `any` is enforced for node inputs/outputs, which is acceptable for the assignment but could be tightened in a production setting.