todo.txt

X editing renderers making and showing updates
X render client command line errors
X save references
X resolve references
X save files
X link files to upload and request loop
X expose creating persistant object to command line
X gaurd against circular references to container types
X special "render" field
X     ctrl + e to get into edit mode for object
X special "permissions" field
X associate proper agent for each function so authorize can
X   check permissions
X write all updates into the root file for persist
X layer svg components properly //  trouble rooted in incompatible svg and html rendering pipelines
X List  operations
X persist list operations
X send List operations to watching
X self is a serializable reference to current object
X generic List renderer
X reference renderer
X persistant meta operations on persistant objects
X     owner
X     type
X utility to rebind watching functions to a different reference
X     useful for lists when indices change
X     ... may be useful in future, for now, it is helpful enough
X         to notify watchers of references in an object that a container change occurred
X pass back function to change watching renderer from each function
X queue watch updates and send as group (guaranteed order and better network performance)
X respect self, root and remote reference beginnings (rather than resolving everything to actual ids)
X reference renderer
X expose promises
X     when calling "then" you can provide:
X         a function in a container
X             this will be executed in the container's context
X         a reference to a function to be executed
X         you cannot provide a newly defined function
X             if you could, scoped variables would
X             be hard to manage
X     the generic renderer for a persistant object should
X         show all promises taken out for that object
X             - resolved ones and future ones on delay should render
X             on a timeline
X             - unresolved ones not waiting on a delay should be
X             available near the timeline
X         show the state of the promise
X delay function
X     returns a promise that will resolve after a specified time
X     or at a specified time
X expose modules
X     modules are loaded as soon as they are used and can
X     have a generic renderer that can be seen when inspecting
X     a reference to the module. This renderer should be used for
X     module administration (ex: redis-cli/viewer)
X     modules are exposed via: module.MODULE_NAME
X         need way to restrict require to pull only from specified directory
X make module references persistant
X persist delay function
X    do this by making an optional argument to promise for a
X    time to fulfill the promise if not yet fulfilled
X Client datatype
X     immutable type
X     allow people to open a node that shows the result
X         a renderer should know if it being opened in a graph of source, so the renderer can open subsequent nodes
X     specify a dsl when create it
X     allow people to edit the DSL with syntax highlighting
X normalize interface for editor saving (so strings and clients can use it now)
X     current tools are good enough since clients and strings have different enough cases
  nodes rendering, layering, and hiding as they should.
  move jumping between nodes and parents into layout module
  different arcs for references to already rendered versions
  resource utilization monitoring
  history
  usage
  basic tests
  clone
  merge
-- release!
  testing suite
      website that allows users to write tests against the api
      and submit them to the testing framework.
  auto optimization / distribution