diff --git a/packages/core/examples/box-and-client.ts b/packages/core/examples/box-and-client.ts
index 5ea219b..53e65c5 100755
--- a/packages/core/examples/box-and-client.ts
+++ b/packages/core/examples/box-and-client.ts
@@ -17,7 +17,7 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 //---------------------------------------------------------------------------
 
-import { bootModule, Skeleton, Record, Discard, Capture, Observe, Facet, DataflowObservableObject } from '..';
+import { bootModule, Skeleton, Record, Discard, Capture, Observe, Facet } from '..';
 const __ = Discard._instance;
 const _$ = Capture(__);
 
@@ -28,67 +28,66 @@ const N = 100000;
 
 console.time('box-and-client-' + N.toString());
 
-function boot(thisFacet: Facet) {
-  thisFacet.spawn('box', function (this: DataflowObservableObject & {
-    value: number;
-  }, thisFacet: Facet) {
-    thisFacet.declareField(this, 'value', 0);
-    thisFacet.addEndpoint(() => {
-      // console.log('recomputing published BoxState', this.value);
-      return { assertion: BoxState(this.value), analysis: null };
-    });
-    thisFacet.addDataflow(() => {
-      // console.log('dataflow saw new value', this.value);
-      if (this.value === N) {
-        thisFacet.stop(() => {
-          console.log('terminated box root facet');
+function boot(thisFacet: Facet<{}>) {
+    thisFacet.spawn<{ value: number }>('box', function (thisFacet) {
+        thisFacet.declareField(this, 'value', 0);
+        thisFacet.addEndpoint(function () {
+            // console.log('recomputing published BoxState', this.value);
+            return { assertion: BoxState(this.value), analysis: null };
+        });
+        thisFacet.addDataflow(function () {
+            // console.log('dataflow saw new value', this.value);
+            if (this.value === N) {
+                thisFacet.stop(function () {
+                    console.log('terminated box root facet');
+                });
+            }
+        });
+        thisFacet.addEndpoint(function () {
+            let analysis = Skeleton.analyzeAssertion(SetBox(_$));
+            analysis.callback = thisFacet.wrap(function (thisFacet, evt, [v]) {
+                if (evt === Skeleton.EventType.MESSAGE) {
+                    if (typeof v !== 'number') return;
+                    thisFacet.scheduleScript(function () {
+                        this.value = v;
+                        // console.log('box updated value', v);
+                    });
+                }
+            });
+            return { assertion: Observe(SetBox(_$)), analysis };
         });
-      }
     });
-    thisFacet.addEndpoint(() => {
-      let analysis = Skeleton.analyzeAssertion(SetBox(_$));
-      analysis.callback = thisFacet.wrap((thisFacet, evt, [v]) => {
-        if (evt === Skeleton.EventType.MESSAGE) {
-          if (typeof v !== 'number') return;
-          thisFacet.scheduleScript(() => {
-            this.value = v;
-            // console.log('box updated value', v);
-          });
-        }
-      });
-      return { assertion: Observe(SetBox(_$)), analysis };
-    });
-  });
 
-  thisFacet.spawn('client', function (thisFacet: Facet) {
-    thisFacet.addEndpoint(() => {
-      let analysis = Skeleton.analyzeAssertion(BoxState(_$));
-      analysis.callback = thisFacet.wrap((thisFacet, evt, [v]) => {
-        if (evt === Skeleton.EventType.ADDED) {
-          if (typeof v !== 'number') return;
-          thisFacet.scheduleScript(() => {
-            // console.log('client sending SetBox', v + 1);
-            thisFacet.send(SetBox(v + 1));
-          });
-        }
-      });
-      return { assertion: Observe(BoxState(_$)), analysis };
+    thisFacet.spawn('client', function (thisFacet: Facet<{}>) {
+        thisFacet.addEndpoint(function () {
+            let analysis = Skeleton.analyzeAssertion(BoxState(_$));
+            analysis.callback = thisFacet.wrap(function (thisFacet, evt, [v]) {
+                if (evt === Skeleton.EventType.ADDED) {
+                    if (typeof v !== 'number') return;
+                    thisFacet.scheduleScript(function () {
+                        // console.log('client sending SetBox', v + 1);
+                        thisFacet.send(SetBox(v + 1));
+                    });
+                }
+            });
+            return { assertion: Observe(BoxState(_$)), analysis };
+        });
+        thisFacet.addEndpoint(function () {
+            let analysis = Skeleton.analyzeAssertion(BoxState(__));
+            analysis.callback = thisFacet.wrap(function (thisFacet, evt, _vs) {
+                if (evt === Skeleton.EventType.REMOVED) {
+                    thisFacet.scheduleScript(function () {
+                        console.log('box gone');
+                    });
+                }
+            });
+            return { assertion: Observe(BoxState(__)), analysis };
+        });
     });
-    thisFacet.addEndpoint(() => {
-      let analysis = Skeleton.analyzeAssertion(BoxState(__));
-      analysis.callback = thisFacet.wrap((thisFacet, evt, _vs) => {
-        if (evt === Skeleton.EventType.REMOVED) {
-          thisFacet.scheduleScript(() => {
-            console.log('box gone');
-          });
-        }
-      });
-      return { assertion: Observe(BoxState(__)), analysis };
-    });
-  });
 
-  thisFacet.actor.dataspace.ground().addStopHandler(() =>
-    console.timeEnd('box-and-client-' + N.toString()));
+    thisFacet.actor.dataspace.ground().addStopHandler(function () {
+        console.timeEnd('box-and-client-' + N.toString());
+    });
 }
 
 bootModule(boot);
diff --git a/packages/core/src/runtime/dataspace.ts b/packages/core/src/runtime/dataspace.ts
index c63fa49..1f42ef1 100644
--- a/packages/core/src/runtime/dataspace.ts
+++ b/packages/core/src/runtime/dataspace.ts
@@ -40,17 +40,18 @@ export type FacetId = ActorId;
 export type EndpointId = ActorId;
 
 export type Task<T> = () => T;
-export type Script<T> = (f: Facet) => T;
+export type Script<T, Fields> = (this: Fields & DataflowObservableObject, f: Facet<Fields>) => T;
 
 export type MaybeValue = Value | undefined;
 export type EndpointSpec = { assertion: MaybeValue, analysis: Skeleton.Analysis | null };
 
-export type ObserverCallback = (facet: Facet, bindings: Array<Value>) => void;
+export type ObserverCallback<Fields> =
+    (this: Fields, facet: Facet<Fields>, bindings: Array<Value>) => void;
 
-export type ObserverCallbacks = {
-    add?: ObserverCallback;
-    del?: ObserverCallback;
-    msg?: ObserverCallback;
+export type ObserverCallbacks<Fields> = {
+    add?: ObserverCallback<Fields>;
+    del?: ObserverCallback<Fields>;
+    msg?: ObserverCallback<Fields>;
 }
 
 export const DataflowObservableObjectId = Symbol.for('DataflowObservableObjectId');
@@ -63,12 +64,12 @@ export function _canonicalizeDataflowObservable(i: DataflowObservable): string {
     return i[0][DataflowObservableObjectId]() + ',' + i[1];
 }
 
-export type DataflowDependent = Endpoint;
+export type DataflowDependent = Endpoint<any>;
 export function _canonicalizeDataflowDependent(i: DataflowDependent): string {
     return '' + i.id;
 }
 
-export type ActivationScript = Script<void>;
+export type ActivationScript = Script<void, {}>;
 
 export abstract class Dataspace {
     nextId: ActorId = 0;
@@ -81,7 +82,7 @@ export abstract class Dataspace {
     actors: IdentityMap<number, Actor> = new IdentityMap();
     activations: IdentitySet<ActivationScript> = new IdentitySet();
 
-    constructor(bootProc: Script<void>) {
+    constructor(bootProc: Script<void, {}>) {
         this.pendingTurns = [new Turn(null, [new Spawn(null, bootProc, new Set())])];
     }
 
@@ -129,7 +130,12 @@ export abstract class Dataspace {
         });
     }
 
-    addActor(name: any, bootProc: Script<void>, initialAssertions: Set, parentActor: Actor | null) {
+    addActor<SpawnFields>(
+        name: any,
+        bootProc: Script<void, SpawnFields>,
+        initialAssertions: Set,
+        parentActor: Actor | null)
+    {
         let ac = new Actor(this, name, initialAssertions, parentActor?.id);
         // debug('Spawn', ac && ac.toString());
         this.applyPatch(ac, ac.adhocAssertions);
@@ -181,7 +187,7 @@ export abstract class Dataspace {
         this.index.removeHandler(handler, handler.callback!);
     }
 
-    endpointHook(_facet: Facet, _endpoint: Endpoint) {
+    endpointHook<Fields>(_facet: Facet<Fields>, _endpoint: Endpoint<Fields>) {
         // Subclasses may override
     }
 }
@@ -190,7 +196,7 @@ export class Actor {
     readonly id: ActorId;
     readonly dataspace: Dataspace;
     readonly name: any;
-    rootFacet: Facet | null = null;
+    rootFacet: Facet<any> | null = null;
     isRunnable: boolean = false;
     readonly pendingTasks: Array<Array<Task<void>>>;
     pendingActions: Array<Action>;
@@ -253,11 +259,15 @@ export class Actor {
         this.pendingTasks[priority].push(task);
     }
 
-    addFacet(parentFacet: Facet | null, bootProc: Script<void>, checkInScript: boolean = false) {
+    addFacet<ParentFields, ChildFields extends ParentFields>(
+        parentFacet: Facet<ParentFields> | null,
+        bootProc: Script<void, ChildFields>,
+        checkInScript: boolean = false)
+    {
         if (checkInScript && parentFacet && !parentFacet.inScript) {
             throw new Error("Cannot add facet outside script; are you missing a `react { ... }`?");
         }
-        let f = new Facet(this, parentFacet);
+        let f = new Facet<ChildFields>(this, parentFacet);
         f.invokeScript(f => f.withNonScriptContext(() => bootProc.call(f.fields, f)));
         this.scheduleTask(() => {
             if ((parentFacet && !parentFacet.isLive) || f.isInert()) {
@@ -351,12 +361,12 @@ class Message extends Action {
     }
 }
 
-class Spawn extends Action {
+class Spawn<Fields> extends Action {
     readonly name: any;
-    readonly bootProc: Script<void>;
+    readonly bootProc: Script<void, Fields>;
     readonly initialAssertions: Set;
 
-    constructor(name: any, bootProc: Script<void>, initialAssertions: Set = new Set()) {
+    constructor(name: any, bootProc: Script<void, Fields>, initialAssertions: Set = new Set()) {
         super();
         this.name = name;
         this.bootProc = bootProc;
@@ -406,7 +416,7 @@ class Activation extends Action {
     perform(ds: Dataspace, ac: Actor | null): void {
         if (ds.activations.has(this.script)) return;
         ds.activations.add(this.script);
-        ds.addActor(this.name, rootFacet => rootFacet.addStartScript(this.script), new Set(), ac);
+        ds.addActor<{}>(this.name, rootFacet => rootFacet.addStartScript(this.script), new Set(), ac);
     }
 }
 
@@ -424,18 +434,18 @@ export class Turn {
     }
 }
 
-export class Facet {
+export class Facet<Fields> {
     readonly id: FacetId;
     isLive = true;
     readonly actor: Actor;
-    readonly parent: Facet | null;
-    readonly endpoints = new IdentityMap<EndpointId, Endpoint>();
-    readonly stopScripts: Array<Script<void>> = [];
-    readonly children = new IdentitySet<Facet>();
-    readonly fields: any;
+    readonly parent: Facet<any> | null;
+    readonly endpoints = new IdentityMap<EndpointId, Endpoint<Fields>>();
+    readonly stopScripts: Array<Script<void, Fields>> = [];
+    readonly children = new IdentitySet<Facet<any>>();
+    readonly fields: Fields & DataflowObservableObject;
     inScript = true;
 
-    constructor(actor: Actor, parent: Facet | null) {
+    constructor(actor: Actor, parent: Facet<any> | null) {
         this.id = actor.dataspace.nextId++;
         this.actor = actor;
         this.parent = parent;
@@ -513,11 +523,11 @@ export class Facet {
     }
 
     // This alias exists because of the naive expansion done by the parser.
-    _stop(continuation?: Script<void>) {
+    _stop(continuation?: Script<void, Fields>) {
         this.stop(continuation);
     }
 
-    stop(continuation?: Script<void>) {
+    stop(continuation?: Script<void, Fields>) {
         this.parent!.invokeScript(() => {
             this.actor.scheduleTask(() => {
                 this._terminate();
@@ -529,35 +539,35 @@ export class Facet {
         });
     }
 
-    addStartScript(s: Script<void>) {
+    addStartScript(s: Script<void, Fields>) {
         this.ensureFacetSetup('`on start`');
         this.scheduleScript(s);
     }
 
-    addStopScript(s: Script<void>) {
+    addStopScript(s: Script<void, Fields>) {
         this.ensureFacetSetup('`on stop`');
         this.stopScripts.push(s);
     }
 
-    addEndpoint(updateFun: Script<EndpointSpec>, isDynamic: boolean = true): Endpoint {
+    addEndpoint(updateFun: Script<EndpointSpec, Fields>, isDynamic: boolean = true): Endpoint<Fields> {
         const ep = new Endpoint(this, isDynamic, updateFun);
         this.actor.dataspace.endpointHook(this, ep);
         return ep;
     }
 
-    _addRawObserverEndpoint(specScript: Script<MaybeValue>, callbacks: ObserverCallbacks): Endpoint
+    _addRawObserverEndpoint(specScript: Script<MaybeValue, Fields>, callbacks: ObserverCallbacks<Fields>): Endpoint<Fields>
     {
         return this.addEndpoint(() => {
-            const spec = specScript(this);
+            const spec = specScript.call(this.fields, this);
             if (spec === void 0) {
                 return { assertion: void 0, analysis: null };
             } else {
                 const analysis = Skeleton.analyzeAssertion(spec);
                 analysis.callback = this.wrap((facet, evt, vs) => {
                     switch (evt) {
-                        case Skeleton.EventType.ADDED: callbacks.add?.(facet, vs); break;
-                        case Skeleton.EventType.REMOVED: callbacks.del?.(facet, vs); break;
-                        case Skeleton.EventType.MESSAGE: callbacks.msg?.(facet, vs); break;
+                        case Skeleton.EventType.ADDED: callbacks.add?.call(facet.fields, facet, vs); break;
+                        case Skeleton.EventType.REMOVED: callbacks.del?.call(facet.fields, facet, vs); break;
+                        case Skeleton.EventType.MESSAGE: callbacks.msg?.call(facet.fields, facet, vs); break;
                     }
                 });
                 return { assertion: Observe(spec), analysis };
@@ -565,9 +575,9 @@ export class Facet {
         });
     }
 
-    addObserverEndpoint(specThunk: (facet: Facet) => MaybeValue, callbacks: ObserverCallbacks): Endpoint {
-        const scriptify = (f?: ObserverCallback) =>
-            f && ((facet: Facet, vs: Array<Value>) =>
+    addObserverEndpoint(specThunk: (facet: Facet<Fields>) => MaybeValue, callbacks: ObserverCallbacks<Fields>): Endpoint<Fields> {
+        const scriptify = (f?: ObserverCallback<Fields>) =>
+            f && ((facet: Facet<Fields>, vs: Array<Value>) =>
                 facet.scheduleScript(() => f.call(facet.fields, facet, vs)));
         return this._addRawObserverEndpoint(specThunk, {
             add: scriptify(callbacks.add),
@@ -576,7 +586,7 @@ export class Facet {
         });
     }
 
-    addDataflow(subjectFun: Script<void>, priority?: Priority): Endpoint {
+    addDataflow(subjectFun: Script<void, Fields>, priority?: Priority): Endpoint<Fields> {
         return this.addEndpoint(() => {
             let subjectId = this.actor.dataspace.dataflow.currentSubjectId;
             this.scheduleScript(() => {
@@ -607,7 +617,7 @@ export class Facet {
         return s + ')';
     }
 
-    invokeScript<T>(script: Script<T>, propagateErrors = false): T | undefined {
+    invokeScript<T>(script: Script<T, Fields>, propagateErrors = false): T | undefined {
         try {
             // console.group('Facet', facet && facet.toString());
             return script.call(this.fields, this);
@@ -623,11 +633,18 @@ export class Facet {
         }
     }
 
-    wrap<T extends Array<any>, R>(fn: (f: Facet, ... args: T) => R): (... args: T) => R {
+    wrap<T extends Array<any>, R>(
+        fn: (this: Fields & DataflowObservableObject,
+             f: Facet<Fields>, ... args: T) => R
+    ): (... args: T) => R
+    {
         return (... actuals) => this.invokeScript(f => fn.call(f.fields, f, ... actuals), true)!;
     }
 
-    wrapExternal<T extends Array<any>>(fn: (f: Facet, ... args: T) => void): (... args: T) => void {
+    wrapExternal<T extends Array<any>>(
+        fn: (this: Fields & DataflowObservableObject,
+             f: Facet<Fields>, ... args: T) => void
+    ): (... args: T) => void {
         const ac = this.actor;
         return (... actuals) => {
             if (this.isLive) {
@@ -660,16 +677,16 @@ export class Facet {
     }
 
     // This alias exists because of the naive expansion done by the parser.
-    _spawn(name: any, bootProc: Script<void>, initialAssertions?: Set) {
+    _spawn<SpawnFields>(name: any, bootProc: Script<void, SpawnFields>, initialAssertions?: Set) {
         this.spawn(name, bootProc, initialAssertions);
     }
 
-    spawn(name: any, bootProc: Script<void>, initialAssertions?: Set) {
+    spawn<SpawnFields>(name: any, bootProc: Script<void, SpawnFields>, initialAssertions?: Set) {
         this.ensureNonFacetSetup('`spawn`');
         this.enqueueScriptAction(new Spawn(name, bootProc, initialAssertions));
     }
 
-    deferTurn(continuation: Script<void>) {
+    deferTurn(continuation: Script<void, Fields>) {
         this.ensureNonFacetSetup('`deferTurn`');
         this.enqueueScriptAction(new DeferredTurn(this.wrap(continuation)));
     }
@@ -679,7 +696,7 @@ export class Facet {
         this.enqueueScriptAction(new Activation(script, name ?? null));
     }
 
-    scheduleScript(script: Script<void>, priority?: Priority) {
+    scheduleScript(script: Script<void, Fields>, priority?: Priority) {
         this.actor.scheduleTask(this.wrap(script), priority);
     }
 
@@ -706,22 +723,22 @@ export class Facet {
     //     delete obj[prop];
     // }
 
-    addChildFacet(bootProc: Script<void>) {
+    addChildFacet<ChildFields extends Fields>(bootProc: Script<void, ChildFields>) {
         this.actor.addFacet(this, bootProc, true);
     }
 
-    withSelfDo(t: Script<void>) {
-        t(this);
+    withSelfDo(t: Script<void, Fields>) {
+        t.call(this.fields, this);
     }
 }
 
-export class Endpoint {
+export class Endpoint<Fields> {
     readonly id: EndpointId;
-    readonly facet: Facet;
-    readonly updateFun: Script<EndpointSpec>;
+    readonly facet: Facet<Fields>;
+    readonly updateFun: Script<EndpointSpec, Fields>;
     spec: EndpointSpec;
 
-    constructor(facet: Facet, isDynamic: boolean, updateFun: Script<EndpointSpec>) {
+    constructor(facet: Facet<Fields>, isDynamic: boolean, updateFun: Script<EndpointSpec, Fields>) {
         facet.ensureFacetSetup('add endpoint');
         let ac = facet.actor;
         let ds = ac.dataspace;
diff --git a/packages/core/src/runtime/relay.ts b/packages/core/src/runtime/relay.ts
index 5ce421b..0b70882 100644
--- a/packages/core/src/runtime/relay.ts
+++ b/packages/core/src/runtime/relay.ts
@@ -28,9 +28,9 @@ import { Ground } from './ground.js';
 export const $QuitDataspace = new $Special("quit-dataspace");
 
 export class NestedDataspace extends Dataspace {
-    readonly outerFacet: Facet;
+    readonly outerFacet: Facet<{}>;
 
-    constructor(outerFacet: Facet, bootProc: Script<void>) {
+    constructor(outerFacet: Facet<{}>, bootProc: Script<void, {}>) {
         super(bootProc);
         this.outerFacet = outerFacet;
     }
@@ -42,7 +42,7 @@ export class NestedDataspace extends Dataspace {
         }
     }
 
-    endpointHook(facet: Facet, innerEp: Endpoint) {
+    endpointHook<InnerFields>(facet: Facet<InnerFields>, innerEp: Endpoint<InnerFields>) {
         super.endpointHook(facet, innerEp);
 
         const innerAssertion = innerEp.spec.assertion;
@@ -105,7 +105,7 @@ export class NestedDataspace extends Dataspace {
         return net;
     }
 
-    hookEndpointLifecycle(innerEp: Endpoint, outerEp: Endpoint) {
+    hookEndpointLifecycle<InnerFields>(innerEp: Endpoint<InnerFields>, outerEp: Endpoint<{}>) {
         const _refresh = innerEp.refresh;
         innerEp.refresh = function () {
             _refresh.call(this);
@@ -139,7 +139,7 @@ export class NestedDataspace extends Dataspace {
     }
 }
 
-export function inNestedDataspace(bootProc: Script<void>): Script<void> {
+export function inNestedDataspace(bootProc: Script<void, {}>): Script<void, {}> {
     return outerFacet => {
         outerFacet.addDataflow(function () {});
         // ^ eww! Dummy endpoint to keep the root facet of the relay alive.