renderHelper = function renderHelper(
    vm: VM,
    args: Arguments
  ): VersionedPathReference<CurriedComponentDefinition | null> {
    let env = vm.env as Environment;
    let nameRef = args.positional.at(0);

    assert(
      `The first argument of {{render}} must be quoted, e.g. {{render "sidebar"}}.`,
      isConst(nameRef)
    );
    // tslint:disable-next-line:max-line-length
    assert(
      `The second argument of {{render}} must be a path, e.g. {{render "post" post}}.`,
      args.positional.length === 1 || !isConst(args.positional.at(1))
    );

    let templateName = nameRef.value() as string;

    // tslint:disable-next-line:max-line-length
    assert(
      `You used \`{{render '${templateName}'}}\`, but '${templateName}' can not be found as a template.`,
      env.owner.hasRegistration(`template:${templateName}`)
    );

    let template = env.owner.lookup<OwnedTemplate>(`template:${templateName}`);

    let controllerName: string;

    if (args.named.has('controller')) {
      let controllerNameRef = args.named.get('controller');

      // tslint:disable-next-line:max-line-length
      assert(
        `The controller argument for {{render}} must be quoted, e.g. {{render "sidebar" controller="foo"}}.`,
        isConst(controllerNameRef)
      );

      // TODO should be ensuring this to string here
      controllerName = controllerNameRef.value() as string;

      // tslint:disable-next-line:max-line-length
      assert(
        `The controller name you supplied '${controllerName}' did not resolve to a controller.`,
        env.owner.hasRegistration(`controller:${controllerName}`)
      );
    } else {
      controllerName = templateName;
    }

    if (args.positional.length === 1) {
      let def = new RenderDefinition(controllerName, template, SINGLETON_RENDER_MANAGER);
      return UnboundReference.create(curry(def));
    } else {
      let def = new RenderDefinition(controllerName, template, NON_SINGLETON_RENDER_MANAGER);
      let captured = args.capture();
      return UnboundReference.create(curry(def, captured));
    }
  };

  value() {
    let { env, nameRef, modelRef } = this;
    let name = nameRef.value();

    if (typeof name === 'string') {
      if (this._lastName === name) {
        return this._lastDef;
      }

      assert(
        `You used \`{{mount '${name}'}}\`, but the engine '${name}' can not be found.`,
        env.owner.hasRegistration(`engine:${name}`)
      );

      if (!env.owner.hasRegistration(`engine:${name}`)) {
        return null;
      }

      this._lastName = name;
      this._lastDef = curry(new MountDefinition(name, modelRef));

      return this._lastDef;
    } else {
      assert(
        `Invalid engine name '${name}' specified, engine name must be either a string, null or undefined.`,
        name === null || name === undefined
      );
      this._lastDef = null;
      this._lastName = null;
      return null;
    }
  }

 value(): CurriedComponentDefinition | null {
   let state = stateFor(this.outletRef);
   if (validate(state, this.lastState)) {
     return this.definition;
   }
   this.lastState = state;
   let definition = null;
   if (state !== null) {
     definition = curry(new OutletComponentDefinition(state));
   }
   return (this.definition = definition);
 }

 appendTo(view: Component, target: Simple.Element) {
   let definition = new RootComponentDefinition(view);
   this._appendDefinition(view, curry(definition), target);
 }

 appendOutletView(view: OutletView, target: Simple.Element) {
   let definition = createRootOutlet(view);
   this._appendDefinition(view, curry(definition), target);
 }