Q:

Publishing structured, reactive data to the client (outside of database collections)

I am looking for the most performant solution for sending structured data to the client in the Meteor framework on a request.
THE ISSUE:
Sometimes, before you send data from the database to the client, you want to add some server side generated additional information beeing sent to the client (i.e. security credentials for many objects). This data can be time-critical (i.e. due to an expiration timestamp) and therefore should not be stored in the db. Also, this data sometimes cannot be processed on the client side (i.e. due to security reasons). In many cases, this data will be structurally related to actual database data, but also very much related to a single request, since you might want to have it discarded and re-generated on a new request.
YOU CAN (at least by design..):

create a second collection, store and publish your request-related data there, accepting the write-overhead, and then i.e. in the Meteor.myTemplate.destroyed=function(){...} remove the data again accepting another write-overhead.
store each entry in a session variable, but then you also have to take care
of deleting it later on (Meteor.myTemplate.destroyed=function(){...}), this is my favourite right now, but I am running into problems with storing large objects there.
store this data in the dom (i.e. in the attributes or data fields of hidden or visible elements)
generate this data from the dom with Meteor.call('method',arguments,callback(){...}) by storing the appropriate arguments in the dom and injecting them back with i.e. jQuery in the callback(){...}.

YOU CAN'T: (by design!!)

use transformations within Meteor.publish("name",function(){...}) on the server
use a Meteor.call() within a transformation on a Template.variable=function(){return collection.find(...)} (also not if you have a corresponding Meteor.method() on the client for guessing the result!).

Again, what I am looking for is the best performing solution for this. 

A:

Jim Mack created a nice example here that proves, how well it works to store db data as well as additional "transform" properties in a Session variable.
Unfortunately this example lacks reactivity and does not perform the desired "transformations" after Meteor's magic re-render. So I grabbed his cool code and added back the reactivity, it's slim code that works very well, but will be outperformed by Jim Mack's example in terms of efficiency.
lolz.html
<head>
  <title>lolz</title>
</head>

<body>
  {{>myItems}}
</body>

<template name="myItems">
    <h3>Reactive Item List with additional properties</h3>
    <button id="add">add</button>
    <button id="remove">remove</button>
    <dl>
        {{#each items}}
            <dt>data: {{caption}}</dt>
            <dd>added property: {{anotherProp _id}}</dd>
        {{/each}}
    </dl>
</template>

lolz.js
items = new Meteor.Collection('Items');

if (Meteor.isServer) {
    items.allow({
    insert: function (userid, doc) {
        return true;
    },
    remove: function(userid,doc){
        return true;
    }
  });
  while(items.find().count()>0){
    items.remove(items.findOne()._id);
  }
  while (items.find().count() < 3) {
        items.insert({caption: 'LOLCATZ RULZ'});
    }
  Meteor.publish('Items', function () {
      return items.find();
  });
  Meteor.methods({
        'getAdditionalProps': function() {
            additionalProps={};
        items.find().forEach(function(doc){
            additionalProps[doc._id]=reverse(doc.caption);
      });
      return additionalProps;
    }
  });

    function reverse(s){ // server side operation, i.e. for security reasons
    return s.split("").reverse().join("");
    };
}

if (Meteor.isClient){
    Meteor.subscribe('Items');

    Meteor.startup(function(){
        getAdditionalProps();
        itemsHandle=items.find().observe({
            added : function(doc){
                getAdditionalProps();
            },
            removed : function(doc){
                getAdditionalProps();
            },
            changed : function(docA,docB){
                getAdditionalProps();
            }
        });
    });

    Template.myItems.rendered=function(){
        console.log(new Date().getTime());
    };

    Template.myItems.items=function(){
        return items.find();
    }

    Template.myItems.anotherProp=function(id){
        return Session.get('additionalProps')[id];
    }

    Template.myItems.events({
        'click #add':function(e,t){
            items.insert({caption: 'LOLCATZ REACTZ'});
        },
        'click #remove':function(e,t){
            items.remove(items.findOne()._id);
        }
    });
}

function getAdditionalProps(){
    setTimeout(function(){
        Meteor.call('getAdditionalProps',function(error,props){
            Session.set('additionalProps',props);
        });
    },0);
}

