@mark1russell7/coeval 0.7.1 → 0.9.0

package/src/formula.ts

@@ -498,19 +498,118 @@ function formulaTypes(profile: FormulaProfile): Readonly<Record<string, TypeRule
  * This function makes the evaluators of the formula kit for one language. Each evaluator compiles its document
  * one time into code. Each evaluator also holds its type rule, for a check of types (TYPE.SYNTH).
  *
+ * Equal profiles give the same evaluator objects (COMPOSE.UNIFY, D46). Thus two machines of one profile merge without
+ * a conflict. Each call gives a new record. Each evaluator object is frozen, because many machines can share it.
+ *
  * @param profile - The operations and the rules of the language.
  * @returns The evaluators, by their name.
  */
 export function formulaEvaluators(profile: FormulaProfile = {}): Readonly<Record<string, Evaluator>> {
+  return { ...kitOf(profile).evaluators };
+}
+
+/** This function makes new evaluators of the formula kit for the fields of one profile. */
+function makeEvaluators(profile: FormulaProfile): Readonly<Record<string, Evaluator>> {
   const evaluators = formulaCode(profile);
   const types = formulaTypes(profile);
   const out: Record<string, Evaluator> = {};
   for (const name of Object.keys(evaluators)) {
     const evaluator = evaluators[name] as CompiledEvaluator;
     const type = Object.hasOwn(types, name) ? types[name] : undefined;
-    out[name] = type === undefined ? evaluator : { compile: evaluator.compile, type };
+    out[name] = Object.freeze(type === undefined ? evaluator : { compile: evaluator.compile, type });
+  }
+  return Object.freeze(out);
+}
+
+/** The keys of a profile that the kit reads. The kit ignores each other key. */
+const PROFILE_KEYS = /* @__PURE__ */ Object.freeze([
+  "ops",
+  "lazy",
+  "ext",
+  "truthy",
+  "otherwise",
+  "logic",
+  "omit",
+  "missing",
+  "check",
+  "combine",
+  "pure",
+  "volatile",
+  "sigs",
+] as const satisfies readonly (keyof FormulaProfile)[]);
+
+/** The evaluators and the hooks of the formula kit for one profile, with the fields that made them. */
+interface Kit {
+  readonly fields: FormulaProfile;
+  readonly evaluators: Readonly<Record<string, Evaluator>>;
+  readonly known: (path: readonly Key[], evaluator: string) => true | string;
+  readonly facts: (path: readonly Key[], code: string) => KindFacts | undefined;
+}
+
+/** The number of recent kits that a profile in a new object can find by its fields. */
+const RECENT_KITS = 16;
+
+/** The kit of each profile object. A kit goes when its profile object goes. */
+const kitsByProfile = /* @__PURE__ */ new WeakMap<object, Kit>();
+
+/** The recent kits, the most recent first. The list holds `RECENT_KITS` kits or fewer. */
+const recentKits: Kit[] = [];
+
+/**
+ * This function gives the canonical form of a profile: a frozen record of the fields that the kit reads. A field
+ * with the value `undefined` is absent, but `otherwise` is present when the profile has it as an own key. A list
+ * is a frozen copy. Each other value stays the same object.
+ */
+function fieldsOf(profile: FormulaProfile): FormulaProfile {
+  const out: Record<string, unknown> = {};
+  for (const key of PROFILE_KEYS) {
+    if (key === "otherwise" ? !Object.hasOwn(profile, key) : profile[key] === undefined) continue;
+    const value: unknown = profile[key];
+    out[key] = Array.isArray(value) ? Object.freeze([...(value as unknown[])]) : value;
   }
-  return out;
+  return Object.freeze(out);
+}
+
+/**
+ * This function tells if two canonical forms are equal. They must have the same keys. A function, a record and a host
+ * value are equal only to themselves. Two lists are equal when their items are the same, in order.
+ */
+function sameFields(a: FormulaProfile, b: FormulaProfile): boolean {
+  const left = a as Readonly<Record<string, unknown>>;
+  const right = b as Readonly<Record<string, unknown>>;
+  const keys = Object.keys(left);
+  if (keys.length !== Object.keys(right).length) return false;
+  return keys.every((key) => {
+    if (!Object.hasOwn(right, key)) return false;
+    const x = left[key];
+    const y = right[key];
+    if (Object.is(x, y)) return true;
+    return Array.isArray(x) && Array.isArray(y) && x.length === y.length && x.every((item, index) => Object.is(item, y[index]));
+  });
+}
+
+/**
+ * This function gives the kit of a profile (D46). A profile object that the kit knows, with the same fields, gives its
+ * kit. Then a recent kit with equal fields serves a new profile object. Else the function makes a new kit from the
+ * canonical form. Thus a later change of a field of the profile object gives a new kit, and an old kit does not change.
+ */
+function kitOf(profile: FormulaProfile): Kit {
+  const fields = fieldsOf(profile);
+  const known = kitsByProfile.get(profile);
+  if (known !== undefined && sameFields(known.fields, fields)) return known;
+  const index = recentKits.findIndex((kit) => sameFields(kit.fields, fields));
+  let kit: Kit;
+  if (index >= 0) {
+    kit = recentKits[index] as Kit;
+    recentKits.splice(index, 1);
+  } else {
+    const hook = makeKnown(fields);
+    kit = { fields, evaluators: makeEvaluators(fields), known: hook, facts: makeFacts(fields, hook) };
+  }
+  recentKits.unshift(kit);
+  if (recentKits.length > RECENT_KITS) recentKits.length = RECENT_KITS;
+  kitsByProfile.set(profile, kit);
+  return kit;
 }
 
 /** This function makes the code of the evaluators of the formula kit, without their type rules. */
@@ -848,10 +947,17 @@ function formulaCode(profile: FormulaProfile): Readonly<Record<string, CompiledE
  * `formula.ext` knows an extension of `ext` and each standard extension. The hook knows each name of the other
  * evaluators.
  *
+ * Equal profiles give the same hook (D46).
+ *
  * @param profile - The operations and the extensions of the language.
  * @returns The hook: `true`, or the reason of the `#NAME?` that the evaluator gives in a run.
  */
 export function formulaKnown(profile: FormulaProfile = {}): (path: readonly Key[], evaluator: string) => true | string {
+  return kitOf(profile).known;
+}
+
+/** This function makes a new hook `known` for the fields of one profile. */
+function makeKnown(profile: FormulaProfile): (path: readonly Key[], evaluator: string) => true | string {
   const hasOp = (name: string): boolean => {
     if (profile.lazy !== undefined && Object.hasOwn(profile.lazy, name)) return true;
     const ops = profile.ops;
@@ -890,13 +996,19 @@ const EACH_PART: readonly LazyRule[] = /* @__PURE__ */ Object.freeze([/* @__PURE
  * - An operation is pure when the profile names it in `pure`, or when `pure` is `true`. A volatile operation is not pure.
  * - A standard extension is pure. An extension of the profile gets the context, thus it is not pure.
  *
+ * Equal profiles give the same hook (D46).
+ *
  * @param profile - The operations, the extensions and their facts.
  * @returns The hook: the facts of a name, or `undefined` for the facts of the contract.
  */
 export function formulaFacts(profile: FormulaProfile = {}): (path: readonly Key[], code: string) => KindFacts | undefined {
+  return kitOf(profile).facts;
+}
+
+/** This function makes a new hook `facts` for the fields of one profile, with the hook `known` of the same fields. */
+function makeFacts(profile: FormulaProfile, known: (path: readonly Key[], evaluator: string) => true | string): (path: readonly Key[], code: string) => KindFacts | undefined {
   const volatile = new Set(profile.volatile ?? []);
   const pure = profile.pure === true ? undefined : new Set(profile.pure ?? []);
-  const known = formulaKnown(profile);
   return (path, code) => {
     if (code !== "formula.op" && code !== "formula.ext") return undefined;
     const name = path.slice(1).join(".");
@@ -922,14 +1034,16 @@ export function formulaFacts(profile: FormulaProfile = {}): (path: readonly Key[
  * The kit gives the domains of the kernel (`STD_DOMAINS`). Thus a domain of the language with the name `number` is a
  * conflict. The language names `["domains", "number"]` in `replaces` to replace it.
  *
+ * Equal profiles give the same evaluators and the same hooks (COMPOSE.UNIFY, D46). Thus two machines of one profile
+ * merge, also when each adds its own language. Two profiles with different fields give different evaluators, and
+ * their machines conflict at each evaluator name of the kit.
+ *
  * @param profile - The operations and the rules of the language.
  * @param more - The parts of a machine that the language adds, with the paths of the entries that it replaces.
  * @returns The machine.
  * @throws {MergeError} The language and the kit have a conflict.
  */
 export function formulaMachine(profile: FormulaProfile = {}, more: MachinePart = {}): Machine {
-  return mergeMachines(
-    { world: { kinds: formulaKinds() }, evaluators: formulaEvaluators(profile), domains: STD_DOMAINS, known: formulaKnown(profile), facts: formulaFacts(profile) },
-    more,
-  );
+  const kit = kitOf(profile);
+  return mergeMachines({ world: { kinds: formulaKinds() }, evaluators: { ...kit.evaluators }, domains: STD_DOMAINS, known: kit.known, facts: kit.facts }, more);
 }

package/src/index.ts

@@ -36,6 +36,7 @@ export {
 } from "./errors.ts";
 export {
   type Alias,
+  type AttributeDeclaration,
   type CapsRule,
   type Kind,
   type KindFacts,
@@ -47,9 +48,11 @@ export {
   type ScopeRule,
   type Shape as PartShape,
   type Side,
+  type TreeContract,
   type World,
   type WorldEntry,
   entriesAsJson,
+  equationType,
   isAlias,
   isKind,
   isNamespace,
@@ -157,7 +160,20 @@ export {
   prepare,
   run,
 } from "./evaluate.ts";
-export { type NearestOptions, STD_CAPS, STD_EVALUATORS, STD_MACHINE, STD_RUNNERS, STD_WALKERS, STD_WORLD, nearestWalker } from "./stdlib.ts";
+export {
+  type AttributeRung,
+  type AttributeTrace,
+  type NearestOptions,
+  ATTRIBUTE_RUNGS,
+  STD_CAPS,
+  STD_EVALUATORS,
+  STD_MACHINE,
+  STD_RUNNERS,
+  STD_WALKERS,
+  STD_WORLD,
+  attributeTrace,
+  nearestWalker,
+} from "./stdlib.ts";
 export {
   type Edge,
   type OrderProblem,
@@ -186,7 +202,9 @@ export {
   type Typing,
   type WalkOptions,
   type WalkProblem,
+  type WorldIssue,
   check,
+  checkWorld,
   mapRefs,
   refsOf,
   typeCheck,

package/src/parts.ts

@@ -1,5 +1,5 @@
 import { type Envelope, type Json, type Key, docEquals, isEnvelope, isRecord, typeName, typePath } from "./doc.ts";
-import { type Kind, type Shape, type World, lookupKind } from "./world.ts";
+import { type Kind, type NamesSource, type ScopeRule, type Shape, type World, lookupKind } from "./world.ts";
 import type { ValueType } from "./types.ts";
 
 /** One part of a value: its place in the value, the JSON of the part, and the type that its position declares. */
@@ -268,3 +268,72 @@ export function pathMatches(path: readonly Key[], pattern: readonly Key[]): bool
   }
   return true;
 }
+
+function valueAt(value: unknown, path: readonly Key[]): unknown {
+  let here: unknown = value;
+  for (const key of path) {
+    if (Array.isArray(here)) here = here[Number(key)];
+    else if (isRecord(here) && Object.hasOwn(here, String(key))) here = here[String(key)];
+    else return undefined;
+  }
+  return here;
+}
+
+function headerName(item: Json): string | undefined {
+  return isEnvelope(item) && typeof (item as { readonly name?: unknown }).name === "string" ? (item as { readonly name: string }).name : undefined;
+}
+
+function namesOf(source: NamesSource, value: unknown, covered: readonly PartSlot[]): readonly string[] {
+  if ("fixed" in source) return source.fixed;
+  if ("keysAt" in source) {
+    const at = valueAt(value, source.keysAt);
+    return isRecord(at) ? Object.keys(at) : [];
+  }
+  if ("listAt" in source) {
+    const at = valueAt(value, source.listAt);
+    return Array.isArray(at) ? (at as readonly unknown[]).filter((item): item is string => typeof item === "string") : [];
+  }
+  if ("textAt" in source) {
+    const at = valueAt(value, source.textAt);
+    if (typeof at === "string") return [at];
+    return source.otherwise === undefined ? [] : [source.otherwise];
+  }
+  return covered.map((slot) => headerName(slot.item)).filter((name): name is string => name !== undefined);
+}
+
+/**
+ * This function gives the names that the scope rules of a kind give each part, and the names that only later parts
+ * see. `check`, `conforms` and the plan read the scope rules with it.
+ *
+ * @param rules - The scope rules of the kind.
+ * @param value - The value of the document.
+ * @param slots - The parts of the value, in order.
+ * @returns The names that each part sees, and the names that only the later parts see, by the index of the part.
+ */
+export function scopesOf(rules: readonly ScopeRule[] | undefined, value: unknown, slots: readonly PartSlot[]): { readonly sees: readonly (readonly string[])[]; readonly later: readonly (readonly string[])[] } {
+  const sees: string[][] = slots.map(() => []);
+  const later: string[][] = slots.map(() => []);
+  for (const rule of rules ?? []) {
+    const covered = slots.map((slot, index) => ({ slot, index })).filter(({ slot }) => rule.in.some((pattern) => pathMatches(slot.path, pattern)));
+    if (rule.sequential !== true) {
+      const names = namesOf(rule.names, value, covered.map(({ slot }) => slot));
+      for (const { index } of covered) sees[index]?.push(...names);
+      continue;
+    }
+    if ("headers" in rule.names) {
+      covered.forEach(({ index }, position) => {
+        const before = covered.slice(0, position).map(({ slot }) => headerName(slot.item)).filter((name): name is string => name !== undefined);
+        const after = covered.slice(position).map(({ slot }) => headerName(slot.item)).filter((name): name is string => name !== undefined);
+        sees[index]?.push(...before);
+        later[index]?.push(...after);
+      });
+      continue;
+    }
+    const names = namesOf(rule.names, value, covered.map(({ slot }) => slot));
+    covered.forEach(({ index }, position) => {
+      if (position > 0) sees[index]?.push(...names);
+      else later[index]?.push(...names);
+    });
+  }
+  return { sees, later };
+}

package/src/reference.ts

@@ -1,9 +1,9 @@
 import { type Envelope, type Json, type Key, isEnvelope, isRecord, typeName } from "./doc.ts";
 import { ask } from "./ladder.ts";
-import type { CapsRule, Kind } from "./world.ts";
+import { type AttributeDeclaration, type CapsRule, type Kind, type TreeContract, equationType, lookupKind } from "./world.ts";
 import { type PartSlot, type Split, partsOf, pathMatches } from "./parts.ts";
 import { type Cap, type Context, type HostThing, type Resolution, type ResolveOptions, type Thing, THING, isHostThing, resolve, valueOfThing, worldThing } from "./deref.ts";
-import { STD_EVALUATORS } from "./stdlib.ts";
+import { type AttributeRung, STD_EVALUATORS } from "./stdlib.ts";
 import { type EvalError, type Failed, type Result, Failure, describe, fail, ok, placed, thrown } from "./errors.ts";
 import {
   type AllOptions,
@@ -17,7 +17,6 @@ import {
   type RunInput,
   type RunPart,
   type Steps,
-  intersectCaps,
   makeContext,
   permits,
   placeText,
@@ -150,13 +149,23 @@ function examine(env: Env, at: At): Seen | Failed {
   return { doc, kindText, typePath: read.typePath ?? [], kind, name, chosen, split };
 }
 
+/**
+ * This function gives the effects that two lists of capabilities both permit (CAP.ONLY). The reference reads the rule
+ * from SPEC directly, and not from the intersection of the plan. Thus `agree` finds a bug in either one (D15).
+ */
+function bothPermit(a: readonly Cap[], b: readonly Cap[]): readonly Cap[] {
+  const out: Cap[] = [];
+  for (const cap of [...a, ...b]) if (permits(a, cap) && permits(b, cap) && !permits(out, cap)) out.push(cap);
+  return out;
+}
+
 /** This function gives the capabilities that the rules of a kind give one part (D14, CAP.CONTRACT, CAP.ONLY). */
 function capsOfPart(rules: readonly CapsRule[] | undefined, path: readonly Key[], caps: readonly Cap[]): readonly Cap[] {
   let out = caps;
   for (const rule of rules ?? []) {
     if (rule.in !== undefined && !rule.in.some((pattern) => pathMatches(path, pattern))) continue;
     if (rule.rule === "mask") return [];
-    if (rule.rule === "only") out = intersectCaps(out, rule.caps);
+    if (rule.rule === "only") out = bothPermit(out, rule.caps);
   }
   return out;
 }
@@ -420,13 +429,20 @@ export function reference(machine: Machine, doc: unknown, context: Context = mak
     scope: { prefix: "", counts: new Map(), alls: 0 },
   };
   const ctx = context.world === null ? { ...context, world: worldThing(machine.world) } : context;
+  // A node of a tree reads the definitions of this evaluation for its equations (TREE.LADDER).
+  activeEnvs.push(env);
   try {
     return evaluateAt(env, { value: doc, place: [], declared: options.declaredType, depth: 0, address: false, ctx });
   } catch (error) {
     return placed(thrown(error, "the reference"), []);
+  } finally {
+    activeEnvs.pop();
   }
 }
 
+/** The evaluations of the reference that run at this time, the innermost last. */
+const activeEnvs: Env[] = [];
+
 /*
  * The definition of the decorated tree (TREE.*), written from docs/SPEC.md. It shares no code with `tree.node` of
  * stdlib.ts: its nodes, its memo, its marks for attributes in evaluation and its JSON are its own.
@@ -444,6 +460,16 @@ interface RefNode {
   readonly place: readonly Key[];
   readonly parts: readonly Part[];
   readonly ctx: Context;
+  /** The tree contract of the kind of the node (D42). */
+  readonly contract: TreeContract | undefined;
+  /** The type of a bare equation: the type `of` of the parts of the kind. */
+  readonly of: string | undefined;
+  /** The parent node in the same tree, for the rungs `parent` and `copy`. */
+  readonly up: RefNode | undefined;
+  /** The evaluation of the reference that made the node. Its equations evaluate with its definitions. */
+  readonly env: Env | undefined;
+  /** The host thing of the node. */
+  thing: HostThing;
   /** The results of the attributes that ended. */
   readonly values: Map<string, Result>;
   /** The attributes in evaluation. */
@@ -463,8 +489,86 @@ function refNodeOf(thing: unknown): RefNode | undefined {
   return typeof thing === "object" && thing !== null ? refNodes.get(thing) : undefined;
 }
 
-/** TREE.ONCE, TREE.MEMO and TREE.CYCLE: the result of one attribute, or `undefined` when the node has no such part. */
-function attributeOf(node: RefNode, self: HostThing, name: string): Result | undefined {
+/**
+ * TREE.LADDER: an equation of the kind of a node evaluates in the reference. It gets the node as `self`, the names of
+ * its rung and no capabilities. A bare equation gets the type `of` of the parts of the kind.
+ */
+function equationOf(node: RefNode, term: Json, names: Readonly<Record<string, unknown>>): Result {
+  const env = node.env;
+  if (env === undefined) return fail("#NOEVAL", "The evaluation of an equation needs the machine.");
+  const ctx: Context = { ...node.ctx, names, caps: [], self: node.thing };
+  return reference(env.machine, term, ctx, { definitions: env.definitions, ...(node.of === undefined ? {} : { declaredType: node.of }) });
+}
+
+function termIn<T>(table: Readonly<Record<string, T>> | undefined, name: string): T | undefined {
+  return table === undefined || !Object.hasOwn(table, name) ? undefined : table[name];
+}
+
+/** TREE.DOWN: the names of a child for an equation of `down` of its parent: `child`, `index` and `prev`. */
+function namesOfChild(up: RefNode, child: RefNode): Result {
+  const children = attributeOf(up, "children");
+  if (children !== undefined && !children.ok) return children;
+  const list: readonly unknown[] = children !== undefined && Array.isArray(children.value) ? children.value : [];
+  const index = list.indexOf(child.thing);
+  return ok({ child: child.thing, index: index < 0 ? null : index, prev: index > 0 ? list[index - 1] : null });
+}
+
+/** TREE.FOLD: the unit, then `combine` with the attribute of each node of this tree in the list `children`. */
+function foldOf(node: RefNode, name: string, fold: NonNullable<AttributeDeclaration["fold"]>): Result {
+  let acc = equationOf(node, fold.unit, {});
+  if (!acc.ok) return acc;
+  const children = attributeOf(node, "children");
+  if (children === undefined) return acc;
+  if (!children.ok) return children;
+  if (!Array.isArray(children.value)) return fail("#VALUE!", `The fold of ${name} needs a list in children.`);
+  for (const item of children.value) {
+    const child = refNodeOf(item);
+    if (child === undefined || child.tree !== node.tree) continue;
+    const value = attributeOf(child, name);
+    if (value === undefined) return fail("#N/A", `No rung gives ${nameOfAttribute(child, name)}.`);
+    if (!value.ok) return value;
+    acc = equationOf(node, fold.combine, { acc: acc.value, item: value.value });
+    if (!acc.ok) return acc;
+  }
+  return acc;
+}
+
+/**
+ * TREE.LADDER: the rungs of the ladder of an attribute, in their order. A rung gives `undefined` when it does not
+ * answer, and the next rung then tries.
+ */
+const REF_RUNGS: readonly (readonly [AttributeRung, (node: RefNode, name: string) => Result | undefined])[] = [
+  ["own", (node, name) => node.parts.find((item) => item.key === name)?.evaluate({ ...node.ctx, self: node.thing })],
+  [
+    "kind",
+    (node, name) => {
+      const term = termIn(node.contract?.equations, name);
+      return term === undefined ? undefined : equationOf(node, term, {});
+    },
+  ],
+  [
+    "parent",
+    (node, name) => {
+      const up = node.up;
+      const term = up === undefined ? undefined : termIn(up.contract?.down, name);
+      if (up === undefined || term === undefined) return undefined;
+      const names = namesOfChild(up, node);
+      return names.ok ? equationOf(up, term, names.value as Readonly<Record<string, unknown>>) : names;
+    },
+  ],
+  ["copy", (node, name) => (node.up !== undefined && termIn(node.contract?.attributes, name)?.copy === true ? attributeOf(node.up, name) : undefined)],
+  [
+    "default",
+    (node, name) => {
+      const declared = termIn(node.contract?.attributes, name);
+      if (declared?.fold !== undefined) return foldOf(node, name, declared.fold);
+      return declared?.default === undefined ? undefined : equationOf(node, declared.default, {});
+    },
+  ],
+];
+
+/** TREE.ONCE, TREE.MEMO and TREE.CYCLE: the result of one attribute, or `undefined` when no rung of its ladder answers. */
+function attributeOf(node: RefNode, name: string): Result | undefined {
   const done = node.values.get(name);
   if (done !== undefined) return done;
   if (node.pending.has(name)) {
@@ -472,14 +576,16 @@ function attributeOf(node: RefNode, self: HostThing, name: string): Result | und
     const steps = from < 0 ? [nameOfAttribute(node, name)] : inEvaluation.slice(from).map((entry) => nameOfAttribute(entry.node, entry.name));
     return fail("#CYCLE!", `The attributes form a cycle: ${[...steps, nameOfAttribute(node, name)].join(" -> ")}.`);
   }
-  const part = node.parts.find((item) => item.key === name);
-  if (part === undefined) return undefined;
   node.pending.add(name);
   inEvaluation.push({ node, name });
   try {
-    const result = part.evaluate({ ...node.ctx, self });
-    node.values.set(name, result);
-    return result;
+    for (const [, rung] of REF_RUNGS) {
+      const result = rung(node, name);
+      if (result === undefined) continue;
+      node.values.set(name, result);
+      return result;
+    }
+    return undefined;
   } finally {
     node.pending.delete(name);
     inEvaluation.pop();
@@ -490,7 +596,7 @@ function attributeOf(node: RefNode, self: HostThing, name: string): Result | und
 function jsonOfNode(node: RefNode, self: HostThing, open: readonly object[]): Result {
   const record: Record<string, unknown> = {};
   for (const part of node.parts) {
-    const result = attributeOf(node, self, part.key) as Result;
+    const result = attributeOf(node, part.key) as Result;
     if (!result.ok) return result;
     const value = plainValue(result.value, [...open, self]);
     if (!value.ok) return value;
@@ -528,30 +634,50 @@ function plainValue(value: unknown, open: readonly object[]): Result {
 
 /**
  * TREE.LAZY, TREE.PARENT, TREE.SIBLING and TREE.ERROR: a node of an open tree gives its thing, and the root of a new
- * tree gives its JSON. A step on the thing reads an attribute, and a failed attribute throws its own error.
+ * tree gives its JSON. A step on the thing reads an attribute, and a failed attribute throws its own error. The node
+ * reads `self` only through `resolve` (C4, TREE.SELF).
  */
-const treeDefinition: EvalFn = ({ parts, context, kind, place }) => {
-  const outer = refNodeOf(context.self);
+const treeDefinition: EvalFn = ({ parts, context, kind, place, machine, typePath, resolve: walk }) => {
+  const reached = walk(["self"]);
+  const parent: Thing | undefined = reached.ok ? reached.thing : undefined;
+  const outer = refNodeOf(parent);
   const nested = outer !== undefined && outer.tree.open;
-  const node: RefNode = { tree: nested ? outer.tree : { open: true }, kind, place, parts, ctx: context, values: new Map(), pending: new Set() };
+  const found = machine === undefined || typePath.length === 0 ? undefined : lookupKind(machine.world, typePath);
+  const contract = found?.ok === true ? found.kind.tree : undefined;
+  const of = contract === undefined || found?.ok !== true ? undefined : equationType(found.kind);
+  const node: RefNode = {
+    tree: nested ? outer.tree : { open: true },
+    kind,
+    place,
+    parts,
+    ctx: context,
+    contract,
+    of,
+    up: nested ? outer : undefined,
+    env: activeEnvs[activeEnvs.length - 1],
+    thing: null as unknown as HostThing,
+    values: new Map(),
+    pending: new Set(),
+  };
   const self: HostThing & { readonly type: string } = {
     [THING]: true,
     type: kind,
     label: `node ${kind}`,
     deref: (key): Thing | undefined => {
-      if (key === "parent") return context.self;
+      if (key === "parent") return parent;
       if (key === "type") return kind;
-      const result = attributeOf(node, self, String(key));
+      const result = attributeOf(node, String(key));
       if (result === undefined || result.ok) return result?.ok === true ? result.value : undefined;
       throw new Failure(result.error);
     },
-    has: (key) => key === "parent" || key === "type" || parts.some((part) => part.key === String(key)),
+    has: (key) => key === "parent" || key === "type" || parts.some((part) => part.key === String(key)) || node.values.has(String(key)),
     toJson: () => {
       const result = jsonOfNode(node, self, []);
       if (result.ok) return result.value;
       throw new Failure(result.error);
     },
   };
+  node.thing = self;
   refNodes.set(self, node);
   if (nested) return ok(self);
   try {