diff --git a/Makefile b/Makefile
index e2cd4db..29a0db8 100644
--- a/Makefile
+++ b/Makefile
@@ -19,10 +19,10 @@ MODULES         := utility reactive graph model dfa plan enable system bind \
                    async hd qunit compile-dfa fn-worker
 
 utility_LOC     := hd/
-utility_UNITS   := adt helpers console schedule
+utility_UNITS   := adt helpers console schedule api
 
 reactive_LOC    := hd/
-reactive_UNITS  := observable property extensions promise ladder function logger
+reactive_UNITS  := observable property extensions promise accum ladder function logger api
 reactive_DEPS   := utility
 
 graph_LOC       := hd/
@@ -30,7 +30,7 @@ graph_UNITS     := walker digraph cgraph sgraph stay
 graph_DEPS      := utility reactive
 
 model_LOC       := hd/
-model_UNITS     := ids variable method constraint context eqn builder path command array
+model_UNITS     := ids variable method constraint context eqn builder path command array api
 model_DEPS      := utility reactive
 
 dfa_LOC         := hd/
@@ -46,18 +46,18 @@ enable_UNITS    := egraph report check
 enable_DEPS     := utility reactive graph
 
 system_LOC      := hd/
-system_UNITS    := pm activate topo
+system_UNITS    := pm activate topo api
 system_DEPS     := utility reactive graph model plan enable
 
 bind_LOC        := hd/
-bind_UNITS      := binding text edit css select checked enable mouse position clicked time forEach when rx factory
+bind_UNITS      := binding text edit css select checked enable mouse position clicked key time forEach when rx factory api
 bind_DEPS       := utility reactive model
 
 async_LOC       := hd/
 async_UNITS     := worker ajax
 async_DEPS      := utility reactive
 
-hd_UNITS        := api methods
+hd_UNITS        := api
 hd_DEPS         := utility reactive model graph plan enable bind system
 
 qunit_UNITS     := qunit.d utility reactive ladder graph model system
@@ -83,10 +83,12 @@ howto_RES    := style.css collapse.js spinner.gif
 ######################################################################
 # Target definitions
 
-TARGETS          := hotdrink qunit compile-dfa fn-worker
+TARGETS          := hotdrink hotpdf qunit compile-dfa fn-worker
 
 hotdrink_MODS    := utility reactive graph model dfa plan enable system bind async hd
 
+hotpdf_MODS      := utility reactive graph model dfa plan enable system hd
+
 qunit_MODS       := qunit
 
 compile-dfa_MODS := shebang $(hotdrink_MODS) compile-dfa
@@ -164,7 +166,7 @@ help:
 $(TARGETS) : % : $(TARGET_DIR)/$$*.js
 
 .PHONY :
-all : $(TARGETS) hotdrink.min howto
+all : $(TARGETS) hotdrink.min hotpdf.min howto
 
 .PHONY :
 clean :
@@ -197,14 +199,17 @@ $(TARGET_MAPS) : $(TARGET_DIR)/%.js.map : $(TARGET_DIR)/%.js ;
 
 .SECONDEXPANSION :
 $(TARGET_FILES) :: $(TARGET_DIR)/%.js : $$($$*_TGT_MAPS) $$($$*_TGT_FILES) | $(TARGET_DIR)
-	@if which -s mapcat ; then                                                   \
+	@if which mapcat ; then                                                      \
 	  echo mapcat -j $(TARGET_DIR)/$*.js -m $(TARGET_DIR)/$*.js.map              \
 	    $($*_TGT_MAPS) ;                                                         \
 	  mapcat -j $(TARGET_DIR)/$*.js -m $(TARGET_DIR)/$*.js.map $($*_TGT_MAPS) ;  \
 	else                                                                         \
 	  echo "make: *** Missing mapcat - cannot make scripts/$*.js.map" 1>&2 ;     \
 	  echo cat $($*_TGT_FILES) ">" $@ ;                                          \
-	  cat $($*_TGT_FILES) > $@ ;                                                 \
+	  for file in $($*_TGT_FILES) ; do                                           \
+	    cat "$${file}" ;                                                         \
+	    echo ;                                                                   \
+	  done > $@ ;                                                                \
 	fi
 
 .SECONDEXPANSION :
@@ -225,6 +230,14 @@ $(TARGET_DIR)/hotdrink.min.js : $(TARGET_DIR)/hotdrink.js
 	uglifyjs $< -m -c warnings=false -o $@
 
 
+hotpdf.min : $(TARGET_DIR)/hotpdf.min.js
+
+$(TARGET_DIR)/hotpdf.min.js.map: $(TARGET_DIR)/hotpdf.min.js
+
+$(TARGET_DIR)/hotpdf.min.js : $(TARGET_DIR)/hotpdf.js
+	uglifyjs $< -m -c warnings=false -o $@
+
+
 howto: $(howto_DEP_FILES) $(howto_FILES) $(howto_RES_FILES)
 
 $(howto_FILES) :: $(HOWTO_DIR)/$(PUBLISH_DIR)/%.html : $(HOWTO_DIR)/%.org publish-org.el | $(HOWTO_DIR)/$(TANGLE_DIR) $(HOWTO_DIR)/$(PUBLISH_DIR)
diff --git a/src/hd/api.ts b/src/hd/api.ts
index 56c7b8e..d4180cd 100644
--- a/src/hd/api.ts
+++ b/src/hd/api.ts
@@ -8,121 +8,72 @@ module hd {
   import s = hd.system;
   import b = hd.bindings;
 
-  export function arrayOf( elementType: m.ContextClass|m.ContextSpec ) {
-    return m.ArrayContext.bind( null, elementType );
+  export
+  function id<T>( x: T ): T {
+    return x;
   }
 
-  export var array = m.ArrayContext;
-
-  /*==================================================================
-   * Enablement functions
-   */
-
-  export function markUsed( p: r.Promise<any> ) {
-    p.usage.set( r.Usage.Used );
+  export
+  function sum() {
+    var n = arguments[0];
+    for (var i = 1, l = arguments.length; i < l; ++i) {
+      n+= arguments[i];
+    }
+    return n;
   }
 
-  export function markUnused( p: r.Promise<any> ) {
-    p.usage.set( r.Usage.Unused );
+  export
+  function diff() {
+    var n = arguments[0];
+    for (var i = 1, l = arguments.length; i < l; ++i) {
+      n-= arguments[i];
+    }
+    return n;
   }
 
-  export function markDelayed( p: r.Promise<any> ) {
-    p.usage.set( r.Usage.Delayed );
+  export
+  function prod() {
+    var n = arguments[0];
+    for (var i = 1, l = arguments.length; i < l; ++i) {
+      n-= arguments[i];
+    }
+    return n;
   }
 
-  /*==================================================================
-   * Export
-   */
-
-  export var dateCompare = u.dateCompare;
-  export var ProxyObserver = r.ProxyObserver;
-  export var BasicObservable = r.BasicObservable;
-  export var Promise = r.Promise;
-  export var Translator = r.Extension;
-  export var liftFunction = r.liftFunction;
-
-  export var dir = b.Direction;
-  export var bind = b.bind;
-  export var unbind = b.unbind;
-  export var performDeclaredBindings = b.performDeclaredBindings;
-  export var isObservable = b.isObservable;
-  export var isObserver = b.isObserver;
-  export var isExtension = b.isExtension;
-
-  export var Variable = m.Variable;
-  export var Constraint = m.Constraint;
-  export var Method = m.Method;
-  export var Context = m.Context;
-  export var ArrayContext = m.ArrayContext;
-  export var MaxOptional = m.Optional.Max;
-  export var MinOptional = m.Optional.Min;
-
-  // RunTime
-  export var PropertyModel = s.PropertyModel;
-  export var ContextBuilder = m.ContextBuilder;
+  export
+  function quot() {
+    var n = arguments[0];
+    for (var i = 1, l = arguments.length; i < l; ++i) {
+      n/= arguments[i];
+    }
+  }
 
-  // Bindings
-  export var Checked = b.Checked;
-  export var Click = b.Click;
-  export var CssClass = b.CssClass;
-  export var DblClick = b.DblClick;
-  export var Edit = b.Edit;
-  export var Enabled = b.Enabled;
-  export var MouseDown = b.MouseDown;
-  export var MouseUp = b.MouseUp;
-  export var MousePosition = b.MousePosition;
-  export var Position = b.Position;
-  export var Text = b.Text;
-  export var Time = b.Time;
-  export var Value = b.Value;
+  export
+  function max() {
+    var n: any;
+    for (var i = 0, l = arguments.length; i < l && n === undefined; ++i) {
+      n = arguments[i];
+    }
+    for (; i < l; ++i) {
+      if (arguments[i] > n) {
+        n = arguments[i];
+      }
+    }
+    return n;
+  }
 
-  // Factories
-  export var checked = b.checked;
-  export var click = b.click;
-  export var cssClass = b.cssClass;
-  export var dblclick = b.dblclick;
-  export var edit = b.edit;
-  export var editVar = b.editVar;
-  export var date = b.date;
-  export var dateVar = b.dateVar;
-  export var enabled = b.enabled;
-  export var forEach = b.forEach;
-  export var mousedown = b.mousedown;
-  export var mouseup = b.mouseup;
-  export var mousePosition = b.getMousePosition;
-  export var num = b.num;
-  export var numVar = b.numVar;
-  export var position = b.position;
-  export var text = b.text;
-  export var value = b.value;
-  export var when = b.when;
+  export
+  function min() {
+    var n: any;
+    for (var i = 0, l = arguments.length; i < l && n === undefined; ++i) {
+      n = arguments[i];
+    }
+    for (; i < l; ++i) {
+      if (arguments[i] < n) {
+        n = arguments[i];
+      }
+    }
+    return n;
+  }
 
-  // Extensions
-  export var chain = b.chain;
-  export var cn = b.cn;
-  export var dateToMilliseconds = b.dateToMilliseconds;
-  export var dateToDateString = b.dateToDateString;
-  export var dateToString = b.dateToString;
-  export var dateToTimeString = b.dateToTimeString;
-  export var def = b.def;
-  export var delay = b.delay;
-  export var exp = b.exp;
-  export var fix = b.fix;
-  export var fn = b.fn;
-  export var millisecondsToDate = b.millisecondsToDate;
-  export var msg = b.msg;
-  export var offset = b.offset;
-  export var path = b.path;
-  export var or = b.or;
-  export var pointToString = b.pointToString;
-  export var prec = b.prec;
-  export var rw = b.rw;
-  export var req = b.req;
-  export var round = b.round;
-  export var scale = b.scale;
-  export var stabilize = b.stabilize;
-  export var toDate = b.toDate;
-  export var toJson = b.toJson;
-  export var toNum = b.toNum;
-  export var toStr = b.toStr;
 }
diff --git a/src/hd/bind/api.ts b/src/hd/bind/api.ts
new file mode 100644
index 0000000..c7faa79
--- /dev/null
+++ b/src/hd/bind/api.ts
@@ -0,0 +1,83 @@
+module hd {
+
+  import b = hd.bindings;
+
+
+  // Export
+  export var bind = b.bind;
+  export var unbind = b.unbind;
+  export var performDeclaredBindings = b.performDeclaredBindings;
+  export var Direction = b.Direction;
+  export var isObservable = b.isObservable;
+  export var isObserver = b.isObserver;
+  export var isExtension = b.isExtension;
+
+  // Bindings
+  export var Change = b.Change;
+  export var Checked = b.Checked;
+  export var Click = b.Click;
+  export var CssClass = b.CssClass;
+  export var DblClick = b.DblClick;
+  export var Edit = b.Edit;
+  export var Enabled = b.Enabled;
+  export var KeyDown = b.KeyDown;
+  export var MouseDown = b.MouseDown;
+  export var MouseUp = b.MouseUp;
+  export var MousePosition = b.MousePosition;
+  export var Position = b.Position;
+  export var Text = b.Text;
+  export var Time = b.Time;
+  export var Value = b.Value;
+
+  export var OnlyKey = b.OnlyKey;
+
+  // Factories
+  export var checked = b.checked;
+  export var click = b.click;
+  export var cssClass = b.cssClass;
+  export var dblclick = b.dblclick;
+  export var edit = b.edit;
+  export var editVar = b.editVar;
+  export var date = b.date;
+  export var dateVar = b.dateVar;
+  export var enabled = b.enabled;
+  export var forEach = b.forEach;
+  export var mousedown = b.mousedown;
+  export var mouseup = b.mouseup;
+  export var mousePosition = b.getMousePosition;
+  export var num = b.num;
+  export var numVar = b.numVar;
+  export var position = b.position;
+  export var text = b.text;
+  export var value = b.value;
+  export var when = b.when;
+
+  // Extensions
+  export var chain = b.chain;
+  export var cn = b.cn;
+  export var dateToMilliseconds = b.dateToMilliseconds;
+  export var dateToDateString = b.dateToDateString;
+  export var dateToString = b.dateToString;
+  export var dateToTimeString = b.dateToTimeString;
+  export var def = b.def;
+  export var delay = b.delay;
+  export var exp = b.exp;
+  export var fix = b.fix;
+  export var fn = b.fn;
+  export var millisecondsToDate = b.millisecondsToDate;
+  export var msg = b.msg;
+  export var offset = b.offset;
+  export var path = b.path;
+  export var or = b.or;
+  export var pointToString = b.pointToString;
+  export var prec = b.prec;
+  export var rw = b.rw;
+  export var req = b.req;
+  export var round = b.round;
+  export var scale = b.scale;
+  export var stabilize = b.stabilize;
+  export var toDate = b.toDate;
+  export var toJson = b.toJson;
+  export var toNum = b.toNum;
+  export var toStr = b.toStr;
+}
diff --git a/src/hd/bind/binding.ts b/src/hd/bind/binding.ts
index 99931e1..169085f 100644
--- a/src/hd/bind/binding.ts
+++ b/src/hd/bind/binding.ts
@@ -84,9 +84,7 @@ module hd.bindings {
   export
   function isObserver( t: Target ): boolean {
     return (typeof t === 'object' &&
-            typeof t.onNext === 'function' &&
-            typeof t.onError === 'function' &&
-            typeof t.onCompleted === 'function');
+            typeof t.onNext === 'function');
   }
 
   // Make sure object is observable
@@ -102,8 +100,6 @@ module hd.bindings {
   function isExtension( t: Target ): boolean {
     return (typeof t === 'object' &&
             typeof t.onNext === 'function' &&
-            typeof t.onError === 'function' &&
-            typeof t.onCompleted === 'function' &&
             typeof t.addObserver === 'function' &&
             typeof t.removeObserver === 'function');
   }
@@ -298,10 +294,10 @@ module hd.bindings {
       return scope;
     }
     try {
-      var elBindingsFn = new Function( functionBody );
-      var elNestedBindings: any[] = elBindingsFn.call( scope );
+      var elBindingsFn = new Function( 'model', functionBody );
+      var elNestedBindings: u.MultiArray<Binding> = elBindingsFn.call( el, scope );
       var elBindings: Binding[] = [];
-      flatten( elNestedBindings, elBindings );
+      u.multiArray.flatten( elNestedBindings, elBindings );
     }
     catch (e) {
       console.error( "Invalid binding declaration: "
@@ -345,24 +341,9 @@ module hd.bindings {
    * of the constructs John implemented.
    */
   function compile( spec: string ): string {
-    return "with (this) {" +
+    return "with (model) {" +
            "  return [" + spec + "]" +
            "}";
   }
 
-  /*------------------------------------------------------------------
-   * Flatten nested lists into a single list.
-   */
-
-  function flatten<T>( from: any[], to: T[] ) {
-    for (var i = 0, l = from.length; i < l; ++i) {
-      if (Array.isArray( from[i] )) {
-        flatten( from[i], to );
-      }
-      else {
-        to.push( from[i] );
-      }
-    }
-  }
-
 }
diff --git a/src/hd/bind/clicked.ts b/src/hd/bind/clicked.ts
index 1e08675..844ee1b 100644
--- a/src/hd/bind/clicked.ts
+++ b/src/hd/bind/clicked.ts
@@ -5,7 +5,6 @@ module hd.bindings {
   export
   class MouseDown extends r.BasicObservable<any> {
 
-    value: any;
     el: HTMLElement;
 
     constructor( el: HTMLElement ) {
@@ -22,7 +21,6 @@ module hd.bindings {
   export
   class MouseUp extends r.BasicObservable<any> {
 
-    value: any;
     el: HTMLElement;
 
     constructor( el: HTMLElement ) {
diff --git a/src/hd/bind/edit.ts b/src/hd/bind/edit.ts
index 19fe117..780199b 100644
--- a/src/hd/bind/edit.ts
+++ b/src/hd/bind/edit.ts
@@ -16,14 +16,11 @@ module hd.bindings {
    * Observer/Observable for binding
    */
   export
-  class Edit {
+  class Edit extends r.BasicObservable<string> {
 
     // element bound to
     el: HTMLInputElement;
 
-    // stabilizer
-    stable: r.Stabilizer<any>;
-
     // value to change from on blur
     blurFrom: string = null;
 
@@ -37,31 +34,19 @@ module hd.bindings {
      * Initialize and subscribe to HTML editing events.
      */
     constructor( el: HTMLElement, scope: Scope, time_ms?: number ) {
+      super();
       this.el = checkHtml( el, HTMLInputElement );
-      this.stable = new r.Stabilizer( time_ms, flush );
 
       el.addEventListener( 'input', this.update.bind( this ) );
       el.addEventListener( 'change', this.onBlur.bind( this ) );
     }
 
-    /*----------------------------------------------------------------
-     */
-    addObserver( o: r.Observer<any> ) {
-      this.stable.addObserver.apply( this.stable, arguments );
-    }
-
-    /*----------------------------------------------------------------
-     */
-    removeObserver( o: r.Observer<any> ) {
-      this.stable.removeObserver.apply( this.stable, arguments );
-    }
-
     /*----------------------------------------------------------------
      * When widget is modified.
      */
     update() {
       this.initialized = true;
-      this.stable.onNext( this.el.value );
+      this.sendNext( this.el.value );
     }
 
     /*----------------------------------------------------------------
@@ -102,7 +87,7 @@ module hd.bindings {
       }
       this.blurTo = null;
       this.initialized = false;
-      this.stable.onNext( <any>flush );
+      this.sendCompleted();
     }
 
     /*----------------------------------------------------------------
diff --git a/src/hd/bind/factory.ts b/src/hd/bind/factory.ts
index 07280ee..09ab47d 100644
--- a/src/hd/bind/factory.ts
+++ b/src/hd/bind/factory.ts
@@ -37,7 +37,7 @@ module hd.bindings {
             model: target,
             dir: Direction.bi,
             toView: toView,
-            toModel: toModel
+            toModel: concat( toModel, new r.Stabilizer() )
            };
   }
 
@@ -61,7 +61,8 @@ module hd.bindings {
               model: target,
               dir: Direction.bi,
               toView: toView,
-              toModel: concat( new r.ToNumber(), toModel )
+              toModel: concat( concat( new r.ToNumber(), toModel ),
+                               new r.Stabilizer() )
              };
     }
     else {
@@ -71,7 +72,8 @@ module hd.bindings {
               toView: concat( toView, places >= 0 ? new r.NumberToFixed( places )
                                                   : new r.Round( places )
                             ),
-              toModel: concat( [new r.ToNumber(), new r.Round( places )], toModel )
+              toModel: concat( concat( [new r.ToNumber(), new r.Round( places )], toModel ),
+                               new r.Stabilizer() )
              };
     }
   }
@@ -95,7 +97,8 @@ module hd.bindings {
             model: target,
             dir: Direction.bi,
             toView: concat( toView, new r.DateToDateString() ),
-            toModel: concat( new r.ToDate(), toModel )
+            toModel: concat( concat( new r.ToDate(), toModel ),
+                             new r.Stabilizer() )
            };
   }
 
diff --git a/src/hd/bind/key.ts b/src/hd/bind/key.ts
new file mode 100644
index 0000000..124978d
--- /dev/null
+++ b/src/hd/bind/key.ts
@@ -0,0 +1,52 @@
+module hd.bindings {
+
+  import r = hd.reactive;
+
+  export
+  class KeyDown extends r.BasicObservable<KeyboardEvent> {
+
+    el: HTMLElement;
+
+    constructor( el: HTMLElement ) {
+      super();
+      this.el = checkHtml( el, HTMLElement );
+      this.el.addEventListener( 'keydown', this.onkeydown.bind( this ) );
+    }
+
+    onkeydown( e: KeyboardEvent ) {
+      this.sendNext( e );
+    }
+
+  }
+
+  export
+  class Change extends r.BasicObservable<Event> {
+
+    el: HTMLElement;
+
+    constructor( el: HTMLElement ) {
+      super();
+      this.el = checkHtml( el, HTMLElement );
+      this.el.addEventListener( 'change', this.onchange.bind( this ) );
+    }
+
+    onchange( e: Event ) {
+      this.sendNext( e );
+    }
+
+  }
+
+  export
+  class OnlyKey extends r.Extension<KeyboardEvent, KeyboardEvent> {
+    constructor( private keyCode: number ) {
+      super();
+    }
+
+    onNext( e: KeyboardEvent ) {
+      if (e.keyCode == this.keyCode) {
+        this.sendNext( e );
+      }
+    }
+  }
+
+}
diff --git a/src/hd/bind/rx.ts b/src/hd/bind/rx.ts
index 996db35..ef8ad4e 100644
--- a/src/hd/bind/rx.ts
+++ b/src/hd/bind/rx.ts
@@ -82,8 +82,8 @@ module hd.bindings {
   }
 
   export
-  function stabilize( time_ms: number, flush?: Object ) {
-    return new r.Stabilizer( time_ms, flush );
+  function stabilize( time_ms: number ) {
+    return new r.Stabilizer( time_ms );
   }
 
   export
diff --git a/src/hd/methods.ts b/src/hd/methods.ts
deleted file mode 100644
index 7e27dd7..0000000
--- a/src/hd/methods.ts
+++ /dev/null
@@ -1,71 +0,0 @@
-module hd {
-
-  export
-  function id<T>( x: T ): T {
-    return x;
-  }
-
-  export
-  function sum() {
-    var n = arguments[0];
-    for (var i = 1, l = arguments.length; i < l; ++i) {
-      n+= arguments[i];
-    }
-    return n;
-  }
-
-  export
-  function diff() {
-    var n = arguments[0];
-    for (var i = 1, l = arguments.length; i < l; ++i) {
-      n-= arguments[i];
-    }
-    return n;
-  }
-
-  export
-  function prod() {
-    var n = arguments[0];
-    for (var i = 1, l = arguments.length; i < l; ++i) {
-      n-= arguments[i];
-    }
-    return n;
-  }
-
-  export
-  function quot() {
-    var n = arguments[0];
-    for (var i = 1, l = arguments.length; i < l; ++i) {
-      n/= arguments[i];
-    }
-  }
-
-  export
-  function max() {
-    var n: any;
-    for (var i = 0, l = arguments.length; i < l && n === undefined; ++i) {
-      n = arguments[i];
-    }
-    for (; i < l; ++i) {
-      if (arguments[i] > n) {
-        n = arguments[i];
-      }
-    }
-    return n;
-  }
-
-  export
-  function min() {
-    var n: any;
-    for (var i = 0, l = arguments.length; i < l && n === undefined; ++i) {
-      n = arguments[i];
-    }
-    for (; i < l; ++i) {
-      if (arguments[i] < n) {
-        n = arguments[i];
-      }
-    }
-    return n;
-  }
-
-}
diff --git a/src/hd/model/api.ts b/src/hd/model/api.ts
new file mode 100644
index 0000000..ca72485
--- /dev/null
+++ b/src/hd/model/api.ts
@@ -0,0 +1,23 @@
+module hd {
+
+  import u = hd.utility;
+  import m = hd.model;
+
+  // shortcuts for arrays
+  export function arrayOf( elementType: u.Constructor|m.ContextSpec ) {
+    return m.ArrayContext.bind( null, elementType );
+  }
+
+  export var array = m.ArrayContext;
+
+  // Exports
+  export var Variable = m.Variable;
+  export var Constraint = m.Constraint;
+  export var Method = m.Method;
+  export var Context = m.Context;
+  export var ArrayContext = m.ArrayContext;
+  export var MaxOptional = m.Optional.Max;
+  export var MinOptional = m.Optional.Min;
+  export var ContextBuilder = m.ContextBuilder;
+
+}
diff --git a/src/hd/model/array.ts b/src/hd/model/array.ts
index c6571df..aac7015 100644
--- a/src/hd/model/array.ts
+++ b/src/hd/model/array.ts
@@ -5,14 +5,6 @@ module hd.model {
   import u = hd.utility;
   import r = hd.reactive;
 
-  /*==================================================================
-   * JavaScript does not have multi-dimensional arrays, just
-   * arrays-of-arrays.  This interface just supports generic
-   * arrays-of-arrays without specifying a depth.
-   */
-  export
-  interface MultiArray<T> extends Array<T|MultiArray<T>> { };
-
   /*==================================================================
    * The ArrayContext class.
    */
@@ -38,7 +30,7 @@ module hd.model {
 
     /*----------------------------------------------------------------
      */
-    constructor( private elementType?: ContextClass|ContextSpec    ) {
+    constructor( private elementType?: u.Constructor|ContextSpec    ) {
       super();
     }
 
@@ -76,6 +68,7 @@ module hd.model {
         }
       }
 
+      this.elements.length = n;
       this.$length.set( n );
     }
 
@@ -151,9 +144,20 @@ module hd.model {
             spec = <ContextSpec>this.elementType;
           }
           for (var i = 0, l = count; i < l; ++i) {
-            var ctx = new klass();
-            if (spec) {
-              Context.construct( ctx, spec, inits[i] );
+            var ctx: any;
+            if (klass === <any>Variable) {
+              ctx = new Variable( "el" + i, inits[i] );
+            }
+            else {
+              ctx = new klass();
+              if (ctx instanceof ArrayContext) {
+                if (inits[i] !== undefined) {
+                  ctx.expand( inits[i] );
+                }
+              }
+              else if (spec) {
+                Context.construct( ctx, spec, inits[i] );
+              }
             }
             this.set( start + i, ctx );
             Context.claim( this, ctx );
diff --git a/src/hd/model/builder.ts b/src/hd/model/builder.ts
index faa31c7..7d4e0b5 100644
--- a/src/hd/model/builder.ts
+++ b/src/hd/model/builder.ts
@@ -70,6 +70,7 @@ module hd.model {
     /*----------------------------------------------------------------
      * Add a variable.
      */
+    v: <T>(loc: string, init?: T, eq?: u.EqualityPredicate<T> ) => ContextBuilder;
     variable<T>( loc: string,
                  init?: T,
                  eq?: u.EqualityPredicate<T> ): ContextBuilder {
@@ -94,6 +95,7 @@ module hd.model {
      * This convenience method allows the creation of a bunch of
      * variables at once.
      */
+    vs: ( a: string|u.Dictionary<any>, b?: u.Dictionary<any> ) => ContextBuilder;
     variables( varorder: string, vardefs?: u.Dictionary<any> ): ContextBuilder;
     variables( vardefs: u.Dictionary<any> ): ContextBuilder;
     variables() {
@@ -127,12 +129,13 @@ module hd.model {
     /*----------------------------------------------------------------
      * Add a nested context.
      */
-    nested( loc: string, klass: {new (): Context}, spec?: ContextSpec ): ContextBuilder {
+    n: (loc: string, klass: {new (): Context}, spec?: ContextSpec) => ContextBuilder;
+    nested( loc: string, ctxType?: ContextSpec ): ContextBuilder {
       this.endAll();
 
       if (this.invalidLoc( loc )) { return this; }
 
-      this.target.nesteds.push( {loc: loc, klass: klass, spec: spec} );
+      this.target.nesteds.push( {loc: loc, ctxType: ctxType} );
       this.usedLocs[loc] = true;
 
       return this;
@@ -141,6 +144,7 @@ module hd.model {
     /*----------------------------------------------------------------
      * Add a reference.
      */
+    r: (loc: string, eq?: u.EqualityPredicate<any> ) => ContextBuilder;
     reference( loc: string, eq?: u.EqualityPredicate<any> ): ContextBuilder {
       this.endAll();
 
@@ -165,6 +169,7 @@ module hd.model {
     /*----------------------------------------------------------------
      * Add a constraint to the property modelcule.
      */
+    c: ((signature: string) => ContextBuilder);
     constraint( loc: string, signature: string ): ContextBuilder;
     constraint( signature: string ): ContextBuilder;
     constraint(): ContextBuilder {
@@ -226,6 +231,7 @@ module hd.model {
     /*----------------------------------------------------------------
      * Add a method
      */
+    m: (signature: string, fn: Function, lift?: boolean ) => ContextBuilder;
     method( signature: string, fn: Function, lift = true ): ContextBuilder {
       if (! this.lastConstraint) {
         console.error( 'Builder function "method" called with no constraint' );
@@ -237,8 +243,9 @@ module hd.model {
 
       // helper function to make sure variable belongs to constraint
       var constraintVars = this.lastConstraint.variables;
-      var isNotConstraintVar = function( name: string ) {
-        if (constraintVars.indexOf( name ) < 0) {
+      var isNotConstraintVar = function( name: string, i: number ) {
+        if ((! p.priorFlags || ! p.priorFlags[i]) &&
+            constraintVars.indexOf( name ) < 0) {
           console.error( "Variable " + name +
                          " does not belong to constraint in method " + signature );
           return true;
@@ -247,17 +254,17 @@ module hd.model {
 
       };
 
-      if (p.inputs.some( isNotConstraintVar ) || p.outputs.some( isNotConstraintVar ) ) {
+      if (u.multiArray.some( p.inputs, isNotConstraintVar ) ||
+          u.multiArray.some( p.outputs, isNotConstraintVar )) {
         return this;
       }
 
-      u.arraySet.addKnownDistinct(
-        this.lastConstraint.methods,
-        {inputs: p.inputs,
-         priorFlags: p.priorFlags,
-         outputs: p.outputs,
-         fn: lift ? r.liftFunction( fn, p.outputs.length, p.promiseFlags ) : fn}
-      );
+      u.arraySet.addKnownDistinct( this.lastConstraint.methods, {
+        inputs: p.inputs,
+        priorFlags: p.priorFlags,
+        outputs: p.outputs,
+        fn: lift ? r.liftFunction( fn, p.promiseFlags ) : fn
+      } );
 
       return this;
     }
@@ -288,18 +295,23 @@ module hd.model {
 
     /*----------------------------------------------------------------
      */
-    command( loc: string,
-             signature: string,
-             fn: Function,
-             lift = true, sync = false ): ContextBuilder {
+    command(
+      loc: string,
+      signature: string,
+      fn: Function,
+      lift = true,
+      sync = false
+    ): ContextBuilder {
+
       this.endAll();
 
       if (this.invalidLoc( loc )) { return this; }
 
-      var p = parseActivation( 'method', signature );
+      var p = parseActivation( 'command', signature );
       if (p == null) { return this; }
 
-      if (p.inputs.some( invalidPath ) || p.outputs.some( invalidPath )) {
+      if (u.multiArray.some( p.inputs, invalidPath ) ||
+          u.multiArray.some( p.outputs, invalidPath )) {
         return this;
       }
 
@@ -308,7 +320,7 @@ module hd.model {
         inputs: p.inputs,
         priorFlags: p.priorFlags,
         outputs: p.outputs,
-        fn: lift ? r.liftFunction( fn, p.outputs.length, p.promiseFlags ) : fn,
+        fn: lift ? r.liftFunction( fn, p.promiseFlags ) : fn,
         synchronous: sync
       } );
 
@@ -464,6 +476,7 @@ module hd.model {
   (<any>ContextBuilder).prototype['rs']  = ContextBuilder.prototype.references;
   (<any>ContextBuilder).prototype['c']   = ContextBuilder.prototype.constraint;
   (<any>ContextBuilder).prototype['m']   = ContextBuilder.prototype.method;
+  (<any>ContextBuilder).prototype['cmd'] = ContextBuilder.prototype.command;
   (<any>ContextBuilder).prototype['o']   = ContextBuilder.prototype.output;
   (<any>ContextBuilder).prototype['os']  = ContextBuilder.prototype.outputs;
   (<any>ContextBuilder).prototype['td']  = ContextBuilder.prototype.touchDep;
@@ -472,8 +485,10 @@ module hd.model {
   /*==================================================================
    * Test for invalid variable path
    */
+  var pathRegEx = /^[a-zA-Z][\w$]*(\.[a-zA-Z][\w$]*|\[\s*(\d+|\*)\s*\]|\[\s*(\d+\s*)?[a-zA-Z][\w$]*\s*([+-]\s*\d+\s*)?\])*$/;
+
   function invalidPath( path: string ): boolean {
-    if (! path.match( /^[a-zA-Z][\w$]*(\.[a-zA-Z][\w$]*|\[\s*(\d+|\*)\s*\]|\[\s*(\d+\s*)?[a-zA-Z][\w$]*\s*([+-]\s*\d+\s*)?\])*$/ )) {
+    if (! path.match( pathRegEx )) {
       console.error( 'Invalid variable path: "' + path + '"' );
       return true;
     }
@@ -525,9 +540,38 @@ module hd.model {
     return {inputs: inputs,
             promiseFlags: promiseFlags.length == 0 ? null : promiseFlags,
             priorFlags: priorFlags.length == 0 ? null : priorFlags,
-            outputs: outputs
+            outputs: outputs.length == 1 ? outputs : [outputs]
            };
-    }
+  }
+
+  export
+  var tokensRegEx = /([\w$.]+(\[[^\]]*\][\w$.]*)*|\S)/g;
+
+  export
+  function parseList( tokens: string[], i: number, list: u.MultiArray<string> ) {
+    do {
+      if (tokens[i] === '[') {
+        var sub: string[] = [];
+        list.push( sub );
+        i = parseList( tokens, i+1, sub );
+        if (tokens[i++] !== ']') {
+          throw 'Expecting "]"';
+        }
+      }
+      else if (tokens[i] === ',' || tokens[i] === ']') {
+        throw 'Unexpected token "' + tokens[i] + '"';
+      }
+      else {
+        list.push( tokens[i++] );
+      }
+      var more = false;
+      if (tokens[i] === ',') {
+        ++i;
+        more = true;
+      }
+    } while (more);
+    return i;
+  }
 
   /*================================================================
    * Strip one-character prefixes from front of names
diff --git a/src/hd/model/command.ts b/src/hd/model/command.ts
index 707675e..5db99eb 100644
--- a/src/hd/model/command.ts
+++ b/src/hd/model/command.ts
@@ -1,5 +1,6 @@
 module hd.model {
 
+  import u = hd.utility;
   import r = hd.reactive;
 
   export
@@ -20,22 +21,22 @@ module hd.model {
     // Inputs to pass to the function, in the order they should be passed
     // Variables in this list will be replaced with their value; everything
     // else will be treated as constants to be passed to the function.
-    inputs: any[];
+    inputs: u.MultiArray<any>;
 
     // Parallel to inputs; true means input comes from prior generation
-    priorFlags: boolean[];
+    priorFlags: u.MultiArray<boolean>;
 
     // Outputs to write to, in the order they are returned form the function
-    outputs: Variable[];
+    outputs: u.MultiArray<Variable>;
 
     // Is this an external operation?  (Does it trigger an update after execution?)
     external = true;
 
     constructor( name: string,
                  fn: any,
-                 inputs: any[],
-                 priorFlags: boolean[],
-                 outputs: Variable[] ) {
+                 inputs: u.MultiArray<any>,
+                 priorFlags: u.MultiArray<boolean>,
+                 outputs: u.MultiArray<Variable> ) {
       super();
       this.id = makeId( name );
       this.name = name;
@@ -101,17 +102,22 @@ module hd.model {
 
     ready: r.Signal<boolean>;
 
-    constructor( name: string,
-                 fn: Function,
-                 inputs: any[],
-                 usePriors: boolean[],
-                 outputs: any[]        ) {
+    constructor(
+      name: string,
+      fn: Function,
+      inputs: u.MultiArray<any>,
+      usePriors: u.MultiArray<boolean>,
+      outputs: u.MultiArray<Variable>
+    ) {
+
       super( name, fn, inputs, usePriors, outputs );
       var properties: r.ProxyObservable<any>[] = [];
       for (var i = 0, l = inputs.length; i < l; ++i) {
         var vv = inputs[i];
-        properties.push( vv.pending );
-        properties.push( vv.error );
+        if (vv instanceof Variable) {
+          properties.push( vv.pending );
+          properties.push( vv.error );
+        }
       }
       this.ready = new None( properties );
     }
diff --git a/src/hd/model/context.ts b/src/hd/model/context.ts
index 0b4e4f2..c57cf1e 100644
--- a/src/hd/model/context.ts
+++ b/src/hd/model/context.ts
@@ -12,7 +12,7 @@ module hd.model {
 
   // getter for constant
   function pathConstant( p: Path ) {
-    return p.constant;
+    return p.isConstant();
   }
 
   // object that can retrieve a path for a string
@@ -25,20 +25,6 @@ module hd.model {
     id: string;
   }
 
-  // lexicographical comparison for arrays of HasId
-  function compareIds( a: HasId[], b: HasId[] ) {
-    for (var i = 0, l = a.length, m = b.length; i < l && i < m; ++i) {
-      if (a[i] !== b[i]) {
-        var cmp = a[i].id.localeCompare( b[i].id );
-        if (cmp != 0) {
-          return cmp;
-        }
-      }
-    }
-
-    return l - m;
-  }
-
   // lexicographical comparison for array
   function compareAnys( a: any[], b: any[] ) {
     for (var i = 0, l = a.length, m = b.length; i < l && i < m; ++i) {
@@ -50,6 +36,9 @@ module hd.model {
             (bi instanceof Variable || bi instanceof Constraint || bi instanceof Command)   ) {
           cmp = ai.id.localeCompare( bi.id );
         }
+        else if (Array.isArray( ai ) && Array.isArray( bi )) {
+          cmp = compareAnys( ai, bi );
+        }
         else if (typeof ai === 'number' && typeof bi === 'number') {
           cmp = ai - bi;
         }
@@ -110,6 +99,19 @@ module hd.model {
             rightOnly: rightOnly, rightShared: rightShared};
   }
 
+  function addToList( list: any[], value: any, interpolations: number ) {
+    if (interpolations == 0) {
+      list.push( value );
+    }
+    else if (interpolations == 1) {
+      list.push.apply( list, value );
+    }
+    else {
+      for (var i = 0, l = value.length; i < l; ++i) {
+        addToList( list, value[i], interpolations - 1 );
+      }
+    }
+  }
 
   /*******************************************************************
     Context elements
@@ -164,8 +166,7 @@ module hd.model {
   export
   interface NestedSpec {
     loc: string;
-    klass?: ContextClass;
-    spec?: ContextSpec;
+    ctxType?: ContextClass|ContextSpec;
   }
 
   export
@@ -176,9 +177,9 @@ module hd.model {
 
   export
   interface MethodSpec {
-    inputs: string[];
-    priorFlags: boolean[];
-    outputs: string[];
+    inputs: u.MultiArray<string>;
+    priorFlags: u.MultiArray<boolean>;
+    outputs: u.MultiArray<string>;
     fn: Function;
   }
 
@@ -194,9 +195,9 @@ module hd.model {
   export
   interface CommandSpec {
     loc: string;
-    inputs: string[];
-    priorFlags: boolean[];
-    outputs: string[];
+    inputs: u.MultiArray<string>;
+    priorFlags: u.MultiArray<boolean>;
+    outputs: u.MultiArray<string>;
     fn: Function;
     synchronous: boolean;
   }
@@ -247,13 +248,11 @@ module hd.model {
    * - in destructor, unsubscribe to all paths
    */
   class Template extends r.BasicObservable<Template> {
+    name: string;
 
     // All paths used by this template
     paths: u.ArraySet<Path> = [];
 
-    // Any path with same cardinality as the template
-    master: Path;
-
     // All instances created from this template, in sorted order
     instances : TemplateInstance[] = [];
 
@@ -265,9 +264,6 @@ module hd.model {
     addPath( path: Path ) {
       if (u.arraySet.add( this.paths, path )) {
         path.addObserver( this );
-        if (! this.master || this.master.cardinality < path.cardinality) {
-          this.master = path;
-        }
       }
     }
 
@@ -338,17 +334,18 @@ module hd.model {
     update( changes: ContextChanges ) {
       var newInstances = <TemplateInstance[]> [];
 
-      if (this.master) {
-        // Take all positions from master and try to create instance
-        this.master.forEach( function( vv: any, pos: Position ) {
-          var inst = this.define( pos );
+      if (this.paths.length > 0) {
+        for (var itr = new PathSetIterator( <Path[]>this.paths );
+             itr.pos !== null;
+             itr.next()) {
+          var inst = this.define( itr.pos );
           if (inst) {
             newInstances.push( inst );
           }
-        }, this );
+        }
       }
       else {
-        var inst = this.define( null );
+        var inst = this.define( {} );
         if (inst) {
           newInstances.push( inst );
         }
@@ -421,15 +418,15 @@ module hd.model {
    * from Template class); it's more a helper for ConstraintTemplate
    */
   interface MethodInstance {
-    inputs: any[];
-    outputs: Variable[];
+    inputs: u.MultiArray<any>;
+    outputs: u.MultiArray<Variable>;
   }
 
   class MethodTemplate {
     name: string;
-    inputs: Path[];
-    priorFlags: boolean[];
-    outputs: Path[];
+    inputs: u.MultiArray<Path>;
+    priorFlags: u.MultiArray<boolean>;
+    outputs: u.MultiArray<Path>;
     fn: Function;
 
     /*----------------------------------------------------------------
@@ -437,13 +434,14 @@ module hd.model {
      * handles that
      */
     constructor( mspec: MethodSpec, lookup: PathLookup ) {
-      this.inputs = mspec.inputs.map( lookup.get, lookup );
+      this.inputs = u.multiArray.map( mspec.inputs, lookup.get, lookup );
       if (mspec.priorFlags) {
-        this.priorFlags = mspec.priorFlags.slice( 0 );
+        this.priorFlags = u.multiArray.copy( mspec.priorFlags );
       }
-      this.outputs = mspec.outputs.map( lookup.get, lookup );
+      this.outputs = u.multiArray.map( mspec.outputs, lookup.get, lookup );
       this.fn = mspec.fn;
-      this.name = [mspec.inputs.join( ',' ), mspec.outputs.join( ',' )].join( '->' );
+      this.name = u.multiArray.toString( mspec.inputs ) + '->' +
+            u.multiArray.toString( mspec.outputs );
     }
 
     /*----------------------------------------------------------------
@@ -451,29 +449,53 @@ module hd.model {
      */
     define( pos: Position ): MethodInstance {
       var get = function( p: Path ) { return p.get( pos ) };
-      var ins = this.inputs.map( get );
-      var outs = this.outputs.map( get );
-
-      // Cannot have same variable as input and output
-      for (var i = 0, l = ins.length; i < l; ++i) {
-        if (ins[i] instanceof Variable &&
-            ! (this.priorFlags && this.priorFlags[i]) &&
-            outs.indexOf( ins[i] ) >= 0) {
-          console.warn( 'Method cannot be instantiated with same variable as input and output: ' +
-                        this.name );
+      var ins = u.multiArray.map( this.inputs, get );
+      var outs = u.multiArray.map( this.outputs, get );
+
+      // Check outputs:  all variables, no duplicates
+      var outVars = u.multiArray.flatten( outs );
+      for (var i = 0, l = outVars.length; i < l; ++i) {
+        if (outVars[i] === undefined) {
           return null;
         }
+        if (! (outVars[i] instanceof Variable)) {
+          console.warn( 'Method cannot be instantiated with non-variable output: ' + this.name );
+          return null;
+        }
+        for (var j = i + 1; j < l; ++j) {
+          if (outVars[i] === outVars[j]) {
+            console.warn( 'Method cannot be instantiated with duplicate output: ' + this.name );
+            return null;
+          }
+        }
       }
 
-      // outs should contain only variables; no duplicates
-      var outVars = u.arraySet.fromArray( <Variable[]>outs.filter( u.isType( Variable ) ) );
-      if (outs.length != outVars.length) {
-        console.warn( 'Method cannot be instantiated with non-variable or duplicate outputs: ' +
-                      this.name );
+      // Recursively check inputs:  current-value variable cannot be output
+      var checkInputs = function( ins: u.MultiArray<any>, priors: u.MultiArray<boolean> ) {
+        for (var i = 0, l = ins.length; i < l; ++i) {
+          if (ins[i] === undefined) {
+            return false;
+          }
+          else if (Array.isArray( ins[i] )) {
+            if (! checkInputs( ins[i], priors ? <u.MultiArray<boolean>>priors[i] : undefined )) {
+              return false;
+            }
+          }
+          else if (ins[i] instanceof Variable &&
+              !(priors && priors[i]) &&
+              outVars.indexOf( ins[i] ) >= 0) {
+            console.warn( 'Method cannot be instantiated with same variable as input and output: ' +
+                          this.name );
+            return false;
+          }
+        }
+        return true;
+      };
+
+      if (! checkInputs( ins, this.priorFlags )) {
         return null;
       }
 
-
       return {inputs: ins, outputs: outs};
     }
 
@@ -482,12 +504,14 @@ module hd.model {
      * in the constraint.
      */
     create( inst: MethodInstance, vars: u.ArraySet<Variable> ): Method {
+      var outVars = u.multiArray.flatten( inst.outputs );
       return new Method( this.name,
                          this.fn,
                          inst.inputs,
                          this.priorFlags,
                          inst.outputs,
-                         u.arraySet.difference( vars, inst.outputs )
+                         u.arraySet.difference( vars, outVars ),
+                         outVars
                        );
     }
   }
@@ -501,11 +525,11 @@ module hd.model {
     constructor( public all: any[],
                  public variables: Variable[],
                  public methods: MethodInstance[],
-                 public touchVariables: Variable[] ) { }
+                 public touchVariables: Variable[],
+                 public pos: Position ) { }
   }
 
   class ConstraintTemplate extends Template {
-    name: string;
     variables: Path[];
     methods: MethodTemplate[];
     optional: Optional;
@@ -532,19 +556,17 @@ module hd.model {
      */
     define( pos: Position ) {
       var all = <any[]> [];
-      var vvs = <Variable[]> [];
 
       for (var i = 0, l = this.variables.length; i < l; ++i) {
         var vv = this.variables[i].get( pos );
         if (vv === undefined) {
           return null;
         }
-        all.push( vv );
-        if (vv instanceof Variable) {
-          vvs.push( vv );
-        }
+        addToList( all, vv, this.variables[i].slices );
       }
 
+      var vvs = <Variable[]>all.filter( u.isType( Variable ) );
+
       var minsts = <MethodInstance[]> [];
       var hasMethods = false;
 
@@ -568,7 +590,7 @@ module hd.model {
           }
         }
 
-        return new ConstraintInstance( all, vvs, minsts, <Variable[]>tvs );
+        return new ConstraintInstance( all, vvs, minsts, <Variable[]>tvs, pos );
       }
       else {
         return null;
@@ -590,7 +612,11 @@ module hd.model {
      * Create element for instance
      */
     create( inst: ConstraintInstance ) {
-      var cc = new Constraint( this.name, inst.variables, inst.touchVariables );
+      var name = this.name.replace( /\[(\d*)([a-zA-Z][\w$]*)/g,
+                                    function( all, n, v ) {
+                                      return '[' + n + inst.pos[v];
+                                    } );
+      var cc = new Constraint( name, inst.variables, inst.touchVariables );
       cc.optional = this.optional;
       for (var i = 0, l = inst.methods.length; i < l; ++i) {
         if (inst.methods[i]) {
@@ -609,15 +635,14 @@ module hd.model {
   class CommandInstance {
     element: Command;
 
-    constructor( public inputs: any[],
-                 public outputs: Variable[] ) { }
+    constructor( public inputs: u.MultiArray<any>,
+                 public outputs: u.MultiArray<Variable> ) { }
   }
 
   class CommandTemplate extends Template {
-    name: string;
-    inputs: Path[];
-    priorFlags: boolean[];
-    outputs: Path[];
+    inputs: u.MultiArray<Path>;
+    priorFlags: u.MultiArray<boolean>;
+    outputs: u.MultiArray<Path>;
     fn: Function;
     synchronous: boolean;
 
@@ -626,14 +651,22 @@ module hd.model {
      */
     constructor( cmdspec: CommandSpec, lookup: PathLookup ) {
       super();
-      this.addPaths( this.inputs = cmdspec.inputs.map( lookup.get, lookup ) )
+
+      this.inputs = u.multiArray.map( cmdspec.inputs, lookup.get, lookup )
+      var inputPaths = u.multiArray.flatten( this.inputs );
+      this.addPaths( inputPaths )
+
       if (cmdspec.priorFlags) {
-        this.priorFlags = cmdspec.priorFlags.slice( 0 );
+        this.priorFlags = u.multiArray.copy( cmdspec.priorFlags );
       }
-      this.addPaths( this.outputs = cmdspec.outputs.map( lookup.get, lookup ) )
+      this.outputs = u.multiArray.map( cmdspec.outputs, lookup.get, lookup )
+      var outputPaths = u.multiArray.flatten( this.outputs );
+      this.addPaths( outputPaths )
+
       this.fn = cmdspec.fn;
       this.synchronous = cmdspec.synchronous;
-      this.name = [cmdspec.inputs.join( ',' ), cmdspec.outputs.join( ',' )].join( '->' );
+      this.name = u.multiArray.toString( cmdspec.inputs ) + '->' +
+            u.multiArray.toString( cmdspec.outputs );
       this.activate = this.activate.bind( this );
     }
 
@@ -642,30 +675,50 @@ module hd.model {
      */
     define( pos: Position ) {
       var get = function( p: Path ) { return p.get( pos ) };
-      var ins = this.inputs.map( get );
-      var outs = this.outputs.map( get );
+      var ins = u.multiArray.map( this.inputs, get );
+      var outs = u.multiArray.map( this.outputs, get );
 
-      // Ensure all paths have values
-      if (ins.some( u.isUndefined ) || outs.some( u.isUndefined )) {
-        return null;
-      }
-
-      // Cannot have same variable as input and output
-      for (var i = 0, l = ins.length; i < l; ++i) {
-        if (ins[i] instanceof Variable &&
-            ! (this.priorFlags && this.priorFlags[i]) &&
-            outs.indexOf( ins[i] ) >= 0) {
-          console.warn( 'Command cannot be instantiated with same variable as input and output: ' +
-                        this.name );
+      // Check outputs:  all variables, no duplicates
+      var outVars = u.multiArray.flatten( outs );
+      for (var i = 0, l = outVars.length; i < l; ++i) {
+        if (outVars[i] === undefined) {
           return null;
         }
+        if (! (outVars[i] instanceof Variable)) {
+          console.warn( 'Command cannot be instantiated with non-variable output: ' + this.name );
+          return null;
+        }
+        for (var j = i + 1; j < l; ++j) {
+          if (outVars[i] === outVars[j]) {
+            console.warn( 'Command cannot be instantiated with duplicate output: ' + this.name );
+            return null;
+          }
+        }
       }
 
-      // outs should contain only variables; no duplicates
-      var outVars = u.arraySet.fromArray( <Variable[]>outs.filter( u.isType( Variable ) ) );
-      if (outVars.length != outs.length) {
-        console.warn( 'Command cannot be instantiated with non-variable or duplicate outputs: ' +
-                      this.name );
+      // Recursively check inputs:  current-value variable cannot be output
+      var checkInputs = function( ins: u.MultiArray<any>, priors: u.MultiArray<boolean> ) {
+        for (var i = 0, l = ins.length; i < l; ++i) {
+          if (ins[i] === undefined) {
+            return false;
+          }
+          else if (Array.isArray( ins[i] )) {
+            if (! checkInputs( ins[i], priors ? <u.MultiArray<boolean>>priors[i] : undefined )) {
+              return false;
+            }
+          }
+          else if (ins[i] instanceof Variable &&
+              !(priors && priors[i]) &&
+              outVars.indexOf( ins[i] ) >= 0) {
+            console.warn( 'Command cannot be instantiated with same variable as input and output: ' +
+                          this.name );
+            return false;
+          }
+        }
+        return true;
+      };
+
+      if (! checkInputs( ins, this.priorFlags )) {
         return null;
       }
 
@@ -678,7 +731,7 @@ module hd.model {
     compare( a: CommandInstance, b: CommandInstance ) {
       var cmp = compareAnys( a.inputs, b.inputs );
       if (cmp == 0) {
-        cmp = compareIds( a.outputs, b.outputs );
+        cmp = compareAnys( a.outputs, b.outputs );
       }
       return cmp;
     }
@@ -724,7 +777,6 @@ module hd.model {
   }
 
   class TouchDepTemplate extends Template {
-    name: string;
     from: Path;
     to: Path;
 
@@ -783,7 +835,6 @@ module hd.model {
   }
 
   class OutputTemplate extends Template {
-    name: string;
     variable: Path;
 
     /*----------------------------------------------------------------
@@ -932,7 +983,7 @@ module hd.model {
           changes.adds.forEach( this.addStatic, this );
         }
         else {
-          console.warn( "Could not instantiate constant template: " );
+          console.warn( "Could not instantiate constant template: " + tmpl.name );
         }
       }
       else {
@@ -1050,9 +1101,14 @@ module hd.model {
      * given context.
      */
     static
-    construct( ctx: Context,
-               spec: ContextSpec,
-               init?: u.Dictionary<any> ): Context {
+    construct(
+      ctx: Context,
+      spec: ContextSpec,
+      init?: u.Dictionary<any>
+    ): Context {
+      if (! (ctx instanceof Context)) {
+        throw "Attempting to construct context using specification failed:  object not a context!";
+      }
       if (init) {
         if (typeof init !== 'object') {
           throw "Invalid initialization object passed to Context.construct: " + init;
@@ -1180,14 +1236,14 @@ module hd.model {
     addNestedContext( ctx: Context, spec: NestedSpec, init: u.Dictionary<any> ) {
       var hd_data = ctx['#hd_data'];
       var nested: Context;
-      if (spec.klass) {
-        nested = new spec.klass();
+      if (typeof spec.ctxType === 'function') {
+        nested = new (<ContextClass>spec.ctxType)();
       }
       else {
         nested = new Context();
-      }
-      if (spec.spec) {
-        Context.construct( nested, spec.spec );
+        if (spec.ctxType) {
+          Context.construct( nested, <ContextSpec>spec.ctxType );
+        }
       }
       hd_data.addStatic( nested );
       ctx[spec.loc] = nested;
diff --git a/src/hd/model/method.ts b/src/hd/model/method.ts
index 7946f84..9abc86b 100644
--- a/src/hd/model/method.ts
+++ b/src/hd/model/method.ts
@@ -35,13 +35,13 @@ module hd.model {
     // Inputs to pass to the function, in the order they should be passed
     // Variables in this list will be replaced with their value; everything
     // else will be treated as constants to be passed to the function.
-    inputs: any[];
+    inputs: u.MultiArray<any>;
 
     // Parallel to inputs; true means input comes from prior generation
-    priorFlags: boolean[];
+    priorFlags: u.MultiArray<boolean>;
 
     // Outputs to write to, in the order they are returned form the function
-    outputs: Variable[];
+    outputs: u.MultiArray<Variable>;
 
     // Is this an external operation?  (Does it trigger an update after execution?)
     external = false;
@@ -51,15 +51,22 @@ module hd.model {
     //   and does not contain duplicates.
     inputVars: u.ArraySet<Variable>;
 
+    // Set of variables used as output by this method
+    outputVars: u.ArraySet<Variable>;
+
     /*----------------------------------------------------------------
      * Initialize members
      */
-    constructor( name: string,
-                 fn: any,
-                 inputs: any[],
-                 priorFlags: boolean[],
-                 outputs: Variable[],
-                 inputVars: u.ArraySet<Variable> ) {
+    constructor(
+      name: string,
+      fn: any,
+      inputs: u.MultiArray<any>,
+      priorFlags: u.MultiArray<boolean>,
+      outputs: u.MultiArray<Variable>,
+      inputVars: u.ArraySet<Variable>,
+      outputVars: u.ArraySet<Variable>
+    ) {
+
       this.id = makeId( name );
       this.name = name;
       if (typeof fn === 'function') {
@@ -72,6 +79,7 @@ module hd.model {
       this.priorFlags = priorFlags;
       this.outputs = outputs;
       this.inputVars = inputVars;
+      this.outputVars = outputVars;
     }
 
     /*----------------------------------------------------------------
diff --git a/src/hd/model/model.ts b/src/hd/model/model.ts
deleted file mode 100644
index b60bbee..0000000
--- a/src/hd/model/model.ts
+++ /dev/null
@@ -1,160 +0,0 @@
-/*####################################################################
- * The Context class.
- */
-module hd.model {
-
-  import u = hd.utility;
-  import r = hd.reactive;
-
-  /*==================================================================
-   * Interface for anything which needs to know when the context grows
-   * (e.g. RunTime).
-   */
-  export
-  enum ContextEventType {addConstraint, removeConstraint}
-
-  export
-  interface ContextEvent {
-    type: ContextEventType;
-    constraint?: Constraint;
-  }
-
-  /*==================================================================
-   * Used by a context to keep track of what it contains.
-   */
-  export class ContextData {
-    templates: u.ArraySet<ConstraintTemplate> = [];
-    constraints: u.ArraySet<Constraint> = [];
-    changes = new r.BasicObservable<ContextEvent>();
-  }
-
-  /*==================================================================
-   * A context has two purposes.
-   *
-   * The first is to act as a container for variables and constraints,
-   * allowing a way to refer to them.  When ContextBuilder is given a
-   * name for, say, the input to a method, it looks the name up in the
-   * context.
-   *
-   * The second purpose is to server as a component -- a building
-   * block for composing large contexts.  That one I haven't quite
-   * worked out yet.  Until I do, this at least enforces the idea of a
-   * context being contained in an object, as opposed to a gobal context.
-   */
-  export class Context {
-
-    // The context keeps its own records of what's inside of it in this
-    // property.  It's pseudo-private -- the application programmer
-    // shouldn't use it, but it may be used by other parts of the
-    // system.
-    '#hd_data': ContextData;  // initialized indirectly -- look below class definition
-
-    // A context serves as a generic container; the programmer can
-    // assign variables and constraints to whatever properties he
-    // wants.
-    [key: string]: any;
-
-    /*----------------------------------------------------------------
-     * Create observable property to represent value
-     */
-    static
-    defineProperty<T>( mod: Context, name: string, value?: T, eq?: u.EqualityPredicate<T> ) {
-      var prop = new r.ObservableProperty<T>( value, eq );
-      Object.defineProperty( mod, '$'+name, {configurable: true,
-                                             enumerable: false,
-                                             value: prop
-                                            }
-                           );
-      Object.defineProperty( mod, name, {configurable: true,
-                                         enumerable: true,
-                                         get: prop.get.bind( prop ),
-                                         set: prop.set.bind( prop )
-                                        }
-                           );
-    }
-
-    /*----------------------------------------------------------------
-     * Static getter for constraints
-     */
-    static
-    constraints( mod: Context ) {
-      return mod['#hd_data'].constraints;
-    }
-
-    /*----------------------------------------------------------------
-     * Static getter for changes
-     */
-    static
-    changes( mod: Context ) {
-      return mod['#hd_data'].changes;
-    }
-
-    /*----------------------------------------------------------------
-     * Add variable to context, optionally storing it as a property.
-     */
-    static
-    addVariable( mod: Context, vv: Variable, name: string, property?: boolean ) {
-      if (property) {
-        Context.defineProperty( mod, name, vv );
-      }
-      else {
-        mod[name] = vv;
-      }
-    }
-
-    /*----------------------------------------------------------------
-     * Add variable to context according to spec.
-     */
-    static
-    addVariableSpec( mod: Context, vspec: VariableSpec, vv?: Variable ) {
-      if (vspec.ref) {
-        Context.defineProperty( mod, vspec.name, vv );
-      }
-      else {
-        if (! vv) {
-          vv = new Variable( vspec.name, vspec.value, vspec.eq, vspec.output );
-        }
-        mod[vspec.name] = vv;
-      }
-    }
-
-    /*----------------------------------------------------------------
-     * Add constraint to context.
-     */
-    static
-    addConstraint( mod: Context, cc: Constraint ) {
-      u.arraySet.addKnownDistinct( mod['#hd_data'].constraints, cc );
-      mod['#hd_data'].changes.sendNext( {type: ContextEventType.addConstraint,
-                                         constraint: cc
-                                        }
-                                      );
-    }
-
-    /*----------------------------------------------------------------
-     * Add constraint to context according to spec.
-     */
-    static
-    addConstraintSpec( mod: Context, cspec: ConstraintSpec ) {
-      var template = new ConstraintTemplate( mod, cspec );
-      u.arraySet.addKnownDistinct( mod['#hd_data'].templates, template );
-    }
-
-  }
-
-  /*==================================================================
-   * I have the idea that, at some point, we may want to allow the
-   * programmer to create his own subclasses of Context.
-   *
-   * Rather than require every context subclass to call the context
-   * constructor, we define a getter that creates it the first time it
-   * is accessed.
-   */
-  Object.defineProperty( Context.prototype, '#hd_data', {
-    get: function makeData() {
-      var data = new ContextData();
-      Object.defineProperty( this, '#hd_data', {value: data} );
-      return data;
-    }
-  } );
-
-}
\ No newline at end of file
diff --git a/src/hd/model/path.ts b/src/hd/model/path.ts
index 0e0a227..412cd2a 100644
--- a/src/hd/model/path.ts
+++ b/src/hd/model/path.ts
@@ -6,86 +6,120 @@ module hd.model {
   import u = hd.utility;
   import r = hd.reactive;
 
-  // A position in a path; null for 0 dimensions, number for 1
+  /*==================================================================
+   * A /position/ is a particular assignment of values to index
+   * variables.  For example, given the path template "a[i].b[j+1]",
+   * the position "{i: 2, j: 4}" would yield "a[2].b[5]".
+   *
+   * A position which does not specify values for one or more index
+   * variables represents all possible values of the unspecified index
+   * variables.  So, in the above example, the position "{i: 2}" would
+   * yield "a[2].b[0]", "a[2].b[1]", "a[2].b[2]", etc.
+   *
+   * If P and Q are positions, then Q is a sub-position of P iff every
+   * index variable/value pair in P are also in Q.  So the position
+   * "{i: 2, k: 6}" is a sub-position of "{i: 2, j: 4, k: 6}", and the
+   * position "{}" is a sub-position of every position.
+   */
   export
-  type Position = number;
+  type Position = u.Dictionary<number>;
 
   /*==================================================================
-   * Pattern for an array index in a path
+   * Legs in a path
    */
+
+  export
+  type Leg = String | IndexPattern;
+
+  ////////////////////////////////////////////////
+  // Array index pattern
   export
   class IndexPattern {
-    constructor( public scale: number,
-                 public offset: number ) { }
+    public offset: number;
+    public scale: number;
+    public index: string;
+    public slice: boolean;
+
+    // Init
+    constructor( offset: number );
+    constructor( scale: number, index: string, offset: number );
+    constructor() {
+      if (arguments.length == 1) {
+        this.scale = 0;
+        this.offset = arguments[0];
+      }
+      else {
+        this.scale = arguments[0];
+        this.index = arguments[1];
+        this.offset = arguments[2];
+      }
+    }
 
     // Get the result for this pattern at a particular position
-    apply( pos: Position ): Position {
+    apply( pos: Position ) {
       if (this.scale == 0) {
         return this.offset;
       }
-      else if (pos === null) {
+      else if (pos[this.index] === undefined) {
         return undefined;
       }
       else {
-        return this.scale * pos + this.offset;
+        return this.scale * pos[this.index] + this.offset;
       }
     }
 
-    // Inverse of apply: is there an index that maps to the given position?
-    inverse( pos: Position ): Position {
-      if (pos === null) { return undefined; }
+    // Inverse of apply: what sub-postion of the current position
+    // would result in this index pattern mapping to n?
+    inverse( pos: Position, n: number ) {
       if (this.scale == 0) {
-        return pos === this.offset ? null : undefined;
-      }
-      var i = (pos - this.offset) / this.scale;
-      if (Math.floor( i ) === i) {
-        return i;
+        return n == this.offset ? pos : undefined;
       }
-      else {
+      var i = (n - this.offset) / this.scale;
+      if (Math.floor( i ) !== i) {
         return undefined;
       }
+      if (pos[this.index] !== undefined) {
+        return i == pos[this.index] ? pos : undefined;
+      }
+      pos = u.shallowCopy( pos );
+      pos[this.index] = i;
+      return pos;
     }
   }
 
   /*==================================================================
-   * Defines names of index variable
-   */
-
-  // index variable names, in order
-  var indexName: string;
-
-  // define names for array indices
-  function defineArrayIndexName( name: string ) {
-    indexName = name;
-  }
-
-  // Default: i
-  defineArrayIndexName( 'i' );
-
-  /*==================================================================
-   * Observer of one leg of a path
+   * Observers for the different types of legs in a path
    */
 
+  export
   type LegObserver = PropertyObserver | ArrayObserver;
 
   ////////////////////////////////////////////////
   // Observer the property for a specific field
+  export
   class PropertyObserver {
-    constructor( public path: Path,
-                 public property: r.Signal<any>,
-                 public legi: number,
-                 public pos: Position          ) {
+    public child: LegObserver;
+
+    constructor(
+      public path:     Path,
+      public property: r.Signal<any>,
+      public legi:     number,
+      public pos:      Position
+    ) {
       this.property.addObserverChangesOnly( this );
     }
 
-    // No longer needed
+    // Observer no longer needed
     destruct() {
       this.property.removeObserver( this );
+      if (this.child) {
+        this.child.destruct();
+      }
     }
 
     // Property changes
     onNext() {
-      this.path.onNextProperty( this.legi, this.pos );
+      this.path.onNextProperty( this );
     }
 
     onError() { }
@@ -93,59 +127,125 @@ module hd.model {
   }
 
   ////////////////////////////////////////////////
-  // Observe an array for all indexes
+  // Observe an entire array
+  export
   class ArrayObserver {
-    constructor( public path: Path,
-                 public ctx: ArrayContext,
-                 public legi: number,
-                 public pos: Position      ) {
-      this.ctx.changes.addObserver( this );
+    // Whether there is just one child or multiple children depends on
+    // whether we are observing the entire array or just one element
+    public children: LegObserver[] = [];
+
+    constructor(
+      public path: Path,
+      public ctx:  ArrayContext,
+      public legi: number,
+      public pos:  Position
+    ) {
+      if (ctx instanceof ArrayContext) {
+        this.ctx.changes.addObserver( this );
+      }
+    }
+
+    alsoWatchLength() {
+      this.ctx.$length.addObserver( this, this.onNextLength, null, null );
     }
 
-    // No longer needed
+    // Observer no longer needed
     destruct() {
       this.ctx.changes.removeObserver( this );
+      this.ctx.$length.removeObserver( this );
+      if (this.hasOwnProperty( 'children' )) {
+        for (var i = 0, l = this.children.length; i < l; ++i) {
+          var child = this.children[i];
+          if (child) {
+            child.destruct();
+          }
+        }
+      }
     }
 
     onNext( idx: number ) {
-      this.path.onNextArray( idx, this.legi, this.pos );
+      this.path.onNextArray( this, idx );
+    }
+
+    onNextLength( legnth: number ) {
+      this.path.onNextArrayLength( this );
     }
 
     onError() { }
     onCompleted() { }
   }
 
+  /*==================================================================
+   */
+  export
+  class PathSetIterator {
+
+    private paths: Path[];
+    private locks: Position[];
+    pos: Position;
+
+    constructor( paths: Path[] ) {
+      this.paths = paths;
+      this.locks = [{}];
+      this.pos = this.multiPosition( 0, 1 );
+    }
+
+    next() {
+      if (this.pos !== null) {
+        this.pos = this.multiPosition( this.paths.length - 1, -1 );
+      }
+    }
+
+    private multiPosition( idx: number, dir: number ): Position {
+      for (var l = this.paths.length; idx >= 0 && idx < l; idx += dir) {
+        if (dir > 0) {
+          this.locks[idx + 1] = this.paths[idx].begin( this.locks[idx] );
+        }
+        else {
+          this.locks[idx + 1] = this.paths[idx].next( this.locks[idx], this.locks[idx + 1] );
+        }
+        dir = this.locks[idx + 1] === null ? -1 : 1;
+      }
+
+      if (idx == l) {
+        return this.locks[idx];
+      }
+      else {
+        return null;
+      }
+    }
+  }
+
   /*==================================================================
    * An observable representing a particular property path in a
    * context.
+   *
+   * Each path can use arbitrary variables.  The path will assign
+   * an order to its variables -- i.e., i_0, i_1, i_2, ...
+   *
+   * Each slice is assigned a unique variable name.  These are
+   * considered internal variable names.  They will not be included in
+   * any positions published by the path, nor will they be looked for
+   * in any positions passed to this path from the outside.  Internal
+   * variable names will always come after external variable names in
+   * the ordering.
    */
   export
   class Path extends r.BasicObservable<Position> {
 
+    slices: number;
+
     // The context at which to begin the search
-    start: Context;
+    private start: Context;
 
     // The path broken down into legs
-    legs: (string|IndexPattern)[];
-
-    // Maximum index variable used
-    cardinality: number;
-
-    // Is the path going to stay the same, or could it change?
-    constant = true;
-
-    // The branch point for the path--first variable index pattern
-    private branchi = 0;
+    private legs: Leg[];
 
-    // Observers corresponding to legs
-    private observers0: LegObserver[] = null;
-    private observers1: LegObserver[][] = null;
-
-    // Path result (0-dimension) or array of results (1-dimension)
-    // This not only caches the result, it's also used to decide whether
-    //   a particular position had a previous result so that we can know
-    //   whether anything changed
-    private result: any;
+    // The observer tree consists of observers for every property/arrray
+    // accessible by this path.  Because it is a tree, whenever any
+    // property/array changes we can simply prune the entire subtree
+    // under that node and rebuild using createObservers.
+    private rootObserver: LegObserver;
 
     /*----------------------------------------------------------------
      * Perform initial search.
@@ -154,307 +254,374 @@ module hd.model {
       super();
 
       // Break path down into property names and index patterns
-      this.legs = parse( path );
-      if (this.legs) {
+      var legs = parse( path );
+      if (legs) {
         this.start = start;
-        this.cardinality = 0;
-
-        // Decide whether this is 0- or 1-dimensional
-        for (var i = 0, l = this.legs.length; i < l; ++i) {
-          if ((<any>this.legs[i]) instanceof IndexPattern &&
-              (<IndexPattern>this.legs[i]).scale != 0       ) {
-            this.branchi = i + 1;
-            this.cardinality = 1;
-            this.result = [];
-            break;
-          }
-        }
+        this.legs = legs;
       }
       else {
         // Create a path which always just returns undefined
         this.start = undefined;
         this.legs = [];
-        this.cardinality = 0;
       }
 
+      this.slices = countSlices( this.legs );
+
       // Initialize
-      this.followPath( this.start, 0, null );
+      this.rootObserver = this.createObservers( this.start, 0, {} );
     }
 
     /*----------------------------------------------------------------
-     * Get the current result for the path serach (from cache)
+     * We're no longer needed; prune observer tree
      */
-    get( pos: Position ): any {
-      if (this.cardinality == 0) {
-        return this.result;
-      }
-      else if (pos !== null) {
-        return this.result[pos]
+    destruct() {
+      if (this.rootObserver) {
+        this.rootObserver.destruct();
+        this.rootObserver = undefined;
       }
     }
 
     /*----------------------------------------------------------------
-     * Called internally to add result to cache
+     * Is this path constant (no references/arrays)?
      */
-    private
-    addResult( pos: Position, val: any ) {
-      if (this.cardinality == 0) {
-        this.result = val;
-        this.sendNext( null );
-      }
-      else if (pos !== null) {
-        this.result[pos] = val;
-        this.sendNext( pos );
-      }
+    isConstant(): boolean {
+      return this.rootObserver === undefined;
     }
 
     /*----------------------------------------------------------------
-     * Called internally to remove result from cache.
-     * For 1-dimensional, position == null means remove all results.
+     * Get the current result for a position
+     */
+    get( pos: Position = {} ): any {
+      return this.getRec( this.start, 0, pos, this.legs.length );
+    }
+
+    /*----------------------------------------------------------------
+     * Get the result for a position up to the specified depth.
      */
     private
-    removeResult( pos: Position ) {
-      if (this.cardinality == 0) {
-        if (this.result !== undefined) {
-          this.result = undefined;
-          this.sendNext( pos );
+    getRec( value: any, legi: number, pos: Position, limit: number ): any {
+      if (value === undefined) { return undefined; }
+
+      // If we reach the end, return the value
+      if (legi >= limit) { return value; }
+
+      // Consider current leg
+      var leg = this.legs[legi];
+      if (typeof leg === 'string' && value != null) {
+        // Field lookup
+        return this.getRec( value[leg], legi + 1, pos, limit );
+      }
+      else if (leg instanceof IndexPattern) {
+        if (leg.scale == 0 || leg.index in pos) {
+          // Index can be determined: single value
+          var idx = leg.apply( pos );
+          if (idx === undefined) { return undefined; }
+          return this.getRec( value[idx], legi + 1, pos, limit );
         }
-      }
-      else if (pos !== null) {
-        if (this.result[pos] !== undefined) {
-          this.result[pos] = undefined;
-          this.sendNext( pos );
-        }
-      }
-      else {
-        for (var i = 0, l = this.result.length; i < l; ++i) {
-          if (this.result[i] !== undefined) {
-            this.sendNext( i );
+        else {
+          // Index undetermined: array of all values
+          var results: any[] = [];
+          for (var i = 0, l = value.length; i < l; ++i) {
+            var newpos = leg.inverse( pos, i );
+            var result = this.getRec( value[i], legi + 1, newpos, limit );
+            if (result === undefined) { return undefined; }
+            results.push( result );
           }
+          return results;
         }
-        this.result = [];
       }
+      return undefined;
     }
 
     /*----------------------------------------------------------------
-     * We only cache the end result; this looks up a node in the
-     * middle by following the path.
+     * Examine every possible value for this path, creating observers
+     * for any references found along the way.
      */
     private
-    getUpTo( limit: number, pos: Position, ctx = this.start, legi = 0 ): any {
-      for (; legi <= limit && ctx instanceof Context; ++legi) {
+    createObservers( value: any, legi: number, pos: Position ): LegObserver {
+      if (value === undefined) { return; }
+
+      // Iterate until we finish or we find a reference to observe.
+      // If we find a reference, we create an observer, recurse to
+      //   finish out the rest of the path, and return the observer.
+      for (var l = this.legs.length; legi < l; ++legi) {
         var leg = this.legs[legi];
-        if (typeof leg === 'string') {
-          ctx = ctx[leg];
+        // Field access
+        if (typeof leg === 'string' && value !== null) {
+          if (value instanceof Context) {
+            var propname = '$' + leg;
+            if (propname in value) {
+              var prop = value[propname];
+              var pobs = new PropertyObserver( this, prop, legi, pos );
+              pobs.child = this.createObservers( prop.get(), legi + 1, pos );
+              return pobs;
+            }
+          }
+          value = value[leg]; // continue iteration
         }
-        else if (leg instanceof IndexPattern) {
-          var n = leg.apply( pos );
-          if (n === undefined) {
-            ctx = undefined;
+        // Array access
+        else if (leg instanceof IndexPattern &&
+                 (value instanceof ArrayContext || value instanceof Array)) {
+          // Constant array access
+          if (leg.scale == 0 || pos[leg.index] !== undefined) {
+            var idx = leg.apply( pos );
+            if (value instanceof ArrayContext) {
+              var aobs = new ArrayObserver( this, value, legi, pos );
+              aobs.children[idx] = this.createObservers( value[idx], legi + 1, pos );
+              return aobs;
+            }
+            value = value[idx]; // continue iteration
           }
+          // Variable array access
           else {
-            ctx = ctx[n];
+            if (value instanceof ArrayContext) {
+              // Note: an array observer for an Array (as opposed to an ArrayContext)
+              //       will not actually observe, but it will manage its children
+              var aobs = new ArrayObserver( this, value, legi, pos );
+              for (var j = 0, m = value.length; j < m; ++j) {
+                if (value[j] !== undefined) {
+                  var n = leg.inverse( pos, j );
+                  if (n !== undefined) {
+                    aobs.children[j] = this.createObservers( value[j], legi + 1, n );
+                  }
+                }
+              }
+              if (leg.slice) {
+                aobs.alsoWatchLength();
+              }
+            }
+            return aobs;
           }
         }
+        else {
+          break;
+        }
       }
-      return legi > limit ? ctx : undefined;
     }
 
     /*----------------------------------------------------------------
-     * Store a leg observer; assumes observer is already subscribed
+     * Find first position that (1) has a value, and (2) is a
+     * superposition of lock.  Lock may be empty to allow all
+     * positions.
      */
-    private
-    addLegObserver( ver: LegObserver, legi: number, pos: Position ) {
-      this.constant = false;
-      if (pos === null) {
-        if (! this.observers0) { this.observers0 = []; }
-        this.observers0[legi] = ver;
-      }
-      else {
-        if (! this.observers1) { this.observers1 = []; }
-        if (! this.observers1[pos]) { this.observers1[pos] = []; }
-        this.observers1[pos][legi - this.branchi] = ver;
-      }
+    begin( lock: Position ): Position {
+      return this.beginRec( this.start, 0, lock );
     }
 
-    /*----------------------------------------------------------------
-     * Unsubscribes and removes all leg observers for position,
-     * beginning at start.
-     * Assumes pos === null => start < this.branchi
-     *         pos !== null => start >= this.branchi
-     */
     private
-    removeLegObservers( start: number, pos: Position ) {
-      if (pos === null) {
-        if (this.observers0) {
-          for (var i = start, l = this.observers0.length; i < l; ++i) {
-            var ver = this.observers0[i]
-            if (ver) {
-              ver.destruct();
-              this.observers0[i] = undefined;
+    beginRec( value: any, legi: number, lock: Position ): Position {
+      // Undefined means no valid positions
+      if (value === undefined) { return null; }
+
+      // If we reach the end, then the lock indicates a valid position
+      if (legi == this.legs.length) { return lock; }
+
+      // Consider the current leg
+      var leg = this.legs[legi];
+      if (typeof leg === 'string' && value !== null) {
+        // Only one possibility for a field
+        return this.beginRec( value[leg], legi + 1, lock );
+      }
+      else if (leg instanceof IndexPattern &&
+               (value instanceof ArrayContext || value instanceof Array)) {
+        if (leg.slice) {
+          // We need to find the first that works for every element of value
+          return this.multiPosition( value, legi, lock );
+        }
+        else {
+          // Is index variable locked down?
+          if (leg.index in lock) {
+            // Yes:  only one thing we can try
+            var idx = leg.apply( lock );
+            if (idx !== undefined) {
+              return this.beginRec( value[idx], legi + 1, lock );
             }
           }
-        }
-        if (this.observers1) {
-          for (var i = 0, l = this.observers1.length; i < l; ++i) {
-            var vers1 = this.observers1[i];
-            if (vers1) {
-              for (var j = 0, m = vers1.length; j < m; ++j) {
-                var ver = vers1[j];
-                if (ver) {
-                  ver.destruct();
-                  vers1[j] = undefined;
+          else {
+            // No: let's try them all and take the first one that works
+            for (var idx = 0, l = value.length; idx < l; ++idx) {
+              var newlock = leg.inverse( lock, idx );
+              if (newlock !== undefined) {
+                var found = this.beginRec( value[idx], legi + 1, newlock );
+                if (found) {
+                  return found;
                 }
               }
             }
           }
         }
       }
-      else if (this.observers1) {
-        var vers1 = this.observers1[pos];
-        if (vers1) {
-          for (var j = start - this.branchi, m = vers1.length; j < m; ++j) {
-            var ver = vers1[j];
-            if (ver) {
-              ver.destruct();
-              vers1[j] = undefined;
-            }
-          }
-        }
-      }
+      // If we make it here, then nothing worked
+      return null;
     }
 
     /*----------------------------------------------------------------
-     * Perform the search, subscribing to any properties encountered.
+     * Find first position /after/ specified position which is a
+     * subposition of lock.  Lock may be empty to allow all
+     * positions
      */
-    private
-    followPath( ctx: Context, legi: number, pos: Position ) {
+    next( lock: Position, pos: Position ): Position {
+      return this.nextRec( this.start, 0, lock, pos );
+    }
 
-      for (var l = this.legs.length; legi < l && ctx instanceof Context; ++legi) {
-        var leg = this.legs[legi];
-        // Field access
-        if (typeof leg === 'string') {
-          var propname = '$' + leg;
-          if (propname in ctx) {
-            var prop = ctx[propname];
-            this.addLegObserver( new PropertyObserver( this, prop, legi, pos ), legi, pos );
-            ctx = prop.get();
-          }
-          else {
-            ctx = ctx[leg];
-          }
+    private
+    nextRec( value: any, legi: number, lock: Position, pos: Position ): Position {
+      // If we run out of values or reach the end, then there's nothing
+      //   more that we can do:  there is no next value
+      if (value === undefined) { return null; }
+      if (legi == this.legs.length) { return null; }
+
+      // Consider the current leg
+      var leg = this.legs[legi];
+      if (typeof leg === 'string' && value !== null) {
+        // A field cannot be changed; we'll have to keep looking
+        return this.nextRec( value[leg], legi + 1, lock, pos );
+      }
+      else if (leg instanceof IndexPattern &&
+               (value instanceof ArrayContext || value instanceof Array)) {
+        if (leg.slice) {
+          // We need to find the next that works for every element of value
+          return this.multiPosition( value, legi, lock, pos );
         }
-        // Array access
-        else if (leg instanceof IndexPattern && ctx instanceof ArrayContext) {
-          // Constant array access
-          if (leg.scale == 0 || pos !== null) {
-            var idx = leg.apply( pos );
-            this.addLegObserver( new ArrayObserver( this, <ArrayContext>ctx, legi, pos ),
-                                 legi, pos                                                );
-            ctx = ctx[idx];
+        else {
+          // Figure out which element is currently being used
+          var idx = leg.apply( pos );
+          if (idx === undefined) { return null; } // shouldn't happen --
+                                                  // pos should be a valid position
+          if (leg.index in lock) {
+            // If it's locked, it cannot be changed; we'll have to keep looking
+            return this.nextRec( value[idx], legi + 1, lock, pos );
           }
-          // Variable array access
           else {
-            this.addLegObserver( new ArrayObserver( this, <ArrayContext>ctx, legi, pos ),
-                                 legi, pos                                                );
-            for (var j = 0, m = (<ArrayContext>ctx).length; j < m; ++j) {
-              if (ctx[j] !== undefined) {
-                var n = leg.inverse( j );
-                if (n !== undefined) {
-                  this.followPath( ctx[j], legi + 1, n );
-                }
+            // First see if we can do a next while staying on the current element
+            //   by locking down this index
+            var extLock = u.shallowCopy( lock );
+            extLock[leg.index] = idx;
+            var found = this.nextRec( value[idx], legi + 1, extLock, pos );
+            if (found) { return found; }
+
+            // If that didn't work, try remaining elements to see if we
+            //   can find something
+            var l: number;
+            for (++idx, l = value.length; idx < l; ++idx) {
+              var newpos = leg.inverse( lock, idx );
+              if (newpos !== undefined) {
+                var found = this.beginRec( value[idx], legi + 1, newpos );
+                if (found) { return found; }
               }
             }
-            break; // we followed everything else recursively
           }
         }
       }
-      if (l == legi && ctx !== undefined) {
-        this.addResult( pos, ctx );
-      }
+      // If we make it here, then nothing worked
+      return null;
     }
 
     /*----------------------------------------------------------------
-     * Property changed
+     * Find the first/next position which (1) produces valid results
+     * for /all/ values, and (2) is a superposition of lock. (If
+     * from is specified, it's next; if not, it's first.)
      */
-    onNextProperty( legi: number, pos: Position ) {
-      this.removeResult( pos );
-      this.removeLegObservers( legi + 1, pos );
-      this.followPath( this.getUpTo( legi, pos ), legi + 1, pos );
-    }
+    private
+    multiPosition(
+      values: ArrayContext | Array<any>,
+      legi:   number,
+      lock:   Position,
+      from?:  Position
+    ):        Position {
+
+      var locks: Position[], dir: number;
+      // The position at locks[i] is used to query a position from values[i].
+      // The position returned becomes the lock for the next value.
+      // If dir == 1, then the previous position query worked and we're moving
+      //   ahead to try the next one ==> use begin
+      // If dir == -1, then the previous position query failed and we're backing
+      //   up to try to find a different lock ==> use next
+
+      if (from) {
+        locks = [lock, from];
+        dir = -1;
+      }
+      else {
+        locks = [lock];
+        dir = 1;
+      }
 
-    /*----------------------------------------------------------------
-     * Array changed
-     */
-    onNextArray( idx: number, legi: number, pos: Position ) {
-      var update = false;
-      var leg = <IndexPattern>this.legs[legi];
-      // Always constant
-      if (leg.scale == 0) {
-        if (leg.offset === idx) {
-          update = true;
+      for (var idx = 0, l = values.length; idx >= 0 && idx < l; idx += dir) {
+        if (dir > 0) {
+          locks[idx + 1] = this.beginRec( values[idx], legi + 1, locks[idx] );
         }
-      }
-      // Constant because pos is fixed
-      else if (pos !== null) {
-        if (leg.apply( pos ) === idx) {
-          update = true;
+        else {
+          locks[idx + 1] = this.nextRec( values[idx], legi + 1, locks[idx], locks[idx + 1] );
         }
+        dir = locks[idx + 1] === null ? -1 : 1;
+      }
+
+      // Either we made it all the way to the end, or we regressed to the beginning
+      if (idx == l) {
+        return locks[idx];
       }
-      // Variable
       else {
-        pos = leg.inverse( idx );
-        update = true;
+        return null;
       }
+    }
 
-      if (update) {
-        this.removeResult( pos );
-        this.removeLegObservers( legi + 1, pos );
-        this.followPath( this.getUpTo( legi, pos ), legi + 1, pos );
-      }
+    /*----------------------------------------------------------------
+     * Property changed
+     */
+    onNextProperty( obs: PropertyObserver ) {
+      if (obs.child) {
+        obs.child.destruct();
+      }
+      obs.child = this.createObservers(
+        this.getRec( this.start, 0, obs.pos, obs.legi + 1 ),
+        obs.legi + 1,
+        obs.pos
+      );
+      this.sendNext( obs.pos );
     }
 
     /*----------------------------------------------------------------
+     * Array changed
      */
-    forEach( fn: (value: any, pos: Position) => void, thisObj: Object = null ) {
-      if (this.cardinality == 0) {
-        if (this.result !== undefined) {
-          fn.call( thisObj, this.result, null );
-        }
-      }
-      else {
-        var lasti = this.legs.length - 1;
-        var idxpat = <IndexPattern>this.legs[this.branchi - 1];
-        var ctx = <ArrayContext>this.getUpTo( this.branchi - 2, null );
-        if (ctx instanceof ArrayContext) {
-          for (var i = 0, l = ctx.length; i < l; ++i) {
-            if (ctx[i] !== undefined) {
-              var pos = idxpat.inverse( i );
-              if (pos !== null) {
-                var val = this.getUpTo( lasti, pos, ctx[i], this.branchi );
-                if (val) {
-                  fn.call( thisObj, val, pos );
-                }
-              }
-            }
-          }
+    onNextArray( obs: ArrayObserver, idx: number ) {
+      var leg = <IndexPattern>this.legs[obs.legi];
+      var newpos = leg.inverse( obs.pos, idx );
+      if (newpos !== undefined) {
+        if (obs.children[idx]) {
+          obs.children[idx].destruct();
         }
+        obs.children[idx] = this.createObservers(
+          this.getRec( this.start, 0, newpos, obs.legi + 1 ),
+          obs.legi + 1,
+          newpos
+        );
+        this.sendNext( newpos );
       }
     }
 
+    /*----------------------------------------------------------------
+     * Array size changed (only for slices)
+     */
+    onNextArrayLength( obs: ArrayObserver ) {
+      this.sendNext( obs.pos );
+    }
+
   }
 
   /*==================================================================
+   * Parse path into legs
    */
 
   export
-  function parse( pathstr: string ): (string|IndexPattern)[] {
+  function parse( pathstr: string ): Leg[] {
     var s = pathstr;
     var nonempty = /\S/;
     var field = /^\s*\.?([a-zA-Z][\w$]*)/;
     var cindex = /^\s*\[\s*(\d+)\s*\]/;
-    var vindex = /^\s*\[\s*(?:(\d+)\s*\*\s*)?([a-zA-Z][\w$]*)\s*(?:([+-])\s*(\d+)\s*)?\]/;
-    var legs: any[] = [];
+    var vindex = /^\s*\[\s*(\d+)?\s*(\*|[a-zA-Z][\w$]*)\s*(?:([+-])\s*(\d+)\s*)?\]/;
+    var legs: Leg[] = [];
+    var temps = 0;
 
     while (nonempty.test( s )) {
       var m : string[];
@@ -462,27 +629,36 @@ module hd.model {
         legs.push( m[1] );
       }
       else if (m = cindex.exec( s )) {
-        legs.push( new IndexPattern( 0, Number( m[1] ) ) );
+        legs.push( new IndexPattern( Number( m[1] ) ) );
       }
       else if (m = vindex.exec( s )) {
-        if (m[2] == indexName) {
-          var scale = 1;
-          var offset = 0;
-          if (m[1]) {
-            scale = Number( m[1] );
-          }
-          if (m[4]) {
-            offset = Number( m[4] );
-            if (m[3] == '-') {
-              offset = -offset;
-            }
-          }
-          legs.push( new IndexPattern( scale, offset ) );
+        var index: string;
+        var slice: boolean;
+        if (m[2] == '*') {
+          index = '#' + temps++;
+          slice = true;
         }
         else {
-          console.error( 'Unknown array index in "' + pathstr + '"' );
-          return null;
+          index = m[2];
+          slice = false;
+        }
+
+        var scale = 1;
+        var offset = 0;
+        if (m[1]) {
+          scale = Number( m[1] );
+        }
+        if (m[4]) {
+          offset = Number( m[4] );
+          if (m[3] == '-') {
+            offset = -offset;
+          }
         }
+        var pat = new IndexPattern( scale, index, offset);
+        if (slice) {
+          pat.slice = true;
+        }
+        legs.push( pat );
       }
       else {
         console.error( 'Unable to parse path "' + pathstr + '"' );
@@ -493,6 +669,32 @@ module hd.model {
     return legs;
   }
 
+  function countDimensions( legs: Leg[] ) {
+    var dimensions = 0;
+    var variables: u.Dictionary<boolean> = {};
+    for (var i = 0, l = legs.length; i < l; ++i) {
+      var leg = legs[i];
+      if (leg instanceof IndexPattern &&
+          ! leg.slice &&
+          ! variables[leg.index]) {
+        ++dimensions;
+        variables[leg.index] = true;
+      }
+    }
+    return dimensions;
+  }
+
+  function countSlices( legs: Leg[] ) {
+    var slices = 0;
+    for (var i = 0, l = legs.length; i < l; ++i) {
+      var leg = legs[i];
+      if (leg instanceof IndexPattern && leg.slice) {
+        ++slices;
+      }
+    }
+    return slices;
+  }
+
   /*==================================================================
    */
   export
@@ -501,11 +703,12 @@ module hd.model {
     constructor( private path: Path ) {
       super();
       path.addObserver( this, this.onPositionChange, null, null );
-      this.set( path.get( null ) );
+      this.set( path.get( {} ) );
     }
 
     onPositionChange() {
-      this.set( this.path.get( null ) );
+      this.set( this.path.get( {} ) );
     }
   }
+
 }
diff --git a/src/hd/reactive/accum.ts b/src/hd/reactive/accum.ts
new file mode 100644
index 0000000..1023654
--- /dev/null
+++ b/src/hd/reactive/accum.ts
@@ -0,0 +1,94 @@
+module hd.reactive {
+
+  const
+  enum AccumState { Pending, Fulfill, Reject, Settled }
+
+  export
+  class AccumulatingPromise<T> extends Promise<T> {
+
+    private accumState = AccumState.Pending;
+    private accumValue: T = undefined;
+    private accumReason: any = undefined;
+    private timeout: number = null;
+    private delay: number;
+
+    constructor( value?: T ) {
+      super();
+      this.ontimeout = this.ontimeout.bind( this );
+      if (arguments.length > 0) {
+        this.accumState = AccumState.Fulfill;
+        this.accumValue = value;
+      }
+    }
+
+    setDelay( delay: number ) {
+      if (this.timeout) {
+        clearTimeout( this.timeout );
+        this.timeout = null;
+      }
+      this.delay = delay;
+      if (this.accumState === AccumState.Fulfill ||
+          this.accumState === AccumState.Reject) {
+        this.timeout = setTimeout( this.ontimeout, delay );
+      }
+    }
+
+    private
+    ontimeout() {
+      this.timeout = null;
+      this.settle();
+    }
+
+    settle() {
+      if (this.timeout) {
+        clearTimeout( this.timeout );
+        this.timeout = null;
+      }
+      if (this.accumState === AccumState.Fulfill) {
+        this.resolve( this.accumValue );
+        this.accumValue = undefined;
+      }
+      else if (this.accumState === AccumState.Reject) {
+        this.reject( this.accumReason );
+      }
+      this.accumState = AccumState.Settled;
+    }
+
+    updateResolve( value: T ) {
+      if (this.accumState === AccumState.Settled) {
+        this.resolve( value );
+      }
+      else {
+        if (this.timeout) {
+          clearTimeout( this.timeout );
+          this.timeout = null;
+        }
+        this.accumState = AccumState.Fulfill;
+        this.accumValue = value;
+        this.accumReason = undefined;
+        if (this.delay) {
+          this.timeout = setTimeout( this.ontimeout, this.delay );
+        }
+      }
+    }
+
+    updateReject( reason: any ) {
+      if (this.accumState === AccumState.Settled) {
+        this.reject( reason );
+      }
+      else {
+        if (this.timeout) {
+          clearTimeout( this.timeout );
+          this.timeout = null;
+        }
+        this.accumState = AccumState.Reject;
+        this.accumReason = reason;
+        this.accumValue = undefined;
+        if (this.delay) {
+          this.timeout = setTimeout( this.ontimeout, this.delay );
+        }
+      }
+    }
+  }
+
+}
diff --git a/src/hd/reactive/api.ts b/src/hd/reactive/api.ts
new file mode 100644
index 0000000..b833b6d
--- /dev/null
+++ b/src/hd/reactive/api.ts
@@ -0,0 +1,27 @@
+module hd {
+
+  import r = hd.reactive;
+
+  export var ProxyObserver = r.ProxyObserver;
+  export var BasicObservable = r.BasicObservable;
+  export var Promise = r.Promise;
+  export var Extension = r.Extension;
+  export var liftFunction = r.liftFunction;
+
+  /*==================================================================
+   * Enablement functions
+   */
+
+  export function markUsed( p: r.Promise<any> ) {
+    p.usage.set( r.Usage.Used );
+  }
+
+  export function markUnused( p: r.Promise<any> ) {
+    p.usage.set( r.Usage.Unused );
+  }
+
+  export function markDelayed( p: r.Promise<any> ) {
+    p.usage.set( r.Usage.Delayed );
+  }
+
+}
diff --git a/src/hd/reactive/extensions.ts b/src/hd/reactive/extensions.ts
index e7013ae..e13666a 100644
--- a/src/hd/reactive/extensions.ts
+++ b/src/hd/reactive/extensions.ts
@@ -424,33 +424,20 @@ module hd.reactive {
    */
   enum StabilizerState { None, Next, Error };
 
-  export class Stabilizer<T> extends Extension<T, T> {
+  export class Stabilizer<T> extends Extension<T, Promise<T>> {
 
-    // What event we are waiting on
-    private state: StabilizerState = StabilizerState.None;
-
-    // The argument for the event we are waiting on
-    private arg: any;
-
-    // The timer id for the event we are waiting on
-    private task: number = null;
+    // Promise for result
+    private promise: AccumulatingPromise<T>;
 
     // How many milliseconds to wait
     private time: number;
 
-    private flush: Object;
-
     /*----------------------------------------------------------------
      * Initialize
      */
-    constructor( time_ms = 400, flush?: Object ) {
+    constructor( time_ms = 400 ) {
       super();
       this.time = time_ms;
-      this.flush = flush;
-
-      // Make personalized version of this callback which
-      //   always invokes on this object
-      this.onTimeout = this.onTimeout.bind( this );
     }
 
     /*----------------------------------------------------------------
@@ -458,20 +445,13 @@ module hd.reactive {
      * this one.
      */
     onNext( value: T ) {
-      if (this.flush !== undefined && value === this.flush) {
-        if (this.task) {
-          clearTimeout( this.task );
-          this.onTimeout();
-        }
-      }
-      else {
-        this.state = StabilizerState.Next;
-        this.arg = value;
-        if (this.task) {
-          clearTimeout( this.task );
-        }
-        this.task = setTimeout( this.onTimeout, this.time );
+      if (! this.promise || this.promise.isSettled()) {
+        this.promise = new AccumulatingPromise<T>();
+        this.promise.setDelay( this.time );
+        this.sendNext( this.promise );
       }
+
+      this.promise.updateResolve( value );
     }
 
     /*----------------------------------------------------------------
@@ -479,12 +459,13 @@ module hd.reactive {
      * this one.
      */
     onError( error: any ) {
-      this.state = StabilizerState.Error;
-      this.arg = error;
-      if (this.task) {
-        clearTimeout( this.task );
+      if (! this.promise || this.promise.isSettled()) {
+        this.promise = new AccumulatingPromise<T>();
+        this.promise.setDelay( this.time );
+        this.sendNext( this.promise );
       }
-      this.task = setTimeout( this.onTimeout, this.time );
+
+      this.promise.updateReject( error );
     }
 
     /*----------------------------------------------------------------
@@ -492,25 +473,10 @@ module hd.reactive {
      * "completed" event.
      */
     onCompleted() {
-      if (this.task) {
-        clearTimeout( this.task );
-        this.onTimeout();
-      }
-      this.sendCompleted();
-    }
-
-    /*----------------------------------------------------------------
-     * Done waiting - fire the event being waited on
-     */
-    onTimeout() {
-      if (this.state == StabilizerState.Next) {
-        this.sendNext( this.arg );
-      }
-      else if (this.state == StabilizerState.Error) {
-        this.sendError( this.arg );
+      if (this.promise) {
+        this.promise.settle();
+        this.promise = null;
       }
-      this.state = StabilizerState.None;
-      this.task = null;
     }
   }
 
diff --git a/src/hd/reactive/function.ts b/src/hd/reactive/function.ts
index 92ba544..6b63539 100644
--- a/src/hd/reactive/function.ts
+++ b/src/hd/reactive/function.ts
@@ -3,213 +3,194 @@
  */
 module hd.reactive {
 
+  import u = hd.utility;
+  import r = hd.reactive;
+
   /*==================================================================
    * The actual lifting function.
    */
   export function liftFunction( fn: Function,
-                                numOutputs: number = 1,
                                 mask: boolean[] = null  ) {
     return function( ...parameters: Promise<any>[] ) {
-      var pack = new ParameterPack( parameters, mask );
-      var fnCall = new SingleFunctionCall( fn, pack.promise, numOutputs );
-      return (fnCall.outputPromises.length <= 1) ?
-            <any>fnCall.outputPromises[0] : <any>fnCall.outputPromises;
+      var invocation = new LiftedFunctionInvocation( fn, parameters, mask );
+      return invocation.output;
     }
   }
 
+  // unique value used to indicate that the corresponding promise has
+  //   never produced a value (including progress notifications)
+  var noValue = {};
+
   /*==================================================================
-   * Takes a Promise<any>[], and returns a Promise<any[]>.
+   * A lifted function invocation.
    */
-  export class ParameterPack {
+  class LiftedFunctionInvocation {
+
+    // The inputs given to the function
+    private inputs: u.MultiArray<any>;
+
+    // List of promises we have subscribed to
+    private promises: r.Promise<any>[] = [];
 
-    // The promise produced
-    promise: Promise<any[]>;
+    // The params generated by resolving all promises in inputs
+    private params: u.MultiArray<any>;
 
-    // The input promises
-    private inputs: Promise<any>[];
+    // How many promises are currently pending
+    private pending = 0;
 
-    // The corresponding values produced by the input promises
-    private values: any[] = [];
+    // How many promises have never produced a value (pending + !progress)
+    private noValue = 0;
 
-    // How many input promises have been fulfilled
-    private numFulfilled = 0;
+    // The function to lift
+    private fn: Function;
+
+    // The output of the function
+    output = new r.Promise<any>();
 
     /*----------------------------------------------------------------
-     * Creates dependencies for each input promise
+     * Subscribe to all input promises
      */
-    constructor( inputs: Promise<any>[], mask?: boolean[] ) {
-      var numInputs = inputs.length;
+    constructor( fn: Function, inputs: u.MultiArray<any>, mask: u.MultiArray<boolean> = null ) {
+      this.fn = fn;
       this.inputs = inputs;
-      this.values.length = numInputs;
-      this.promise = new Promise<any[]>();
-      if (plogger) {
-        plogger.register( this.promise, 'parampack', 'parameter pack' );
+      this.params = this.genParams( inputs, mask, [] );
+      this.output.ondropped.addObserver( this );
+
+      if (this.pending == 0) {
+        this.invoke();
       }
-      this.promise.ondropped.addObserver( this );
+    }
 
-      if (numInputs) {
-        for (var i = 0; i < numInputs; ++i) {
-          if (mask && mask[i]) {
-            this.onParameterFulfilled( inputs[i], i );
+    /*----------------------------------------------------------------
+     * Convert input array to parameter array -- i.e., replacing
+     * promises with their value.
+     */
+    private
+    genParams(
+      inputs: u.MultiArray<any>,
+      mask:   u.MultiArray<boolean>,
+      place:  number[]
+    ):        u.MultiArray<any> {
+
+      var params: any[] = [];
+      for (var i = 0, l = inputs.length; i < l; ++i) {
+        var input = inputs[i];
+
+        if (Array.isArray( input )) {
+          params[i] = this.genParams( input,
+                                      Array.isArray( mask ) ? <u.MultiArray<boolean>>mask[i] : null,
+                                      place.concat( [i] ) );
+        }
+        else if (input instanceof r.Promise) {
+          if (Array.isArray( mask ) && mask[i]) {
+            params[i] = input;
           }
           else {
-            inputs[i].addDependency<void, number>(
+            params[i] = noValue;
+            input.addDependency(
               this,
-              this.onParameterFulfilled,
-              this.onParameterRejected,
-              this.onParameterProgress,
-              i
+              this.onParamFulfilled,
+              this.onParamRejected,
+              this.onParamProgress,
+              place.concat( [i] )
             );
+            this.promises.push( input );
+            ++this.pending;
+            ++this.noValue;
           }
         }
+        else {
+          params[i] = input;
+        }
       }
-      else {
-        this.promise.resolve( this.values );
-      }
+      return params;
     }
 
     /*----------------------------------------------------------------
-     * Set the corresponding value; fulfill or notify
+     * Inserts the value of a resolved promise into the parameter
+     * multi-array.
      */
-    onParameterFulfilled( value: any, index: number ) {
-      this.values[index] = value;
-      if (++this.numFulfilled == this.values.length) {
-        this.promise.resolve( this.values );
+    private
+    resolveParam(
+      value: any,
+      params: u.MultiArray<any>,
+      place: number[],
+      i: number
+    ) {
+
+      var idx = place[i];
+      if (i == place.length - 1) {
+        if (params[idx] === noValue) {
+          --this.noValue;
+        }
+        params[idx] = value;
       }
       else {
-        this.promise.notify( this.values );
+        this.resolveParam( value, params[idx], place, i + 1 );
       }
     }
 
     /*----------------------------------------------------------------
-     * If any parameter fails then we fail.
-     */
-    onParameterRejected( reason: any, index: number ) {
-      this.promise.reject( null );
-    }
-
-    /*----------------------------------------------------------------
-     * Set the corresponding value; notify
+     * Called when promise resolves
      */
-    onParameterProgress( value: any, index: number ) {
-      this.values[index] = value;
-      this.promise.notify( this.values );
+    onParamFulfilled( value: any, place: number[] ) {
+      this.resolveParam( value, this.params, place, 0 );
+      --this.pending;
+      if (this.noValue == 0) {
+        this.invoke();
+      }
     }
 
     /*----------------------------------------------------------------
-     * When parameters no longer needed, unsubscribe from all
+     * If any parameter fails then we fail
      */
-    onNext() {
-      this.inputs.forEach( function( p: Promise<any> ) {
+    onParamRejected( reason: any ) {
+      this.output.reject( null );
+      this.promises.forEach( function( p: Promise<any> ) {
         p.removeDependency( this );
       }, this );
-      this.promise.ondropped.removeObserver( this );
     }
 
-    onError() { }
-
-    onCompleted() { }
-
-  }
-
-  /*==================================================================
-   * Takes a function and a promise for an array of parameters,
-   * returns a promise for the result of calling the function.
-   * Only calls the function one time, once all parameters are ready.
-   */
-  export class SingleFunctionCall {
-
-    // The function to call
-    fn: Function;
-
-    // Promises for the parameters to pass
-    parameters: Promise<any[]>;
-
-    // Promises for each output produced
-    outputPromises: Promise<any>[] = [];
-
     /*----------------------------------------------------------------
-     * Subscribes to parameters; creates output promises
+     * Set the corresponding value; notify
      */
-    constructor( fn: Function,
-                 parameters: Promise<any[]>,
-                 numOutputs: number
-               ) {
-      this.fn = fn;
-      this.parameters = parameters;
-      parameters.addDependency( this );
-      for (var i = 0; i < numOutputs; ++i) {
-        var p = new Promise<any>();
-        p.ondropped.addObserver( this );
-        this.outputPromises.push( p );
+    onParamProgress( value: any, place: number[] ) {
+      this.resolveParam( value, this.params, place, 0 );
+      if (this.noValue == 0) {
+        this.invoke();
       }
     }
 
     /*----------------------------------------------------------------
-     * Call the function and pass on results
      */
-    onFulfilled( value: any[] ) {
-      var numOutputs = this.outputPromises.length;
+    private
+    invoke() {
       try {
-        var result = this.fn.apply( null, value );
-        if (numOutputs > 0) {
-          if (numOutputs == 1) {
-            result = [result];
-          }
-          else if (! Array.isArray( result )) {
-            throw new TypeError( 'Multi-output lifted function did not return array' );
-          }
+        var result = this.fn.apply( null, this.params );
+        if (this.pending == 0) {
+          this.output.resolve( result );
         }
-
-        for (var i = 0; i < numOutputs; ++i) {
-          this.outputPromises[i].resolve( result[i] );
-          if (result[i] instanceof Promise && !(<Promise<any>>result[i]).isSettled()) {
-            this.outputPromises[i].ondropped.addObserver( result[i] );
-          }
+        else {
+          this.output.notify( result );
         }
       }
       catch (e) {
         console.error( e );
-        for (var i = 0; i < numOutputs; ++i) {
-          this.outputPromises[i].reject( e );
-        }
-      }
-    }
-
-    /*----------------------------------------------------------------
-     * If the parameters fail then the function fails
-     */
-    onRejected( reason: any ) {
-      var numOutputs = this.outputPromises.length;
-      for (var i = 0; i < numOutputs; ++i) {
-        this.outputPromises[i].reject( reason );
+        this.output.reject( e );
       }
     }
 
     /*----------------------------------------------------------------
-     * Ignore
-     */
-    onProgress() { }
-
-    /*----------------------------------------------------------------
-     * If everyone stops listening to the result, we cancel the call
      */
-    onNext() {
-      var anyRelevant = this.outputPromises.some( function( p: Promise<any> ) {
-        return p.hasDependencies();
-      } );
-      if (! anyRelevant) {
-        this.parameters.removeDependency( this );
-        this.outputPromises.forEach( function( p: Promise<any> ) {
-          p.reject( null );
-        } );
+    onNext( p: r.Promise<any> ) {
+      if (p === this.output) {
+        this.promises.forEach( function( p: Promise<any> ) {
+          p.removeDependency( this );
+        }, this );
       }
     }
 
-    // ignore
     onError() { }
-
-    // ignore
     onCompleted() { }
 
   }
diff --git a/src/hd/reactive/observable.ts b/src/hd/reactive/observable.ts
index e2450e9..51aaf85 100644
--- a/src/hd/reactive/observable.ts
+++ b/src/hd/reactive/observable.ts
@@ -75,13 +75,13 @@ module hd.reactive {
 
     // List of observers
     // (Note: inherits empty list from prototype; copies on write)
-    '#observers': Observer<T>[];
+    observers: Observer<T>[];
 
     /*----------------------------------------------------------------
      * Predicate to tell if anyone's listening
      */
     hasObservers(): boolean {
-      return this['#observers'].length > 0
+      return this.observers.length > 0
     }
 
     /*----------------------------------------------------------------
@@ -109,12 +109,12 @@ module hd.reactive {
       else {
         observer = new ProxyObserver( object, onNext, onError, onCompleted, id );
       }
-      if (this.hasOwnProperty( '#observers' )) {
-        this['#observers'].push( observer );
+      if (this.hasOwnProperty( 'observers' )) {
+        this.observers.push( observer );
       }
       else {
         // copy on write
-        this['#observers'] = [observer];
+        this.observers = [observer];
       }
       return observer;
     }
@@ -124,12 +124,12 @@ module hd.reactive {
      */
     removeObserver( observer: Object ): boolean {
       var removed = false;
-      for (var i = this['#observers'].length; i >= 0; --i) {
-        var o = this['#observers'][i];
+      for (var i = this.observers.length; i >= 0; --i) {
+        var o = this.observers[i];
         if (o === observer ||
             (o instanceof ProxyObserver &&
              (<ProxyObserver<T>>o).object === observer)) {
-          this['#observers'].splice( i, 1 );
+          this.observers.splice( i, 1 );
           removed = true;
         }
       }
@@ -140,9 +140,11 @@ module hd.reactive {
      * Send "next" event to all observers.
      */
     sendNext( value: T ): void {
-      this['#observers'].slice( 0 ).forEach( function( observer: Observer<T> ) {
-        observer.onNext( value );
-        //u.schedule( ObservablePriority, observer.onNext, observer, value );
+      this.observers.slice( 0 ).forEach( function( observer: Observer<T> ) {
+        if (observer.onNext) {
+          observer.onNext( value );
+          //u.schedule( ObservablePriority, observer.onNext, observer, value );
+        }
       } );
     }
 
@@ -150,9 +152,11 @@ module hd.reactive {
      * Send "error" event to all observers.
      */
     sendError( error: any ): void {
-      this['#observers'].slice( 0 ).forEach( function( observer: Observer<T> ) {
-        observer.onError( error );
-        //u.schedule( ObservablePriority, observer.onError, observer, error );
+      this.observers.slice( 0 ).forEach( function( observer: Observer<T> ) {
+        if (observer.onError) {
+          observer.onError( error );
+          //u.schedule( ObservablePriority, observer.onError, observer, error );
+        }
       } );
     }
 
@@ -160,17 +164,18 @@ module hd.reactive {
      * Send "completed" event to all observers.
      */
     sendCompleted(): void {
-      this['#observers'].slice( 0 ).forEach( function( observer: Observer<T> ) {
-        observer.onCompleted();
-        //u.schedule( ObservablePriority, observer.onCompleted, observer );
+      this.observers.slice( 0 ).forEach( function( observer: Observer<T> ) {
+        if (observer.onCompleted) {
+          observer.onCompleted();
+          //u.schedule( ObservablePriority, observer.onCompleted, observer );
+        }
       } );
-      delete this['#observers'];
     }
 
   }
 
   // Inherited empty observer list
-  BasicObservable.prototype['#observers'] = [];
+  BasicObservable.prototype.observers = [];
 
 
   /*==================================================================
diff --git a/src/hd/reactive/promise.ts b/src/hd/reactive/promise.ts
index d7d25af..36cbfd1 100644
--- a/src/hd/reactive/promise.ts
+++ b/src/hd/reactive/promise.ts
@@ -443,6 +443,7 @@ module hd.reactive {
       // Clean up
       delete this.dependencies;
       this.sendCompleted();
+      delete this.observers;
       u.schedule( DroppedPriority, this.ondropped.sendCompleted, this.ondropped );
     }
 
diff --git a/src/hd/system/activate.ts b/src/hd/system/activate.ts
index 0d8050d..d2590d4 100644
--- a/src/hd/system/activate.ts
+++ b/src/hd/system/activate.ts
@@ -7,7 +7,8 @@ module hd.system {
   /*==================================================================
    * An operation over variables in the property model
    */
-  export interface Operation {
+  export
+  interface Operation {
 
     // Function that implements this operation
     fn: Function;
@@ -18,13 +19,13 @@ module hd.system {
     // Inputs to pass to the function, in the order they should be passed
     // Variables in this list will be replaced with their value; everything
     // else will be treated as constants to be passed to the function.
-    inputs: any[];
+    inputs: u.MultiArray<any>;
 
     // Parallel to inputs; true means input comes from prior generation
-    priorFlags: boolean[];
+    priorFlags: u.MultiArray<boolean>;
 
     // Outputs to write to, in the order they are returned form the function
-    outputs: m.Variable[];
+    outputs: u.MultiArray<m.Variable>;
 
     // Is this an external operation?  (Does it trigger an update after execution?)
     external: boolean;
@@ -41,6 +42,8 @@ module hd.system {
   }
 
   /*==================================================================
+   * Serves as a constant function for operations that only give a
+   * result.
    */
 
   function constantFunction( result: any, numOutputs = 1 ): r.Promise<any>|r.Promise<any>[] {
@@ -73,56 +76,210 @@ module hd.system {
 
   export
   function activate( op: Operation ): ActivationRecord {
-    var params: any[] = [];
-
-    var priorLookup: u.Dictionary<r.Promise<any>> = {};
     var inputLookup: u.Dictionary<r.Promise<any>> = {};
+    var priorLookup: u.Dictionary<r.Promise<any>> = {};
     var outputLookup: u.Dictionary<r.Promise<any>> = {};
 
-    // Collect parameter promises
-    for (var i = 0, l = op.inputs.length; i < l; ++i) {
-      var param: r.Promise<any>;
+    /*----------------------------------------------------------------
+     * Recursive function for building parameter multi-array while
+     * recording the promise retrieved from each variable.
+     */
+    function collectParams(
+      inputs:      u.MultiArray<any>,
+      priors:      u.MultiArray<boolean>
+    ) {
+
+      var params: u.MultiArray<r.Promise<any>> = [];
 
-      // An input is either a variable or a constant
-      var input = op.inputs[i];
-      if (input instanceof m.Variable) {
+      // Collect parameter promises
+      for (var i = 0, l = inputs.length; i < l; ++i) {
 
-        // If it's a variable, determine what promise to use
-        if (op.priorFlags && op.priorFlags[i]) {
-          if (! (param = priorLookup[input.id])) {
-            if (config.forwardPriorGens) {
-              param = priorLookup[input.id] = input.getForwardedPromise();
+        // An input is either a variable, an array, or a constant
+        var input = inputs[i];
+        var prior = priors ? priors[i] : undefined;
+        if (input instanceof m.Variable) {
+          var param: r.Promise<any>;
+
+          // If it's a variable, determine what promise to use
+          if (prior) {
+            if (! (param = priorLookup[input.id])) {
+              if (config.forwardPriorGens) {
+                param = priorLookup[input.id] = input.getForwardedPromise();
+              }
+              else {
+                param = priorLookup[input.id] = input.getCurrentPromise();
+              }
             }
-            else {
-              param = priorLookup[input.id] = input.getCurrentPromise();
+          }
+          else {
+            if (! (param = inputLookup[input.id])) {
+              // Make a new, dependent promise for evaluation graph
+              param = inputLookup[input.id] = new r.Promise();
+              var oldp = input.getStagedPromise();
+              if (r.plogger) {
+                r.plogger.register( param, input.name, 'input parameter' );
+              }
+              param.resolve( oldp );
+              param.ondropped.addObserver( oldp );
             }
           }
+          params.push( param );
+        }
+        else if (Array.isArray( input )) {
+          // If its an array, we recurse
+          params.push( collectParams( <u.MultiArray<any>>input,
+                                      <u.MultiArray<boolean>>prior ) );
+        }
+        else {
+          // If it's a constant, we create a satisfied promise
+          var param = new r.Promise<any>();
+          if (r.plogger) {
+            r.plogger.register( param, op.inputs[i], 'constant parameter' );
+          }
+          param.resolve( op.inputs[i] );
+          params.push( param );
+        }
+
+      }
+
+      return params;
+    }
+
+    /*----------------------------------------------------------------
+     * Recursive function which assigns method results to
+     * corresponding variables of the output signature, while
+     * recording the promise for each output variable.
+     *
+     * If the method returned a single promise in place of a
+     * multi-array of promises, then this function (1) generates the
+     * multi-array of promises required, and (2) subscribes to the
+     * single promise so that when it is resolved, its value will be
+     * used to resolve the generated multi-array.
+     */
+
+    function assignResults(
+      output:       m.Variable | u.MultiArray<m.Variable>,
+      result:       r.Promise<any> | u.MultiArray<r.Promise<any>>
+    ) {
+
+      if (output instanceof m.Variable) {
+        // If we were expecting a single value...
+
+        if (outputLookup[output.id]) {
+          // This would only happen if an operation has the same output twice
+          //   -- i.e., an invalid method
+          console.error( 'Operation attempting to output twice to same variable' );
+        }
+        else {
+          // Get promise
+          var p: r.Promise<any>;
+          if (result instanceof r.Promise) {
+            p = result;
+          }
+          else {
+            p = new r.Promise<any>( result );
+          }
+          if (r.plogger) {
+            r.plogger.register( p, output.name, 'output' );
+          }
+
+          // Record promise
+          outputLookup[output.id] = p;
+
+          // Assign result
+          if (op.external) {
+            output.set( p );
+          }
+          else {
+            output.makePromise( p );
+          }
+        }
+      }
+      else if (Array.isArray( output )) {
+        // If we were expecting a multi-array...
+
+        var outputs = <u.MultiArray<m.Variable>> output; // just to avoid type-casts
+
+        // If we got an array, then recursively match the promises
+        if (Array.isArray( result )) {
+          var results = <u.MultiArray<any>>result; // just to avoid type-casts
+          for (var i = 0, l = outputs.length; i < l; ++i) {
+            assignResults( outputs[i], results[i] );
+          }
         }
         else {
-          if (! (param = inputLookup[input.id])) {
-            // Make a dependent promise for parameter
-            param = inputLookup[input.id] = new r.Promise();
-            var oldp = input.getStagedPromise();
+
+          // Then we resolve the multi-array using the value of the single promise
+          var p: r.Promise<any>;
+          if (result instanceof r.Promise) {
+            p = result;
+          }
+          else {
+            p = new r.Promise( result );
             if (r.plogger) {
-              r.plogger.register( param, input.name, 'input parameter' );
+              r.plogger.register( p, '?', 'output placeholder' );
             }
-            param.resolve( oldp );
-            param.ondropped.addObserver( oldp );
           }
+
+          var promises = <u.MultiArray<r.Promise<any>>>generatePromises( outputs );
+
+          p.addDependency(
+            null,
+            resolveMany( promises ),
+            rejectMany( promises ),
+            null
+          );
+        }
+      }
+
+    }
+
+    /*----------------------------------------------------------------
+     * Generates a multi-array of promises which is parallel to the
+     * provided multi-array of variables: one promise for each
+     * variable
+     */
+
+    function generatePromises(
+      output: m.Variable | u.MultiArray<m.Variable>
+    ):        r.Promise<any> | u.MultiArray<r.Promise<any>> {
+
+      if (output instanceof m.Variable) {
+        if (outputLookup[output.id]) {
+          console.error( 'Operation attempting to output twice to same variable' );
+        }
+        else {
+          var p = outputLookup[output.id] = new r.Promise<any>();
+          if (r.plogger) {
+            r.plogger.register( p, output.name, 'output' );
+          }
+          // Assign result
+          if (op.external) {
+            output.set( p );
+          }
+          else {
+            output.makePromise( p );
+          }
+          return p;
         }
       }
       else {
-        // If it's a constant, we create a satisfied promise
-        param = new r.Promise();
-        if (r.plogger) {
-          r.plogger.register( param, op.inputs[i], 'constant parameter' );
+        var outputs = <u.MultiArray<m.Variable>>output; // just to avoid type-casts
+        var ps: u.MultiArray<r.Promise<any>> = [];
+        for (var i = 0, l = outputs.length; i < l; ++i) {
+          ps[i] = generatePromises( outputs[i] );
         }
-        param.resolve( op.inputs[i] );
+        return ps;
       }
-
-      params.push( param );
     }
 
+    /*----------------------------------------------------------------
+     * Body of activate
+     */
+
+    // Get the parameters
+    var params = collectParams( op.inputs, op.priorFlags );
+
     // Invoke the operation
     try {
       var result: any;
@@ -130,17 +287,7 @@ module hd.system {
         result = op.fn.apply( null, params );
       }
       else {
-        result = constantFunction( op.result, op.outputs.length );
-      }
-
-      // Ensure result is an array
-      if (op.outputs.length > 0) {
-        if (op.outputs.length == 1) {
-          result = [result];
-        }
-        else if (! Array.isArray( result )) {
-          throw new TypeError( 'Multi-output activating function did not return array' );
-        }
+        result = op.result;
       }
     }
     catch (e) {
@@ -154,30 +301,76 @@ module hd.system {
       }
     }
 
-    // Set output promises
-    for (var i = 0, l = op.outputs.length; i < l; ++i) {
-      // An output is always a variable
-      var vv = op.outputs[i];
-      if (outputLookup[vv.id]) {
-        console.error( 'Operation attempting to output same variable twice' );
+    // Match results to signature
+    assignResults( op.outputs[0], result );
+
+    return {inputs:  inputLookup,
+            outputs: outputLookup};
+  }
+
+  /*==================================================================
+   * Resolves all promises in a promise multi-array with corresponding
+   * value in value multi-array.  If we find a single value where we
+   * were expecting an multi-array of values, then we assume it is a
+   * promise and subscribe to it so that we can use its value to
+   * fulfill the multi-array.  Curried to make it easier to subscribe
+   * to promises.
+   */
+  function resolveMany( promises: u.MultiArray<r.Promise<any>> ) {
+    return function( results: any ) {
+      // It should be an array (we wouldn't use this for a single promise)
+      if (Array.isArray( results )) {
+        for (var i = 0, l = promises.length; i < l; ++i) {
+          var promise = promises[i];
+          var result = results[i];
+          if (promise instanceof r.Promise) {
+            // Single promise
+            promise.resolve( result );
+          }
+          else if (Array.isArray( promise )) {
+            var subpromises = <u.MultiArray<r.Promise<any>>>promise; // just to avoid type-casts
+            // Array of promises
+            if (Array.isArray( result )) {
+              // Array of values
+              resolveMany( subpromises )( result );
+            }
+            else {
+              // Single value
+              var p: r.Promise<any>;
+              if (result instanceof r.Promise) {
+                p = result;
+              }
+              else {
+                p = new r.Promise( result );
+              }
+              p.addDependency(
+                null,
+                resolveMany( subpromises ),
+                rejectMany( subpromises ),
+                null
+              );
+            }
+          }
+        }
       }
       else {
-        var p = <r.Promise<any>>result[i];
-        outputLookup[vv.id] = p
-        if (r.plogger) {
-          r.plogger.register( p, vv.name, 'output parameter' );
-        }
-        if (op.external) {
-          vv.set( p );
+        console.error( "Expected array for return value of method" );
+        rejectMany( promises )( "Internal error" );
+      }
+    }
+  }
+
+  function rejectMany( promises: u.MultiArray<r.Promise<any>> ) {
+    return function( reason: any ) {
+      for (var i = 0, l = promises.length; i < l; ++i) {
+        var promise = promises[i];
+        if (promise instanceof r.Promise) {
+          promise.reject( reason );
         }
         else {
-          vv.makePromise( p );
+          rejectMany( <u.MultiArray<r.Promise<any>>>promise)( reason );
         }
       }
     }
-
-    return {inputs:  inputLookup,
-            outputs: outputLookup};
   }
-
 }
diff --git a/src/hd/system/api.ts b/src/hd/system/api.ts
new file mode 100644
index 0000000..849330c
--- /dev/null
+++ b/src/hd/system/api.ts
@@ -0,0 +1,7 @@
+module hd {
+
+  import s = hd.system;
+
+  // RunTime
+  export var PropertyModel = s.PropertyModel;
+}
diff --git a/src/hd/system/pm.ts b/src/hd/system/pm.ts
index 0c07cb9..b204d39 100644
--- a/src/hd/system/pm.ts
+++ b/src/hd/system/pm.ts
@@ -84,6 +84,7 @@ module hd.system {
     private hasOptionals: boolean;
 
     private commandQueue: m.Command[] = [];
+    private accumPromises: r.AccumulatingPromise<any>[] = [];
     private isCommandScheduled = false;
 
     /*----------------------------------------------------------------
@@ -303,8 +304,7 @@ module hd.system {
         this.cgraph.addMethod( mm.id,
                                cid,
                                mm.inputVars.map( u.getId ),
-                               mm.outputs.map( u.getId )
-                             );
+                               mm.outputVars.map( u.getId ) );
       }
     }
 
@@ -323,7 +323,7 @@ module hd.system {
     //--------------------------------------------
     // Add command
     addCommand( cmd: m.Command ) {
-      cmd.addObserver( this, this.scheduleCommand, null, null );
+      cmd.addObserver( this, this.performCommand, null, null );
     }
 
     //--------------------------------------------
@@ -471,7 +471,7 @@ module hd.system {
         break;
 
       case m.VariableEventType.command:
-        this.scheduleCommand( event.cmd );
+        this.performCommand( event.cmd );
         break;
       }
     }
@@ -808,13 +808,33 @@ module hd.system {
       this.isCommandScheduled = false;
       while (this.commandQueue.length > 0) {
         var cmd = this.commandQueue.shift();
-        activate( cmd );
+        var ar = activate( cmd );
+        for (var id in ar.outputs) {
+          if (ar.outputs[id] instanceof r.AccumulatingPromise) {
+            console.log( 'Found one' );
+          }
+        }
         if (cmd.external) {
           this.update();
         }
       }
     }
 
+    performCommand( cmd: m.Command ) {
+      for (var i = 0, l = this.accumPromises.length; i < l; ++i) {
+        this.accumPromises[i].settle();
+      }
+      var ar = activate( cmd );
+      this.accumPromises = [];
+      for (var id in ar.outputs) {
+        var p = ar.outputs[id];
+        if (p instanceof r.AccumulatingPromise) {
+          this.accumPromises.push( p );
+        }
+      }
+      this.update();
+    }
+
   }
 
 }
diff --git a/src/hd/utility/adt.ts b/src/hd/utility/adt.ts
index f691d73..2188088 100644
--- a/src/hd/utility/adt.ts
+++ b/src/hd/utility/adt.ts
@@ -33,6 +33,116 @@ module hd.utility {
     [key: string]: T;
   }
 
+  /*==================================================================
+   * JavaScript does not have multi-dimensional arrays, just
+   * arrays-of-arrays.  This interface just supports generic
+   * arrays-of-arrays without specifying a depth.
+   */
+  export
+  interface MultiArray<T> extends Array<T|MultiArray<T>> { };
+
+  export
+  module multiArray {
+
+    /*------------------------------------------------------------------
+     */
+    export
+    function copy<T>( ts: MultiArray<T> ) {
+      var t2s = <MultiArray<T>>[];
+      for (var i = 0, l = ts.length; i < l; ++i) {
+        if (Array.isArray( ts[i] )) {
+          t2s.push( copy( <MultiArray<T>>ts[i] ) );
+        }
+        else {
+          t2s.push( ts[i] );
+        }
+      }
+      return t2s;
+    }
+
+    /*------------------------------------------------------------------
+     */
+    export
+    function map<T, U>(
+      ts:      MultiArray<T>,
+      fn:      (t: T, i: number, ts: MultiArray<T>) => U,
+      thisArg: Object = null
+    ):         MultiArray<U> {
+
+      var results: MultiArray<U> = [];
+      for (var i = 0, l = ts.length; i < l; ++i) {
+        if (Array.isArray( ts[i] )) {
+          results.push( map( <MultiArray<T>>ts[i], fn, thisArg ) );
+        }
+        else {
+          results.push( fn.call( thisArg, <T>ts[i], i, ts ) );
+        }
+      }
+      return results
+    }
+
+    /*----------------------------------------------------------------
+     */
+    export
+    function some<T>(
+      ts:      MultiArray<T>,
+      fn:      (t: T, i: number, ts: MultiArray<T>) => boolean,
+      thisArg: Object = null
+    ):         boolean {
+
+      for (var i = 0, l = ts.length; i < l; ++i) {
+        if (Array.isArray( ts[i] )) {
+          if (some( <MultiArray<T>>ts[i], fn, thisArg )) {
+            return true;
+          }
+        }
+        else {
+          if (fn.call( thisArg, <T>ts[i], i, ts )) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+
+    /*----------------------------------------------------------------
+     */
+    export
+    function toString<T>( ts: MultiArray<T> ) {
+      var result: (T|string)[] = [];
+      for (var i = 0, l = ts.length; i < l; ++i) {
+        if (i > 0) {
+          result.push( ',' );
+        }
+        if (Array.isArray( ts[i] )) {
+          result.push( '[' );
+          result.push( toString( <MultiArray<T>>ts[i] ) );
+          result.push( ']' );
+        }
+        else {
+          result.push( <T>ts[i] );
+        }
+      }
+      return result.join( '' );
+    }
+
+    /*----------------------------------------------------------------
+     */
+    export
+    function flatten<T>( from: MultiArray<T>, to: T[] = [] ) {
+      for (var i = 0, l = from.length; i < l; ++i) {
+        if (Array.isArray( from[i] )) {
+          flatten( <MultiArray<T>>from[i], to );
+        }
+        else {
+          to.push( <T>from[i] );
+        }
+      }
+      return to;
+    }
+
+  }
+
   /*==================================================================
    * The standard Array interface, pared back to only support
    * operations that make sense on a set.
diff --git a/src/hd/utility/api.ts b/src/hd/utility/api.ts
new file mode 100644
index 0000000..1ad9912
--- /dev/null
+++ b/src/hd/utility/api.ts
@@ -0,0 +1,7 @@
+module hd {
+
+  import u = hd.utility;
+
+  export var dateCompare = u.dateCompare;
+
+}
diff --git a/src/qunit/ladder.ts b/src/qunit/ladder.ts
index abecce1..d722f19 100644
--- a/src/qunit/ladder.ts
+++ b/src/qunit/ladder.ts
@@ -51,7 +51,7 @@ module hd.qunit {
           ok( false, "received " + received + " when expecting " + expecting );
         }
         else {
-          equal( value, expecting.value, "next received expected value " + expecting.value );
+          deepEqual( value, expecting.value, "next received expected value " + expecting.value );
         }
         if (expecting.cb) {
           expecting.cb();
diff --git a/src/qunit/model.ts b/src/qunit/model.ts
index a3e2924..b072dc0 100644
--- a/src/qunit/model.ts
+++ b/src/qunit/model.ts
@@ -8,22 +8,21 @@ module hd.qunit {
 
   function id<T>( x: T ): T { return x };
 
-  function checkSequence( vals: any[], poss: m.Position[] ) {
+  function checkSequence( paths: m.Path[], poss: m.Position[] ) {
     var i = 0;
-    return function( val: any, pos: m.Position ) {
-      if (i >= vals.length || i >= poss.length) {
-        ok( false, "Sequence too long" );
-      }
-      else {
-        equal( val, vals[i], "Sequence value" );
-        equal( pos, poss[i], "Sequence position" );
-        ++i;
-      }
+    var itr = new m.PathSetIterator( paths );
+    while (itr.pos != null) {
+      deepEqual( itr.pos, poss[i], "Path list has expected position" );
+      i++;
+      itr.next();
+    }
+    if (i < poss.length) {
+      ok( false, "Expected more positions for path list" );
     }
   }
 
   test( "paths", function() {
-    expect( 21 );
+    expect( 20 );
 
     var spec = new m.ContextBuilder().references( "x, y, z" ).spec();
 
@@ -33,19 +32,19 @@ module hd.qunit {
 
     ctx.i = 8;
     var p1 = new m.Path( ctx, "i" );
-    equal( p1.get( null ), ctx.i, "one field path" );
+    equal( p1.get(), ctx.i, "one field path" );
 
     ctx.a.j = 9;
     var p2 = new m.Path( ctx, "a.j" );
-    equal( p2.get( null ), ctx.a.j, "two field path" );
+    equal( p2.get(), ctx.a.j, "two field path" );
 
     ctx.a.b.k = 10;
     var p3 = new m.Path( ctx, "a.b.k" );
-    equal( p3.get( null ), ctx.a.b.k, "three field path" );
+    equal( p3.get(), ctx.a.b.k, "three field path" );
 
-    ok( p1.constant && p2.constant && p3.constant, "constant paths" );
+    ok( p1.isConstant() && p2.isConstant() && p3.isConstant(), "constant paths" );
 
-    var nr = new Result( E.next, null );
+    var nr = new Result( E.next, {} );
     var mr = new Result( E.next, "oops" );
 
     var vers = <any> [];
@@ -54,59 +53,61 @@ module hd.qunit {
     var p4 = new m.Path( ctx, "x.j" );
     p4.addObserver( new ObservableTest( [nr, // rem
                                         ] ) );
-    equal( p4.get( null ), ctx.a.j, "one reference path" );
+    equal( p4.get(), ctx.a.j, "one reference path" );
 
-    var o1 = (<any>p4).observers0[0];
-    ok( 'destruct' in o1, "field observer" );
+    var o1 = <m.PropertyObserver>(<any>p4).rootObserver;
+    ok( o1 instanceof m.PropertyObserver, "field observer" );
 
     var p5 = new m.Path( ctx, "x.y.k" );
     p5.addObserver( new ObservableTest( [nr, // set
                                          nr, // rem
                                         ] ) );
 
-    var o2 = (<any>p5).observers0[0];
-    ok( 'destruct' in o2, "field observer" );
-    var o3 = (<any>p5).observers0[1];
-    ok( 'destruct' in o3, "field observer" );
+    var o2 = <m.PropertyObserver>(<any>p5).rootObserver;
+    ok( o2 instanceof m.PropertyObserver, "field observer" );
+    var o3 = <m.PropertyObserver>o2.child;
+    ok( o2 instanceof m.PropertyObserver, "field observer" );
 
     ctx.a.y = ctx.a.b;
-    equal( p5.get( null ), ctx.a.b.k, "two reference path" );
+    equal( p5.get(), ctx.a.b.k, "two reference path" );
 
     var p6 = new m.Path( ctx, "x.k" );
-    strictEqual( p6.get( null ), undefined, "dangling path" );
+    strictEqual( p6.get(), undefined, "dangling path" );
 
     ctx.x = ctx.a.b;
-    equal( p6.get( null ), ctx.a.b.k, "shortcut path" );
-    strictEqual( p5.get( null ), undefined, "dangling path" );
-    strictEqual( p4.get( null ), undefined, "dangling path" );
-    ok( o1.property['#observers'][0] === o1, "still watching" );
-    ok( o2.property['#observers'][1] === o2, "still watching" );
-    ok( o3.property['#observers'].length == 0, "done watching" );
-
-    p6.forEach( checkSequence( [ctx.a.b.k], [null] ) );
-    p5.forEach( checkSequence( [], [] ) );
+    equal( p6.get(), ctx.a.b.k, "shortcut path" );
+    strictEqual( p5.get(), undefined, "dangling path" );
+    strictEqual( p4.get(), undefined, "dangling path" );
+    ok( (<any>o1.property).observers[0] === o1, "still watching" );
+    ok( (<any>o2.property).observers[1] === o2, "still watching" );
+    ok( (<any>o3.property).observers.length == 0, "done watching" );
+
+    checkSequence( [p6], [{}] );
+    checkSequence( [p4], [] );
   } );
 
   test( "array paths", function() {
-    expect( 27 );
+    expect( 17 );
 
     var spec = new m.ContextBuilder().references( "x, y, z" ).spec();
 
-    var ctx1: any = m.Context.construct( new m.Context(), spec );
+    var ctx1: any = new m.Context( spec );
     ctx1.x = new m.ArrayContext();
     ctx1.x.length = 10;
 
     var p1 = new m.Path( ctx1, "x[i]" );
-    var o1 = (<any>p1).observers0[1];
-    ok( o1.ctx === ctx1.x, "watching array" );
-    ok( ctx1.x.changes['#observers'][0] === o1, "array being watched" );
-    var t1 = new ObservableTest( [new Result( E.next, 2 ),
-                                  new Result( E.next, 8 ),
-                                  new Result( E.next, 5 ),
-                                  new Result( E.next, 2 ),
-                                  new Result( E.next, 2 ),
-                                  new Result( E.next, 5 ),
-                                  new Result( E.next, 4 )
+    var o1 = <m.PropertyObserver>(<any>p1).rootObserver;
+    ok( o1 instanceof m.PropertyObserver, "property observer" );
+    var o2 = <m.ArrayObserver>o1.child;
+    ok( o2 instanceof m.ArrayObserver, "array observer" );
+    ok( o2.ctx === ctx1.x, "watching array" );
+    ok( ctx1.x.changes.observers[0] === o2, "array being watched" );
+    var t1 = new ObservableTest( [new Result( E.next, {i: 2} ),
+                                  new Result( E.next, {i: 8} ),
+                                  new Result( E.next, {i: 5} ),
+                                  new Result( E.next, {i: 2} ),
+                                  new Result( E.next, {i: 5} ),
+                                  new Result( E.next, {i: 4} )
                                  ] );
     p1.addObserver( t1 );
     ctx1.x[2] = 1;
@@ -117,7 +118,7 @@ module hd.qunit {
     ctx1.x[4] = 9;
     p1.removeObserver( t1 );
 
-    p1.forEach( checkSequence( [6, 9, 2], [2, 4, 8] ) );
+    checkSequence( [p1], [{i: 2}, {i: 4}, {i: 8}] );
 
     ctx1.b = new m.ArrayContext();
     ctx1.b.length = [10];
@@ -125,17 +126,11 @@ module hd.qunit {
     ctx1.b[5] = 9;
     ctx1.b[9] = 8;
 
-    var t2 = new ObservableTest( [new Result( E.next, 2 ),
-                                  new Result( E.next, 4 ),
-                                  new Result( E.next, 8 ),
-                                  new Result( E.next, 4 ),
-                                  new Result( E.next, 5 ),
-                                  new Result( E.next, 9 )
-                                 ] );
+    var t2 = new ObservableTest( [new Result( E.next, {} )] );
     p1.addObserver( t2 );
 
     ctx1.x = ctx1.b;
-    p1.forEach( checkSequence( [10, 9, 8], [4, 5, 9] ) );
+    checkSequence( [p1], [{i: 4}, {i: 5}, {i: 9}] );
 
   } );
 
@@ -386,7 +381,7 @@ module hd.qunit {
     ctx = new m.ContextBuilder()
           .variables( "x, y, z", {x: 3, y: 4, z: 5} )
           .references( "a, b, c" )
-          .constraint(  "a, b => b, c" )
+          .constraint(  "b => b, c" )
             .method( "b -> c", id )
           .context();
     x = m.Context.update( ctx );
@@ -401,7 +396,7 @@ module hd.qunit {
     ctx.c = ctx.z;
     var x = m.Context.update( ctx );
     ok( x.removes.length == 0 && x.adds.length == 1,
-        "One updates" );
+        "One update" );
 
     ok( x.adds[0] instanceof m.Constraint, "Update is constraint" );
 
@@ -462,4 +457,55 @@ module hd.qunit {
     equal( a.length, 8, "Set length 2" );
 
   } );
+
+  test( "slice paths", function() {
+    var Spec = new m.ContextBuilder().r( 'x' ).spec();
+    var Spec2 = new m.ContextBuilder().n( 'b', hd.arrayOf( Spec ) ).spec();
+    var ctx: any = new m.ContextBuilder().n( 'a', hd.arrayOf( hd.arrayOf( Spec2 ) ) ).context();
+
+    var p1 = new m.Path( ctx, 'a[i][*].b[k].x' );
+
+    ctx.a.expand( 3 );
+    for (var i = 0; i < 3; ++i) {
+      ctx.a[i].expand( 3 );
+      for (var j = 0; j < 3; ++j) {
+        ctx.a[i][j].b.expand( 3 );
+      }
+    }
+
+    ctx.a[0][0].b[0].x = 1;
+    ctx.a[0][1].b[0].x = 2;
+    ctx.a[0][2].b[0].x = 3;
+
+    ctx.a[2][0].b[1].x = 4;
+    ctx.a[2][1].b[1].x = 5;
+    ctx.a[2][2].b[1].x = 7;
+
+    ctx.a[0][0].b[2].x = 8;
+    ctx.a[0][1].b[2].x = 6;
+    ctx.a[0][2].b[2].x = 4;
+
+    ctx.a[1][0].b[1].x = 2;
+    ctx.a[1][1].b[1].x = 3;
+    ctx.a[1][2].b[1].x = 4;
+
+    ctx.a[1][0].b[2].x = 3;
+    ctx.a[1][1].b[2].x = 4;
+    ctx.a[1][2].b.length = 2;
+
+    ctx.a[0][0].b[1].x = 10;
+    ctx.a[1][0].b[0].x = 8;
+    ctx.a[1][1].b[0].x = 12;
+
+    deepEqual( p1.get( {i: 0, k: 0} ), [1, 2, 3], "Retrieved slice" );
+    deepEqual( p1.get( {i: 2, k: 1} ), [4, 5, 7], "Retrieved slice" );
+    deepEqual( p1.get( {i: 0, k: 2} ), [8, 6, 4], "Retrieved slice" );
+    deepEqual( p1.get( {i: 1, k: 1} ), [2, 3, 4], "Retrieved slice" );
+    strictEqual( p1.get( {i: 1, k: 2} ), undefined, "Undefined for staggered lengths" );
+    strictEqual( p1.get( {i: 0, k: 1} ), undefined, "Undefined for missing elements" );
+    strictEqual( p1.get( {i: 1, k: 0} ), undefined, "Undefined for missing elements" );
+
+    checkSequence( [p1], [{i: 0, k: 0}, {i: 0, k: 2}, {i: 1, k: 1}, {i: 2, k: 1}] );
+  } );
+
 }
diff --git a/src/qunit/reactive.ts b/src/qunit/reactive.ts
index 1641fcf..331be96 100644
--- a/src/qunit/reactive.ts
+++ b/src/qunit/reactive.ts
@@ -105,12 +105,14 @@ module hd.qunit {
     o.addObserver( stabilizer );
     var count = 0;
     stabilizer.addObserver( null,
-      function( n: number ) {
+      function( p: r.Promise<number> ) {
         equal( ++count, 1, "stabilizer only notified once" );
-        equal( n, 10, "stabilizer received correct value" );
-        hd.utility.schedule( 1, function() { start(); } );
+        p.then( function( n: number ) {
+          equal( n, 10, "stabilizer received correct value" );
+          hd.utility.schedule( 1, function() { start(); } );
+        } );
       },
-      function( n: number ) {
+      function( e: any ) {
         ok( false, "stabilizer received error" );
       },
       null
@@ -238,62 +240,8 @@ module hd.qunit {
 
   } );
 
-  // asyncTest( "ladder", function() {
-  //   expect( 8 );
-
-  //   var ladder = new r.PromiseLadder<number>( 4 );
-  //   ok( ladder.isSettled(), "Ladder created with fulfilled promise" );
-
-  //   var count = 0;
-  //   ladder.addObserver( null,
-  //     function( n: number ) {
-  //       switch (++count) {
-  //       case 1:
-  //         equal( n, 11, "First value correct" );
-  //         break;
-  //       case 2:
-  //         equal( n, 12, "Second value correct" );
-  //         break;
-  //       case 3:
-  //         equal( n, 14, "Third value correct" );
-  //         break;
-  //       default:
-  //         ok( false, "Too many values" );
-  //       }
-  //     },
-  //     null, null
-  //   );
-
-  //   var p1 = new r.Promise<number>();
-  //   var p2 = new r.Promise<number>();
-  //   var p3 = new r.Promise<number>();
-  //   var p4 = new r.Promise<number>();
-  //   var p5 = new r.Promise<number>();
-  //   ladder.addPromise( p1 );
-  //   ladder.addPromise( p2 );
-  //   ladder.addPromise( p3 );
-  //   strictEqual( ladder.currentPromise(), p3, "Current promise correct" );
-  //   ladder.addPromise( p4 );
-  //   ladder.addPromise( p5 );
-  //   strictEqual( ladder.currentPromise(), p5, "Current promise correct" );
-
-  //   ok( ! ladder.isSettled(), "Ladder has promises" );
-
-  //   p1.resolve( 11 );
-  //   p3.resolve( 12 );
-  //   p2.resolve( 13 );
-  //   p5.resolve( 14 );
-  //   p4.resolve( 15 );
-
-  //   hd.utility.schedule( 3, function() {
-  //     equal( count, 3, "Correct number of notifications" );
-  //     start();
-  //   } );
-
-  // } );
-
   asyncTest( "lifting functions", function() {
-    expect( 8 );
+    expect( 11 );
 
     var lifted1 =
           r.liftFunction( function( a: number, b: number ) {
@@ -303,7 +251,7 @@ module hd.qunit {
     var lifted2 =
           r.liftFunction( function( a: number, b: number ) {
             return [a + b, a * b];
-          }, 2 );
+          } );
 
     ok( typeof lifted1 === 'function' &&
         typeof lifted2 === 'function'   , "Lifting produces a function" );
@@ -311,29 +259,54 @@ module hd.qunit {
     var a = new r.Promise<number>();
     var b = new r.Promise<number>();
     var c = lifted1( a, b );
-    var ds = lifted2( a, b );
+    var d = lifted2( a, b );
 
     ok( c instanceof r.Promise, "Lifted function return promise" );
-    ok( Array.isArray( ds ), "Lifted function with multiple outputs returned array" );
-    ok( ds.length == 2, "Array was of length 2" );
-    ok( ds[0] instanceof r.Promise &&
-        ds[1] instanceof r.Promise   , "Array contained promises" );
+    ok( d instanceof r.Promise, "Lifted function return promise" );
 
     c.then( function( n: number ) {
       equal( n, 5, "Lifted function produced correct value" );
     } );
 
-    ds[0].then( function( n: number ) {
-      equal( n, 5, "Lifted function first output correct value" );
-    } );
-
-    ds[1].then( function( n: number ) {
-      equal( n, 6, "Lifted function second output correct value" );
+    d.then( function( ns: number[] ) {
+      ok( Array.isArray( ns ), "Lifted function produced an array" );
+      equal( ns[0], 5, "Lifted function first output correct value" );
+      equal( ns[1], 6, "Lifted function second output correct value" );
     } );
 
     a.resolve( 2 );
     b.resolve( 3 );
 
+    var lifted3 =
+          r.liftFunction( function( n: number, m: number ) {
+            return n + m;
+          } );
+
+    var n = new r.Promise<number>();
+    var m = new r.Promise<number>();
+    var o = lifted3( n, m );
+    var i = 0;
+
+    o.then(
+      function( n: number ) {
+        equal( n, 12, "Lifted function produced correct value" );
+      },
+      null,
+      function( n: number ) {
+        switch (i++) {
+        case 0: return equal( n, 7, "Lifted function produced correct notification" );
+        case 1: return equal( n, 9, "Lifted function produced correct notification" );
+        case 2: return equal( n, 11, "Lifted function produced correct notification" );
+        }
+      }
+    );
+
+    n.notify( 3 );
+    m.notify( 4 );
+    n.resolve( 5 );
+    m.notify( 6 );
+    m.resolve( 7 );
+
     hd.utility.schedule( 4, function() {
       start();
     } );
diff --git a/src/qunit/system.ts b/src/qunit/system.ts
index 2701c2b..61ce25f 100644
--- a/src/qunit/system.ts
+++ b/src/qunit/system.ts
@@ -92,7 +92,7 @@ module hd.qunit {
     pm.update();
 
     pm.removeConstraint( c );
-    c.addMethod( new m.Method( "x,y->z", hd.reactive.liftFunction( sum ), [x,y], null, [z], [x,y] ) );
+    c.addMethod( new m.Method( "x,y->z", hd.reactive.liftFunction( sum ), [x,y], null, [z], [x,y], [z] ) );
     pm.addConstraint( c );
     pm.update();
 
@@ -657,7 +657,7 @@ module hd.qunit {
   } );
 
   asyncTest( "set commands", function() {
-    expect( 12 );
+    expect( 9 );
 
     var ctx: any = new m.ContextBuilder()
           .variables( "x, y, z", {x: 3, y: 5} )
@@ -673,20 +673,18 @@ module hd.qunit {
     checkVariables( ctx, {x: 3, y: 5, z: 8}, "1" );
 
     ctx.x.commandSet( 4 );
-    pm.performCommands();
     checkVariables( ctx, {x: 4, y: 5, z: 9}, "2" );
 
     ctx.y.commandSet( 3 );
     ctx.z.commandSet( 10 );
-    checkVariables( ctx, {x: 4, y: 5, z: 9}, "2 (again)" );
-
-    pm.performCommands();
     checkVariables( ctx, {x: 7, y: 3, z: 10}, "4" );
 
     u.schedule( 3, start );
   } );
 
   asyncTest( "command queue", function() {
+    expect( 24 );
+
     var spec = new m.ContextBuilder()
           .variables( "a, x, y, z", {a: 12, x: 3, y: 5} )
           .constraint( "x, y, z" )
@@ -723,10 +721,6 @@ module hd.qunit {
 
     ctx3.cmd.activate();
 
-    checkVariables( ctx1, {a: 12, x: 3, y: 5, z: 8}, "1.1 (again)" );
-    checkVariables( ctx2, {a: 12, x: 3, y: 5, z: 8}, "1.2 (again)" );
-    checkVariables( ctx3, {a: 12, x: 3, y: 5, z: 8}, "1.3 (again)" );
-
     u.schedule( 3, function() {
       checkVariables( ctx1, {a: 12, x: 6, y: 6, z: 12}, "2.1" );
     } );
@@ -790,4 +784,159 @@ module hd.qunit {
 
     u.schedule( 3, start );
   } );
+
+  asyncTest( "slice constraints", function() {
+    var ctx: any = new m.ContextBuilder()
+          .nested( "a", hd.arrayOf( hd.Variable ) )
+          .v( "sum" )
+          .c( "a[*], sum" )
+          .m( "a[*] -> sum", function( a: number[] ) {
+            var sum = 0;
+            for (var i = 0; i < a.length; ++i) {
+              sum+= a[i];
+            }
+            return sum;
+          } )
+          .context();
+
+    ctx.a.expand( [2, 4, 6, 8, 10] );
+
+    var pm = new hd.PropertyModel();
+    pm.addComponent( ctx );
+    pm.update();
+    checkVariables( ctx, {sum: 30}, "0" );
+
+    ctx.a[3].set( 12 );
+    pm.update();
+    checkVariables( ctx, {sum: 34}, "1" );
+
+    ctx.a.expand( [14] );
+    pm.update();
+    checkVariables( ctx, {sum: 48}, "2" );
+
+    ctx.a.collapse( 2 );
+    pm.update();
+    checkVariables( ctx, {sum: 24}, "3" );
+
+    ctx.a.length = 5;
+    ctx.a[0].set( 5 );
+    pm.update();
+    // Because ctx.a contains an undefined, constraint should be uninstantiated
+    // Therefore, sum should remain unchanged
+    checkVariables( ctx, {sum: 24}, "3" );
+
+    ctx.a.length = 4;
+    pm.update()
+    // Now they are all defined again
+    checkVariables( ctx, {sum: 27}, "4" );
+
+    u.schedule( 3, start );
+  } );
+
+  asyncTest( "matrix test", function() {
+    expect( 25 );
+
+    var Matrix = hd.arrayOf( hd.arrayOf( hd.Variable ) );
+
+    function dotProduct( n: number[], m: number[] ) {
+      var dot = 0;
+      for (var i = 0, l = n.length; i < l; ++i) {
+        dot += n[i] * m[i];
+      }
+      return dot;
+    }
+
+    var ctx: any = new m.ContextBuilder()
+          .n( "a", Matrix )
+          .n( "b", Matrix )
+          .n( "c", Matrix )
+          .c( "a[i][*], b[*][j], c[i][j]" )
+          .m( "a[i][*], b[*][j] -> c[i][j]", dotProduct )
+          .context();
+
+    ctx.a.expand( [[1, 2, 3],
+                   [4, 5, 6] ] );
+    ctx.b.expand( [[2, 4],
+                   [6, 8],
+                   [10, 12]] );
+    ctx.c.expand( [[0, 0],
+                   [0, 0]] );
+
+    var pm = new hd.PropertyModel();
+    pm.addComponent( ctx );
+    pm.update();
+    checkVariables( ctx.c[0], <any>[/* 1*2 + 2*6 + 3*10 == */44,
+                                    /* 1*4 + 2*8 + 3*12 == */56], "0.0" );
+    checkVariables( ctx.c[1], <any>[/* 4*2 + 5*6 + 6*10 == */98,
+                                    /* 4*4 + 5*8 + 6*12 == */128], "1.0" );
+
+    ctx.a[0][1].set( -2 );
+    pm.update();
+    checkVariables( ctx.c[0], <any>[/* 1*2 - 2*6 + 3*10 == */20,
+                                    /* 1*4 - 2*8 + 3*12 == */24], "0.1" );
+    checkVariables( ctx.c[1], <any>[/* 4*2 + 5*6 + 6*10 == */98,
+                                    /* 4*4 + 5*8 + 6*12 == */128], "1.1" );
+
+    ctx.a[1][2].set( 2 );
+    ctx.b[0][0].set( 1 );
+    pm.update();
+    checkVariables( ctx.c[0], <any>[/* 1*1 - 2*6 + 3*10 == */19,
+                                    /* 1*4 - 2*8 + 3*12 == */24], "0.2" );
+    checkVariables( ctx.c[1], <any>[/* 4*1 + 5*6 + 2*10 == */54,
+                                    /* 4*4 + 5*8 + 2*12 == */80], "1.2" );
+
+    ctx.a[0].expand( [4] );
+    ctx.a[1].expand( [5] );
+    ctx.b.expand( [[14, 16]] );
+    pm.update();
+    checkVariables( ctx.c[0], <any>[/* 1*1 - 2*6 + 3*10 + 4*14 == */75,
+                                    /* 1*4 - 2*8 + 3*12 + 4*16 == */88], "0.3" );
+    checkVariables( ctx.c[1], <any>[/* 4*1 + 5*6 + 2*10 + 5*14 == */124,
+                                    /* 4*4 + 5*8 + 2*12 + 5*16 == */160], "1.3" );
+
+    ctx.a.expand( [[1, 2, 1, 2]] );
+    ctx.b[0].expand( [1] );
+    ctx.b[1].expand( [-1] );
+    ctx.b[2].expand( [1] );
+    ctx.b[3].expand( [-1] );
+    ctx.c[0].expand( [0] );
+    ctx.c[1].expand( [0] );
+    ctx.c.expand( [[0, 0, 0]] );
+    pm.update();
+    checkVariables( ctx.c[0], <any>[/* 1*1 - 2*6 + 3*10 + 4*14 == */75,
+                                    /* 1*4 - 2*8 + 3*12 + 4*16 == */88,
+                                    /* 1*1 + 2*1 + 3*1  - 4*1  == */2], "0.4" );
+    checkVariables( ctx.c[1], <any>[/* 4*1 + 5*6 + 2*10 + 5*14 == */124,
+                                    /* 4*4 + 5*8 + 2*12 + 5*16 == */160,
+                                    /* 4*1 - 5*1 + 2*1  - 5*1  == */-4], "1.4" );
+    checkVariables( ctx.c[2], <any>[/* 1*1 + 2*6 + 1*10 + 2*14 == */51,
+                                    /* 1*4 + 2*8 + 1*12 + 2*16 == */64,
+                                    /* 1*1 - 2*1 + 1*1  - 2*1  == */-2], "2.4" );
+
+    u.schedule( 4, start );
+  } );
+
+  asyncTest( "array params", function() {
+
+    var ctx: any = new hd.ContextBuilder()
+          .vs( 'a, b, c, d, e', {a: 8, d: 4} )
+
+          .c( 'a, b, c' )
+          .m( 'b, c -> a', function( b: number, c: number ) {
+            return b + c;
+          } )
+          .m( 'a -> b, c', function( a: number ) {
+            return [a/2, a/2];
+          } )
+
+          .context();
+
+    var pm = new hd.PropertyModel();
+    pm.addComponent( ctx );
+    pm.update();
+
+    checkVariables( ctx, {a: 8, b: 4, c: 4}, "_1" );
+
+    u.schedule( 4, start );
+  } );
 }
diff --git a/test/cases/autocomplete.html b/test/cases/autocomplete.html
new file mode 100644
index 0000000..80d9f5b
--- /dev/null
+++ b/test/cases/autocomplete.html
@@ -0,0 +1,108 @@
+<html>
+  <head>
+    <title>HotDrink Test Case</title>
+    <style type="text/css">
+      body {
+          padding: 2em 0 0 2em;
+      }
+      td:nth-child(odd) {
+          width: 100px;
+      }
+      td:nth-child(even) {
+          width: 300px;
+      }
+      .ac {
+          width: 250px;
+          border: 1px solid black;
+          font-size: 12px;
+      }
+      .scroll {
+          width: 248px;
+          height: 180px;
+          overflow-y: auto;
+          border: 1px solid black;
+      }
+      .menu {
+          width: 248px;
+          border-collapse: collapse;
+          margin: 0;
+      }
+      .menu td {
+          border-color: black;
+          border-style: solid none;
+          border-width: 1px;
+          cursor: pointer;
+      }
+      .menu td:first-child {
+          border-top-style: none;
+      }
+      menu td:last-child {
+          border-bottom-style: none;
+      }
+      .menu td.on {
+          background-color: #026;
+          color: #fff;
+      }
+      .menu.disabled td {
+          background-color: #ddd;
+          cursor: default;
+      }
+      .menu.disabled td.on {
+          background-color: #999;
+          color: #ddd;
+      }
+    </style>
+    <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js"></script>
+    <script src="../../scripts/hotdrink.js"></script>
+    <script type="text/javascript" src="autocomplete.js"></script>
+    <script type="text/javascript">
+      /*====================================================================
+       * On document ready
+       */
+      $(function() {
+        autocomplete( document.getElementById( 'nohd' ) );
+
+        context = new hd.ContextBuilder()
+            .nested( 'ac', HdAutoComplete )
+            .context();
+
+        pm = new hd.PropertyModel();
+        pm.addComponent( context );
+
+        hd.performDeclaredBindings( context );
+      } );
+    </script>
+  </head>
+  <body>
+    <table>
+      <tr>
+	<td>Manual:</td>
+        <td><input type="text" id="nohd" class="ac"/></td>
+	<td>HotDrink:</td>
+        <td><input type="text" id="hd" class="ac" data-bind="hdAutoComplete( this, ac )"/></td>
+      </tr>
+      <tr>
+        <td></td>
+        <td>
+          <div class="scroll">
+            <table id="nohd-menu" class="menu">
+            </table>
+          </div>
+        </td>
+        <td></td>
+        <td>
+          <div class="scroll">
+            <table id="hd-menu" class="menu">
+            </table>
+          </div>
+        </td>
+      </tr>
+      <tr>
+        <td></td>
+        <td id="nohd-result"></td>
+        <td></td>
+        <td id="hd-result" data-bind="hd.text( ac.value )"></td>
+      </tr>
+    </table>
+  </body>
+</html>
diff --git a/test/cases/autocomplete.js b/test/cases/autocomplete.js
new file mode 100644
index 0000000..0dca061
--- /dev/null
+++ b/test/cases/autocomplete.js
@@ -0,0 +1,395 @@
+
+/*====================================================================
+ * Helper function for Ajax calls.
+ */
+
+function ajaxError( jqXHR, status, error ) {
+  alert( status );
+  console.error( status, error );
+}
+
+/*====================================================================
+ * Implementation of autocomplete using ordinary
+ */
+
+function autocomplete( input ) {
+  var table = document.getElementById( input.id + '-menu' );
+  var query = '';
+  var index = -1;
+  var menu = [];
+  var value = '';
+  var timeout;
+
+  $(input).keydown(
+    function( e ) {
+      if (e.keyCode == 38) {
+        incIndex( -1 );
+        e.preventDefault();
+      }
+      else if (e.keyCode == 40) {
+        incIndex( 1 );
+        e.preventDefault();
+      }
+      else if (e.keyCode == 13) {
+        input.value = value;
+        query = '';
+        clearMenu();
+        e.preventDefault();
+      }
+    }
+  ).keyup(
+    function( e ) {
+      if (e.keyCode != 37 && e.keyCode != 38 &&
+          e.keyCode != 39 && e.keyCode != 40 && e.keyCode != 13) {
+        if (timeout) {
+          clearTimeout( timeout );
+        }
+        timeout = window.setTimeout( function() {
+          setQuery( input.value );
+          timeout = null;
+        }, 400 );
+      }
+    }
+  );
+
+  function setQuery( to ) {
+    if (query == to) { return; }
+
+    query = to;
+    index = -1;
+    value = query;
+
+    // Initiate Ajax
+    if (query) {
+      $.ajax({
+        type: 'GET',
+        url: 'http://autocomplete.wunderground.com/aq',
+        data: {
+          'query': query
+        },
+        dataType: 'jsonp',
+        jsonp: 'cb',
+        crossDomain: true,
+        success: function( response ) {
+          // On success, update menu
+          setMenu( response.RESULTS.map( function( city ) { return city.name; } ) )
+        },
+        error: ajaxError
+      });
+    }
+    else {
+      setMenu( [] );
+    }
+  }
+
+  function setMenu( to ) {
+    menu = to;
+    clearMenu();
+    for (var i = 0, l = menu.length; i < l; ++i) {
+      var tr = table.insertRow( i );
+      var td = tr.insertCell( 0 );
+      $(td).mouseenter(
+        function() {
+          setIndex( this.parentElement.rowIndex )
+        }
+      ).click(
+        function() {
+          input.value = value;
+          query = '';
+          clearMenu();
+        }
+      )
+
+      td.appendChild( document.createTextNode( menu[i] ) );
+    }
+
+    setIndex( 0 );
+  }
+
+  function clearMenu() {
+    while (table.rows.length > 0) {
+      table.deleteRow( 0 );
+    }
+  }
+
+  function setIndex( to ) {
+    index = to;
+    if (index >= 0 && index < menu.length) {
+      value = menu[index];
+    }
+    for (var i = 0, l = table.rows.length; i < l; ++i) {
+      if (i == index) {
+        var td = table.rows[i].firstElementChild;
+        td.classList.add( 'on' );
+        if (td.scrollIntoViewIfNeeded) {
+          td.scrollIntoViewIfNeeded();
+        }
+        else {
+          td.scrollIntoView();
+        }
+      }
+      else {
+        table.rows[i].firstElementChild.classList.remove( 'on' );
+      }
+    }
+  }
+
+  function incIndex( howmany ) {
+    var to = index + howmany;
+    if (to < -1) {
+      to = -1;
+    }
+    if (to > menu.length) {
+      to = menu.length;
+    }
+    setIndex( to );
+  }
+}
+
+/*====================================================================
+ * HotDrink model
+ */
+
+var HdAutoComplete;
+
+$(function() {
+
+  var autoCompleteSpec = new hd.ContextBuilder()
+      // Variables
+      .vs( 'query, menu, index, value' )
+
+      // Calculate menu
+      .c( 'query, menu' )
+      .m( 'query -> menu',
+          function( query ) {
+            var p = new hd.Promise();
+
+            // Initiate Ajax
+            if (query) {
+              var thisObj = this;
+              $.ajax({
+                type: 'GET',
+                url: 'http://autocomplete.wunderground.com/aq',
+                data: {
+                  'query': query
+                },
+                dataType: 'jsonp',
+                jsonp: 'cb',
+                crossDomain: true,
+                success: function( response ) {
+                  // On success, update menu
+                  p.resolve( response.RESULTS.map(
+                    function( city ) { return city.name; }
+                  ) )
+                },
+                error: ajaxError
+              });
+            }
+            else {
+              p.resolve( [] );
+            }
+
+            return p;
+          } )
+
+      // Calculate value
+      .c( 'query, menu, index, value' )
+      .m( 'query, menu, index -> value',
+          function( query, menu, index) {
+            if (index >= 0 && index < menu.length) {
+              return menu[index];
+            }
+            else {
+              return query
+            }
+          } )
+
+      // After writing to query, calculate index
+      .c( 'query => menu, index' )
+      .m( '!value, menu -> index',
+          function( value, menu ) {
+            var i = menu.indexOf( value );
+            return i < 0 ? 0 : i;
+          } )
+
+      // Increment index
+      .cmd( 'inc', '!index, !menu -> index',
+            function( i, m ) {
+              return i < m.length ? i + 1 : m.length;
+            } )
+
+      // Decrement index
+      .cmd( 'dec', '!index -> index',
+            function( i ) {
+              return i >= 0 ? i - 1 : -1;
+            } )
+
+      .spec();
+
+
+  //------------------------------------------------------------------
+  // Make a JavaScript type for this spec.
+
+  HdAutoComplete = function HdAutoComplete() {
+    hd.Context.call( this, autoCompleteSpec );
+  };
+
+  HdAutoComplete.prototype = Object.create( hd.Context.prototype );
+});
+
+/*====================================================================
+ * View adapter for autocomplete menu -- a container for several
+ * different observables and observers
+ */
+
+function AutoCompleteMenu( input ) {
+  var table = document.getElementById( input.id + '-menu');
+  var menuVisible = false;
+  var menuEnabled = true;
+
+  // Extra logic: hide menu when input finalized
+  input.addEventListener( 'change', function( e ) {
+    menuVisible = false;
+    while (table.rows.length > 0) {
+      table.deleteRow( 0 );
+    }
+  } );
+
+  // Observables for increment and decrement command
+  var inc = this.inc = new hd.BasicObservable();
+  var dec = this.dec = new hd.BasicObservable();
+
+  input.addEventListener( 'keydown', function( e ) {
+    if (menuVisible) {
+      if (e.keyCode == 38) {
+        dec.sendNext( e );
+        e.preventDefault();
+      }
+      if (e.keyCode == 40) {
+        inc.sendNext( e );
+        e.preventDefault();
+      }
+    }
+  } );
+  input.addEventListener( 'input', function() {
+    menuVisible = true;
+  } );
+
+  // Observable for mouse over row
+  var hover = new hd.BasicObservable();
+  this.hover = hover;
+
+  table.addEventListener( 'mouseleave', function() {
+    hover.sendNext( -1 );
+  } );
+
+  this.disabled = {
+    onNext: function( disable ) {
+      if (disable == menuEnabled) {
+        if (disable) {
+          table.classList.add( 'disabled' );
+        }
+        else {
+          table.classList.remove( 'disabled' );
+        }
+        menuEnabled = !disable;
+      }
+    }
+  }
+
+  // Observer for menu items
+  this.items = {
+    onNext: function( items ) {
+      if (! menuVisible) { return }
+      while (table.rows.length > 0) {
+        table.deleteRow( 0 );
+      }
+      for (var i = 0, l = items.length; i < l; ++i) {
+        var tr = table.insertRow( i );
+        var td = tr.insertCell( 0 );
+        td.addEventListener( 'mouseenter', function() {
+          if (menuEnabled) {
+            hover.sendNext( this.parentElement.rowIndex );
+          }
+        } );
+        td.addEventListener( 'click', function() {
+          if (menuEnabled) {
+            input.dispatchEvent( new Event( 'change', {bubbles: true, cancelable: false} ) );
+          }
+        } )
+        td.appendChild( document.createTextNode( items[i] ) );
+      }
+    },
+  };
+
+    // Observer for selected index
+  this.highlight = {
+    onNext: function( index ) {
+      if (menuVisible) {
+        for (var i = 0, l = table.rows.length; i < l; ++i) {
+          if (i == index) {
+            var td = table.rows[i].firstElementChild;
+            td.classList.add( 'on' );
+            if (td.scrollIntoViewIfNeeded) {
+              td.scrollIntoViewIfNeeded();
+            }
+            else {
+              td.scrollIntoView();
+            }
+          }
+          else {
+            table.rows[i].firstElementChild.classList.remove( 'on' );
+          }
+        }
+      }
+    },
+  };
+}
+
+
+/*====================================================================
+ * Create binding for HdAutoComplete -- connect observables and
+ * observers
+ */
+
+function hdAutoComplete( input, ac ) {
+  var menu = new AutoCompleteMenu( input );
+
+  return [
+    // The input element: read value, write query
+    {view:    new hd.Edit( input ),
+     toModel: hd.stabilize(),
+     model:   hd.rw( ac.value, ac.query ),
+     dir:     hd.Direction.bi},
+
+    // Menu items
+    {view:  menu.items,
+     model: ac.menu,
+     dir:   hd.Direction.m2v},
+
+    // Menu disabled while pending
+    {view:  menu.disabled,
+     model: ac.menu.pending,
+     dir:   hd.Direction.m2v},
+
+    // Index to highlight
+    {view:  menu.highlight,
+     model: ac.index,
+     dir:   hd.Direction.m2v},
+
+    // Index being hovered
+    {view:  menu.hover,
+     model: ac.index,
+     dir:   hd.Direction.v2m},
+
+    // Decrement command
+    {view:  menu.dec,
+     model: ac.dec,
+     dir:   hd.Direction.v2m},
+
+    // Increment command
+    {view:  menu.inc,
+     model: ac.inc,
+     dir:   hd.Direction.v2m},
+  ];
+}
diff --git a/test/cases/expense.html b/test/cases/expense.html
index 172544f..dc9fa2e 100644
--- a/test/cases/expense.html
+++ b/test/cases/expense.html
@@ -7,6 +7,7 @@
     </style>
     <script type="text/javascript" src="../../scripts/hotdrink.js"></script>
     <script type="text/javascript">
+    {
       function sum( a ) {
         var total = 0;
         for (var i = 0, l = a.length; i < l; ++i) {
@@ -16,31 +17,45 @@
       }
 
       var context = new hd.ContextBuilder()
-      .variables( {miles: 50, mpg: 30, gallons: undefined, gas: 3.5, travel: undefined} )
-      .equation( 'miles / gallons == mpg' )
-      .equation( 'gallons * gas == travel' )
+          .variables( {miles: 50, mpg: 30, gallons: undefined, gas: 3.5, travelCost: undefined} )
+          .equation( 'miles / gallons == mpg' )
+          .equation( 'gallons * gas == travelCost' )
 
-      .variables( {checkin: new Date().setHours( 0, 0, 0, 0 ),
-                   nights: 1, checkout: undefined, rate: 150, hotel: undefined} )
-      .equation( 'checkout - checkin == nights * 86400000')
-      .equation( 'nights * rate == hotel' )
+          .variables( {usetravel: true, travel: 0} )
+          .constraint( 'usetravel, travel, travelCost' )
+          .method( 'usetravel, *travelCost -> travel',
+                   function( usetravel, travelCost ) {
+                     return usetravel ? travelCost : 0;
+                   } )
 
-      .variables( {food: 30, tip: 0.15, meals: undefined} )
-      .equation( 'food * (1 + tip) == meals' )
+          .variables( {checkin: new Date().setHours( 0, 0, 0, 0 ),
+                       nights: 1, checkout: undefined, rate: 150, hotelCost: undefined} )
+          .equation( 'checkout - checkin == nights * 86400000')
+          .equation( 'nights * rate == hotelCost' )
 
-      .variables( {usetravel: true, usehotel: true, usemeals: true, total: undefined} )
-      .output( 'total' )
-      .constraint( 'usetravel, travel, usehotel, hotel, usemeals, meals, total' )
-      .method( 'usetravel, *travel, usehotel, *hotel, usemeals, *meals -> total',
-               function( usetravel, travel, usehotel, hotel, usemeals, meals ) {
-                 if (! usetravel) { travel = new hd.Promise( 0 ); }
-                 if (! usehotel)  { hotel  = new hd.Promise( 0 ); }
-                 if (! usemeals)  { meals  = new hd.Promise( 0 ); }
-                 return hd.Promise.all( travel, hotel, meals ).then( sum );
-               }
-             )
+          .variables( {usehotel: true, hotel: 0} )
+          .constraint( 'usehotel, hotel, hotelCost' )
+          .method( 'usehotel, *hotelCost -> hotel',
+                   function( usehotel, hotelCost ) {
+                     return usehotel ? hotelCost : 0;
+                   } )
 
-      .context();
+          .variables( {food: 30, tip: 0.15, mealsCost: undefined} )
+          .equation( 'food * (1 + tip) == mealsCost' )
+
+          .variables( {usemeals: true, meals: 0} )
+          .constraint( 'usemeals, meals, mealsCost' )
+          .method( 'usemeals, *mealsCost -> meals',
+                   function( usemeals, mealsCost ) {
+                     return usemeals ? mealsCost : 0;
+                   } )
+
+          .variables( {total: undefined} )
+          .output( 'total' )
+          .constraint( 'travel, hotel, meals, total' )
+          .method( 'travel, hotel, meals -> total', hd.sum )
+
+          .context();
 
       var pm = new hd.PropertyModel();
       pm.addComponent( context );
@@ -48,6 +63,7 @@
       window.addEventListener( 'load', function() {
         hd.performDeclaredBindings( context );
       } );
+    }
     </script>
   </head>
   <body>
@@ -71,7 +87,7 @@
         </tr>
         <tr>
           <td>Total Cost:</td>
-          <td><input type="text" data-bind="hd.numVar( travel, 2 )"/></td>
+          <td><input type="text" data-bind="hd.numVar( travelCost, 2 )"/></td>
         </tr>
       </table>
     </fieldset>
@@ -97,7 +113,7 @@
         </tr>
         <tr>
           <td>Total Cost:</td>
-          <td><input type="text" data-bind="hd.numVar( hotel, 2 )"/></td>
+          <td><input type="text" data-bind="hd.numVar( hotelCost, 2 )"/></td>
         </tr>
       </table>
     </fieldset>
@@ -117,7 +133,7 @@
         </tr>
         <tr>
           <td>Total Cost:</td>
-          <td><input type="text" data-bind="hd.numVar( meals, 2 )"></td>
+          <td><input type="text" data-bind="hd.numVar( mealsCost, 2 )"></td>
         </tr>
       </table>
     </fieldset>
diff --git a/test/cases/pull1.html b/test/cases/pull1.html
index 21a1e21..119ec69 100644
--- a/test/cases/pull1.html
+++ b/test/cases/pull1.html
@@ -79,8 +79,8 @@
         context.drag = p;
       }
 
-      function stopDragging( p ) {
-        if (context.drag === p) {
+      function stopDragging() {
+        if (context.drag) {
           context.drag = null;
         }
       }
@@ -91,7 +91,7 @@
     <div class="puck"
          data-bind="hd.text( p.txt ), hd.position( p.pos, hd.offset( -30, -30 ) ),
                     hd.mousedown( hd.fn( startDragging, p ) ),
-                    hd.mouseup( hd.fn( stopDragging, p ) ),
+                    hd.mouseup( hd.fn( stopDragging ) ),
                     hd.dblclick( hd.fn( addPoint, idx ) )"><div>
   </body>
 </html>
diff --git a/test/cases/pull2.html b/test/cases/pull2.html
index cde4a70..54b2843 100644
--- a/test/cases/pull2.html
+++ b/test/cases/pull2.html
@@ -97,8 +97,8 @@
         context.drag = p;
       }
 
-      function stopDragging( p ) {
-        if (context.drag === p) {
+      function stopDragging() {
+        if (context.drag) {
           context.drag = null;
         }
       }
@@ -109,7 +109,7 @@
     <div class="puck"
          data-bind="hd.text( p.txt ), hd.position( p.pos, hd.offset( -30, -30 ) ),
                     hd.mousedown( hd.fn( startDragging, p ) ),
-                    hd.mouseup( hd.fn( stopDragging, p ) ),
+                    hd.mouseup( hd.fn( stopDragging ) ),
                     hd.dblclick( hd.fn( addPoint, idx ) )"><div>
   </body>
 </html>
diff --git a/test/cases/shipping.html b/test/cases/shipping.html
index 42d26ae..5515e6f 100644
--- a/test/cases/shipping.html
+++ b/test/cases/shipping.html
@@ -13,7 +13,7 @@
       fieldset input[type="text"] { font-size: 80% }
       td.padr { padding-right: 2em; }
       small { font-size: 70% }
-      input[type="button"] { display: block; }
+      button { display: block; margin: 1em 0; }
     </style>
     <script type="text/javascript" src="../../scripts/hotdrink.js"></script>
     <script type="text/javascript">
@@ -21,13 +21,25 @@
       var q = [];
 
       function delay( v, n ) {
-        var p = new hd.Promise();
+        var p;
+        if (Array.isArray( v )) {
+          p = v.map( function() { return new hd.Promise(); } );
+        }
+        else {
+          p = new hd.Promise();
+        }
 
-        var b = document.createElement( 'input' );
-        b.type = 'button';
-        b.value = n;
+        var b = document.createElement( 'button' );
+        b.innerHTML = n;
         b.onclick = function() {
-          p.resolve( v );
+          if (Array.isArray( v )) {
+            for (var i = 0, l = v.length; i < l; ++i) {
+              p[i].resolve( v[i] );
+            }
+          }
+          else {
+            p.resolve( v );
+          }
           document.getElementById( 'buttons' ).removeChild( b );
         }
         var bs= document.getElementById( 'buttons' ).appendChild( b );
@@ -62,7 +74,7 @@
             default:  perkm = 0.1;
                       break;
             }
-            return [delay(distance*perkm, 'target'), delay(distance*perkm, 'price')];
+            return delay( [distance*perkm, distance*perkm], 'distance, class &rarr; target, price' );
           } )
           .m( 'target, klass -> distance, price', function( target, klass ) {
             var perkm;
@@ -79,7 +91,7 @@
                       break;
             }
             var distance = Math.floor( target/perkm );
-            return [delay(distance, 'distance'), delay(distance*perkm, 'price')];
+            return delay( [distance, distance*perkm], 'target, class &rarr; distance, price' );
           } )
           .m( 'target, distance -> klass, price', function( target, distance ) {
             var perkm = target / distance;
@@ -105,7 +117,7 @@
               klass = 'A';
             }
 
-            return [delay(klass, 'class'), delay(distance*perkm, 'price')];
+            return delay( [klass, distance*perkm], 'target, distance &rarr; class, price' );
           } )
 
           .c( 'volume, weight, klass' )
@@ -119,7 +131,7 @@
             else if (weight <= 25)   klass = 'C';
             else if (weight <= 50)   klass = 'D';
             else                     klass = 'E';
-            return delay( klass, 'class' );
+            return delay( klass, 'volume, weight &rarr; class' );
           } )
           .m( 'klass -> volume, weight', function( klass ) {
             var weight;
@@ -130,7 +142,7 @@
             case 'D': weight = 50;  break;
             default:  weight = 100; break;
             }
-            return [delay(weight * 0.025, 'volume'), delay(weight, 'weight')];
+            return delay( [weight * 0.025, weight], 'class &rarr; volume, weight' );
           } )
 
       .eq( 'width*height*depth == volume*1000000' )