@mark1russell7/coeval 0.24.0 → 0.24.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/coeval",
-  "version": "0.24.0",
+  "version": "0.24.1",
   "description": "coeval: the kernel of declarative languages. Documents in envelopes, a ladder that finds the evaluator, kind contracts, compiled plans, a static kit, a formula kit and a run side with capabilities.",
   "type": "module",
   "main": "./build/index.js",
@@ -36,8 +36,8 @@
   ],
   "devDependencies": {
     "@mark1russell7/cue": "^2.1.1",
-    "@mark1russell7/rigor-bench": "^0.2.15",
-    "@mark1russell7/rigor-statistics": "^0.1.12",
+    "@mark1russell7/rigor-bench": "^0.2.29",
+    "@mark1russell7/rigor-statistics": "^0.1.16",
     "@types/node": "^26.6.4",
     "esbuild": "^0.28.2",
     "typescript": "^7.0.2",

package/src/agree.ts

@@ -1,7 +1,10 @@
 import { type Key, docEquals, equalWith } from "./doc.ts";
 import { type Context, isHostThing } from "./deref.ts";
-import { type EvalError, type Result, isStackOverflow, thrown } from "./errors.ts";
-import { type Effect, type Machine, type Perform, type Read, JOURNAL, evaluate, makeContext, prepare, run, sharedCopy } from "./evaluate.ts";
+import { type EvalError, type Result, describe, isStackOverflow, thrown } from "./errors.ts";
+import { type CheckOptions, typeCheck } from "./static.ts";
+import { isPrecise, member, typeText } from "./types.ts";
+import { boundariesOf } from "./typing.ts";
+import { type Effect, type Machine, type Perform, type Read, type TraceNode, JOURNAL, evaluate, makeContext, prepare, run, sharedCopy } from "./evaluate.ts";
 import { Held, isClosure } from "./formula.ts";
 import { type Definitions, reference, referenceRun } from "./reference.ts";
 import { type ReplaySettle, recorder, relay, replayer } from "./replay.ts";
@@ -392,6 +395,15 @@ function resolutions(reads: readonly Read[]): readonly Read[] {
   return reads.filter((read) => read.free && read.kept !== true);
 }
 
+/** This function gives the text of a value of a trace. It does not throw for a bigint or a record with a cycle. */
+function valueText(value: unknown): string {
+  try {
+    return JSON.stringify(value) ?? describe(value);
+  } catch {
+    return describe(value);
+  }
+}
+
 function pathText(path: readonly unknown[] | undefined): string {
   if (path === undefined) return "no read";
   try {
@@ -537,3 +549,94 @@ export async function agreeRun(machine: Machine, doc: unknown, context: Context
   }
   return compared === undefined ? { ok: true, result, effects: first.effects } : { ok: true, result, effects: first.effects, reads: compared };
 }
+
+/** The result of `agreeTypes`: the agreement of a check of types and a traced evaluation (STATIC.TYPES-AGREE). */
+export type TypeAgreement =
+  | {
+      readonly ok: true;
+      /** `false` when the document has an issue, or a value breaks a position of an imprecise type. The rule then tells nothing. */
+      readonly checked: boolean;
+      /** The number of the values of the trace that the rule examined. */
+      readonly values: number;
+    }
+  | {
+      readonly ok: false;
+      /** `value`: a value is not in the type of its place. `argument`: it is not in the type that its position needs. `error`: a type error of the kernel. */
+      readonly clause: "value" | "argument" | "error";
+      /** The keys of the place, as texts. */
+      readonly place: readonly string[];
+      readonly reason: string;
+    };
+
+/** The options of `agreeTypes`: the options of `check`, and `guards`. */
+export interface AgreeTypesOptions extends CheckOptions {
+  /** `true`: the evaluation tests each boundary (PLAN.GUARD). The rule then holds for each context. The default is `false`. */
+  readonly guards?: boolean;
+}
+
+/** The type errors of the kernel, by the evaluator that gives them (STATIC.TYPES-AGREE). */
+const TYPE_ERRORS: Readonly<Record<string, string>> = {
+  "formula.op": "#NAME?",
+  "formula.if": "#VALUE!",
+  "formula.and": "#VALUE!",
+  "formula.or": "#VALUE!",
+};
+
+/**
+ * This function examines the agreement rule for types (STATIC.TYPES-AGREE, D148). A document with no issue evaluates
+ * with a trace. Each value of the trace is a member of the type of its place. A value of a precise type is also a member
+ * of the type that its position needs. No document with precise parts gives a type error of the kernel.
+ *
+ * A language imports this function for its own property tests, with `agree`. A failure tells that a signature, a type
+ * rule, a cover or a root type does not hold. A value that breaks a position of an imprecise type ends the promise, and
+ * the result then has `checked: false` (TYPE.GRADUAL).
+ *
+ * @param machine - The world and the code of the evaluators, with their type rules.
+ * @param doc - The document.
+ * @param context - The context. Its roots are members of the root types.
+ * @param options - The options of `check`, with the root types, and `guards`.
+ * @returns The agreement, or the first place that breaks it.
+ */
+export function agreeTypes(machine: Machine, doc: unknown, context: Context = makeContext(), options: AgreeTypesOptions = {}): TypeAgreement {
+  const typing = typeCheck(machine, doc, options);
+  if (typing.issues.length > 0) return { ok: true, checked: false, values: 0 };
+  const keyOf = (path: readonly unknown[]): string => JSON.stringify(path.map(String));
+  const places = new Map(typing.places.map((item) => [keyOf(item.place), item]));
+  const domains = machine.domains;
+  const guards = options.guards === true ? boundariesOf(typing, domains) : undefined;
+  const given = { ...(options.declaredType === undefined ? {} : { declaredType: options.declaredType }), ...(guards === undefined ? {} : { guards }) };
+  const stack: TraceNode[] = [evaluate(machine, doc, context, given).trace];
+  const nodes: TraceNode[] = [];
+  while (stack.length > 0) {
+    const node = stack.pop() as TraceNode;
+    nodes.push(node);
+    stack.push(...node.children);
+  }
+  // A value that breaks a position of an imprecise type leaves the promise of each later type (K28).
+  for (const node of nodes) {
+    const place = places.get(keyOf(node.path));
+    if (place?.expected === undefined || !node.result.ok || isPrecise(place.type, domains)) continue;
+    if (!member(node.result.value, place.expected, domains)) return { ok: true, checked: false, values: 0 };
+  }
+  // The walk goes from the end, thus a part comes before the kind that reads it, and a finding names the origin.
+  let values = 0;
+  for (const node of nodes.reverse()) {
+    const place = places.get(keyOf(node.path));
+    if (place === undefined) continue;
+    const at = node.path.map(String);
+    if (!node.result.ok) {
+      const parts = node.children.map((child) => places.get(keyOf(child.path)));
+      const decided = node.children.every((child) => child.result.ok) && parts.every((part) => part?.expected !== undefined && isPrecise(part.type, domains));
+      const code = TYPE_ERRORS[node.answer.evaluator ?? ""];
+      if (decided && node.result.error.code === code) return { ok: false, clause: "error", place: at, reason: `The document gives ${code}, but it checks with no issue.` };
+      continue;
+    }
+    const value = node.result.value;
+    values += 1;
+    if (!member(value, place.type, domains)) return { ok: false, clause: "value", place: at, reason: `The value ${valueText(value)} is not a member of ${typeText(place.type)}.` };
+    if (place.expected !== undefined && !member(value, place.expected, domains)) {
+      return { ok: false, clause: "argument", place: at, reason: `The value ${valueText(value)} is not a member of the needed type ${typeText(place.expected)}.` };
+    }
+  }
+  return { ok: true, checked: true, values };
+}

package/src/evaluate.ts

@@ -2,8 +2,8 @@ import { type Envelope, type Json, type Key, type TypeRef, isEnvelope, isKey, ty
 import { type PartSlot, type Split, partsOf, pathMatches, scopesOf } from "./parts.ts";
 import { answerOf, ask, type Answer } from "./ladder.ts";
 import type { CapsRule, Kind, KindFacts, Side } from "./world.ts";
-import type { Domain } from "./types.ts";
-import type { TypeRule } from "./typing.ts";
+import { type Domain, type ValueType, member, typeText } from "./types.ts";
+import type { Boundary, TypeRule } from "./typing.ts";
 import type { StaticRead } from "./facts.ts";
 import { type ErrorCode, type EvalError, type Result, Failure, fail, ok, placed, thrown, describe } from "./errors.ts";
 import {
@@ -993,6 +993,8 @@ export interface PlanRunOptions {
 export interface RunOptions extends PlanRunOptions {
   /** The type of a bare root value. */
   readonly declaredType?: string;
+  /** The boundaries that test their values (PLAN.GUARD). The default is none. */
+  readonly guards?: readonly Boundary[];
   /** The verb of `run`, for example `format`. The default is `eval` (VERB.PREPARE). */
   readonly verb?: string;
 }
@@ -1023,6 +1025,8 @@ export interface EvaluateOptions {
   readonly perform?: Perform;
   /** A list that gets each read, in the order of the resolutions (READS.RECORD). */
   readonly reads?: Read[];
+  /** The boundaries that test their values (PLAN.GUARD). The default is none. */
+  readonly guards?: readonly Boundary[];
 }
 
 /** The options of a resolution without a record of hops, and with one. One object of each serves each call. */
@@ -1700,6 +1704,11 @@ export interface PrepareOptions {
    * the code without the fold. A plan without folds ignores this option.
    */
   readonly fixed?: { readonly names?: Readonly<Record<string, unknown>> };
+  /**
+   * The boundaries of the document, from `boundariesOf` (PLAN.GUARD, D149). A value that is not a member of the type of
+   * its boundary gives `#VALUE!` at that place. The default is none, and a plan then has no test.
+   */
+  readonly guards?: readonly Boundary[];
 }
 
 /** A compiled document. It evaluates many times, and it does the work of the ladder one time. */
@@ -1740,6 +1749,8 @@ interface Compiler {
   readonly fold: boolean;
   /** The fixed names and their values, or `undefined` when the plan has none (PLAN.FIXED). */
   readonly fixed: Readonly<Record<string, unknown>> | undefined;
+  /** The types of the boundaries by their place, or `undefined` when the plan has no guard (PLAN.GUARD). */
+  readonly guards: ReadonlyMap<string, ValueType> | undefined;
   /** The runtime of the folds of this compilation. The first fold makes it. */
   probe?: Probe;
 }
@@ -1885,7 +1896,8 @@ function compileNode(c: Compiler, value: unknown, place: readonly Key[], declare
     } catch (error) {
       return failingWith(c, meta, placed(thrown(error, `the runner ${name}`), place));
     }
-    const run = placedRun(inner, place, name);
+    const guard = guardOf(c, place);
+    const run = placedRun(guard === undefined ? inner : guardRun(inner, guard, c.machine.domains), place, name);
     return finish(c, meta, runnerCode(run, place, kindText), run);
   }
 
@@ -1895,8 +1907,9 @@ function compileNode(c: Compiler, value: unknown, place: readonly Key[], declare
   } catch (error) {
     return failingWith(c, meta, placed(thrown(error, `the evaluator ${name}`), place));
   }
+  const guard = guardOf(c, place);
   // Code that cannot fail needs no place and no catch, and it does not read the context of its grant (PLAN.TOTAL).
-  const done = finish(c, meta, TOTAL.has(inner) ? inner : placedCode(inner, place, name), undefined);
+  const done = finish(c, meta, guard !== undefined ? placedCode(guardCode(inner, guard, c.machine.domains), place, name) : TOTAL.has(inner) ? inner : placedCode(inner, place, name), undefined);
   if (frees === undefined || kind === undefined || !pureCode(c, envelope, kind, typePath, name, quick)) return done;
   const free = freeOf(doc, kind, split.parts, frees);
   if (free === undefined) return done;
@@ -2308,6 +2321,34 @@ function gated(rules: readonly CapsRule[], part: Compiled): Compiled {
  * This function gives the steps of a runner, with the place of each error and of each exception. The steps get the
  * context that its grant permits (CAP.NARROW-CODE).
  */
+/** This function gives the key of a place in the guards of a plan. */
+function guardKey(place: readonly Key[]): string {
+  return JSON.stringify(place.map(String));
+}
+
+/** This function gives the type of the boundary at a place, when the plan has one (PLAN.GUARD). */
+function guardOf(c: Compiler, place: readonly Key[]): ValueType | undefined {
+  return c.guards?.get(guardKey(place));
+}
+
+/** This function gives the result of a part of a boundary: a value that is not a member gives `#VALUE!` (PLAN.GUARD). */
+function guarded(result: Result, type: ValueType, domains: Readonly<Record<string, Domain>> | undefined): Result {
+  if (!result.ok || member(result.value, type, domains)) return result;
+  return fail("#VALUE!", `The value is not a member of ${typeText(type)}, the type of its boundary.`);
+}
+
+/** This function adds the test of a boundary to the code of a part. */
+function guardCode(inner: Code, type: ValueType, domains: Readonly<Record<string, Domain>> | undefined): Code {
+  return (ctx, rt) => guarded(inner(ctx, rt), type, domains);
+}
+
+/** This function adds the test of a boundary to the steps of a part. */
+function guardRun(inner: RunCode, type: ValueType, domains: Readonly<Record<string, Domain>> | undefined): RunCode {
+  return function* (ctx, rt) {
+    return guarded(yield* inner(ctx, rt), type, domains);
+  };
+}
+
 function placedRun(inner: RunCode, place: readonly Key[], name: string): RunCode {
   return function* (ctx, rt) {
     try {
@@ -2520,7 +2561,8 @@ export function prepare(machine: Machine, doc: unknown, options: PrepareOptions
   const traced = options.trace === true;
   const fold = !traced && options.fold !== false;
   const fixed = fold ? fixedNamesOf(options.fixed?.names) : undefined;
-  const c: Compiler = { machine, traced, maxDepth: machine.maxDepth ?? 1000, verb, noAnswer, fold, fixed };
+  const guards = options.guards === undefined || options.guards.length === 0 ? undefined : new Map(options.guards.map((each) => [guardKey(each.place), each.type]));
+  const c: Compiler = { machine, traced, maxDepth: machine.maxDepth ?? 1000, verb, noAnswer, fold, fixed, guards };
   let root: Compiled;
   try {
     root = compileNode(c, doc, [], options.declaredType, 0);
@@ -2643,6 +2685,7 @@ export function evaluate(machine: Machine, doc: unknown, context: Context = make
     trace: true,
     ...(declaredType === undefined ? {} : { declaredType }),
     ...(given.verb === undefined ? {} : { verb: given.verb }),
+    ...(given.guards === undefined ? {} : { guards: given.guards }),
   });
   const ctx = rootContext(machine, context);
   const s = new Session(machine, ctx.caps, false, true, given.perform, undefined, undefined, readingOf(given.reads, ctx));
@@ -2665,6 +2708,7 @@ export async function run(machine: Machine, doc: unknown, context: Context = mak
   const plan = prepare(machine, doc, {
     trace: true,
     ...(options.declaredType === undefined ? {} : { declaredType: options.declaredType }),
+    ...(options.guards === undefined ? {} : { guards: options.guards }),
     ...(options.verb === undefined ? {} : { verb: options.verb }),
   });
   const ctx = rootContext(machine, context);

package/src/formula.ts

@@ -420,6 +420,7 @@ function formulaTypes(profile: FormulaProfile): Readonly<Record<string, TypeRule
     "formula.lit": { synth: (input) => valueType(input.doc.value) },
 
     "formula.ref": {
+      read: true,
       synth: (input, report) => {
         const path = input.doc.value;
         // An address gives a thing, not a value. The check gives #VALUE! for a path that is not a list.

package/src/index.ts

@@ -197,6 +197,7 @@ export {
   STD_EVALUATORS,
   STD_MACHINE,
   STD_RUNNERS,
+  ifRunner,
   STD_WALKERS,
   STD_WORLD,
   WORLD_SYNTAX,
@@ -227,6 +228,7 @@ export {
 } from "./context.ts";
 export {
   type CheckOptions,
+  type DocChange,
   type DocVisit,
   type Issue,
   type RefUse,
@@ -237,6 +239,7 @@ export {
   type WorldOptions,
   check,
   checkWorld,
+  mapDocs,
   mapRefs,
   refsOf,
   typeCheck,
@@ -289,7 +292,7 @@ export {
   syntaxFormat,
 } from "./syntax.ts";
 export { type Definitions, type ReferenceOptions, type ReferenceRunOptions, STD_DEFINITIONS, formulaDefinitions, reference, referenceRun } from "./reference.ts";
-export { type AgreeOptions, type AgreeRunOptions, type Agreement, type Tier, type TierInput, type TierResult, agree, agreeRun, sameValue } from "./agree.ts";
+export { type AgreeOptions, type AgreeRunOptions, type Agreement, type AgreeTypesOptions, type TypeAgreement, agreeTypes, type Tier, type TierInput, type TierResult, agree, agreeRun, sameValue } from "./agree.ts";
 export { type ConformOptions, type ConformProbe, type Finding, type Obligation, conforms } from "./conform.ts";
 export { sameResult } from "./same.ts";
 export { type PrintOptions, type ReadPrints, type ReadsCheck, type VerifyOptions, printReads, verifyReads } from "./reads.ts";
@@ -346,5 +349,5 @@ export {
 } from "./replay.ts";
 export { type GenerateOptions, type Random, generate, random, typesOf } from "./generate.ts";
 export { type Domain, type DomainCodec, type TypeIssue, type ValueType, STD_DOMAINS, fits, join, member, typeIssues, typeText } from "./types.ts";
-export { type Declared, type PartType, type RootTypes, type TypeInput, type TypeProblem, type TypeRule, type Typed, CAPS_TYPE } from "./typing.ts";
+export { type Boundary, type Declared, type PartType, type RootTypes, type TypeInput, type TypeProblem, type TypeRule, type Typed, CAPS_TYPE, boundariesOf } from "./typing.ts";
 export { type SampleOptions, type TypeReading, typeFromSamples, typeFromSchema } from "./providers.ts";

package/src/schedule.ts

@@ -294,6 +294,8 @@ export function schedule(machine: Machine, options: ScheduleOptions = {}): Sched
   // The nodes that finished in a kept read, and if that read met a node in evaluation below it (D143).
   const keptNodes: string[] = [];
   let keptMet = false;
+  // The count of the visits at the start of the kept read. A node with a lower number started below the read.
+  let keptFrom = 0;
   let count = 0;
   let ahead = 0;
   // The node that stopped the evaluation of a walk, because the walk has no result for it.
@@ -370,8 +372,12 @@ export function schedule(machine: Machine, options: ScheduleOptions = {}): Sched
     const reader = stack[stack.length - 1];
     const known = epoch.values.get(id);
     if (known !== undefined) {
-      // A finished node of an open component is on a cycle with its reader too.
-      if (reader !== undefined && onOpen.has(id)) lower(reader, order.get(id) as number);
+      if (reader !== undefined && onOpen.has(id)) {
+        // The path from that component to a kept read has a read that no evaluation asked for (SCHED.KEPT-OPEN).
+        if (keptAt >= 0 && (order.get(id) as number) < keptFrom) keptMet = true;
+        // A finished node of an open component is on a cycle with its reader too.
+        else lower(reader, order.get(id) as number);
+      }
       return known;
     }
     if (busy.has(id)) {
@@ -592,9 +598,11 @@ export function schedule(machine: Machine, options: ScheduleOptions = {}): Sched
     keeping(read) {
       const outer = keptAt;
       const outerMet = keptMet;
+      const outerFrom = keptFrom;
       const from = keptNodes.length;
       keptAt = stack.length;
       keptMet = false;
+      keptFrom = count;
       try {
         return read();
       } finally {
@@ -609,6 +617,7 @@ export function schedule(machine: Machine, options: ScheduleOptions = {}): Sched
         }
         keptAt = outer;
         keptMet = outerMet;
+        keptFrom = outerFrom;
       }
     },
   });

package/src/static.ts

@@ -258,11 +258,14 @@ export function walk(world: World, doc: unknown, visit: (visit: DocVisit) => voi
       continue;
     }
     const { sees, later } = scopesOf(kind.scope, doc.value, split.parts);
+    // The rules of a grant are read one time for each kind, not for each part. A kind without such a rule gives no list (K238).
+    const grantRules = kind.caps !== undefined && kind.caps.some((rule) => rule.rule === "grant") ? kind.caps : undefined;
     for (let index = split.parts.length - 1; index >= 0; index -= 1) {
       const slot = split.parts[index] as PartSlot;
       const extra = sees[index] ?? [];
       const hidden = later[index] ?? [];
-      const grants = partGrants(kind.caps, slot.path, doc.value);
+      const grants = grantRules === undefined ? undefined : partGrants(grantRules, slot.path, doc.value);
+      const granted = grants !== undefined && grants.length > 0 ? grants : undefined;
       stack.push({
         value: slot.item,
         place: slot.path.length === 0 ? item.place : { up: item.place, keys: slot.path },
@@ -274,8 +277,14 @@ export function walk(world: World, doc: unknown, visit: (visit: DocVisit) => voi
         address: slot.address === true,
         slot: slot.path,
         parent: here,
-        caps: item.caps === undefined || kind.caps === undefined ? item.caps : [...partCaps(kind.caps, slot.path, item.caps), ...grants],
-        handled: grants.length === 0 ? item.handled : [...(item.handled ?? []), ...grants],
+        // A part with no grant keeps the list of partCaps, with no copy (K238).
+        caps:
+          item.caps === undefined || kind.caps === undefined
+            ? item.caps
+            : granted === undefined
+              ? partCaps(kind.caps, slot.path, item.caps)
+              : [...partCaps(kind.caps, slot.path, item.caps), ...granted],
+        handled: granted === undefined ? item.handled : [...(item.handled ?? []), ...granted],
         bound: extra,
         expect: slot.expect,
       });
@@ -371,6 +380,45 @@ export function mapRefs(world: World, doc: unknown, change: (use: RefUse) => unk
   return out;
 }
 
+/**
+ * The answer of the function of `mapDocs` for one document.
+ *
+ * - `undefined`: keep the document and go into its parts.
+ * - `"skip"`: keep the document and stop there.
+ * - `{ to }`: put `to` in the place of the document and stop there.
+ * - `{ to, into: true }`: put `to` in the place of the document, then go into the parts of the old document. Thus
+ *   `to` must keep the path of each such part.
+ */
+export type DocChange = undefined | "skip" | { readonly to: unknown; readonly into?: boolean };
+
+/**
+ * This function changes the documents of a document, from the root to the parts (STATIC.MAPDOCS). The function
+ * `change` reads only the original documents. It decides at each node, and it can stop at a node. The kinds of a
+ * position come from the world, thus this function names no kind. The document is not changed: the function gives a
+ * new document that shares each part without a change.
+ *
+ * @param world - The world of the kinds.
+ * @param doc - The document, as JSON.
+ * @param change - The function that gives the answer for each visit. See `DocChange`.
+ * @param options - The type of a bare root value, and the names that the host binds at the root.
+ * @returns The new document, or `doc` itself when no document changes.
+ */
+export function mapDocs(world: World, doc: unknown, change: (visit: DocVisit) => DocChange, options: WalkOptions = {}): unknown {
+  let out = doc;
+  walk(
+    world,
+    doc,
+    (visit) => {
+      const next = change(visit);
+      if (next === undefined || next === "skip") return next;
+      out = setAt(out, visit.at, next.to);
+      return next.into === true ? undefined : "skip";
+    },
+    options,
+  );
+  return out;
+}
+
 /** A problem that a check finds before a document runs. */
 export interface Issue {
   readonly code: ErrorCode;

package/src/stdlib.ts

@@ -192,7 +192,8 @@ export const STD_WORLD: World = {
  * A literal in a place that takes a document gets its data envelope (K159, D65). Such a place is a part of `if`,
  * `list`, `seq` or `pure`, the value of `write`, or the whole text. The document after a header name is such a place
  * too. Thus `list(1, "a")` evaluates to `[1, "a"]`. The forms `add`, `multiply` and `greater` write an operator document that its operator
- * does not write, for example `add(5)` (K163).
+ * does not write, for example `add(5)` (K163). The field `with` of `handle` is a field of data, thus each clause is a
+ * record between braces in a list between brackets (D177).
  *
  * A host with more kinds spreads this profile and adds its forms to `calls.forms`. `STD_SYNTAX` stays the profile of
  * the formula kit.
@@ -223,6 +224,8 @@ export const WORLD_SYNTAX: SyntaxProfile = /* @__PURE__ */ Object.freeze({
       { name: "tree.named", kind: "tree.named", args: "named", fields: ["name", "in"] },
       { name: "tree.at", kind: "tree.at", args: "named", fields: ["attr", "args"] },
       { name: "tree.quote", kind: "tree.quote", args: "literal" },
+      // The clauses are data with documents in it, for example handle(with: [{op: "log", do: payload + 1}], body: log(2)) (D177).
+      { name: "handle", kind: "handle", args: "named", fields: ["with", "return", "body"], data: ["with"], wrap: ["return", "body"] },
       // An operator document with fewer terms than its operator takes, for example add(5) (K163, D65).
       { name: "add", kind: "add" },
       { name: "multiply", kind: "multiply" },
@@ -835,6 +838,7 @@ function leaderOnHost(n: LoopNode, key: string, rule: CircularRule & { readonly
 /**
  * This function gives an attribute of a node with circular attributes, or an attribute in an open fixed point (D113).
  * The memo and the marks of the node do not hold the attribute. An open fixed point does not use the cells of the host.
+ * With the cells of a host, only a circular attribute comes here outside a fixed point. A plain attribute takes its cell.
  */
 function circularRead(n: LoopNode, key: string): Result | undefined {
   const rule = circularRule(n.tree, key);
@@ -1221,7 +1225,8 @@ function treeThing(input: EvalInput, place: readonly Key[], build: TreeBuild, ou
           const text = attributeText(key, type, place);
           if (marks.has(key)) return busyAt(state, key);
           if (tree === undefined && up?.tree === undefined && !parts.some((item) => item.key === key)) return undefined;
-          if (circular || openPoint !== undefined) return circularRead(state, key);
+          // Outside a fixed point, a plain attribute of a node with a circular attribute also takes the cell of the host.
+          if (openPoint !== undefined || (circular && circularRule(tree, key) !== undefined)) return circularRead(state, key);
           marks.set(key, BUSY);
           demands.push({ cells: marks, key, text });
           let thrown: unknown = NOT_THROWN;
@@ -1527,6 +1532,27 @@ function isOp(value: unknown): value is Cap {
   return typeof value === "string" || (Array.isArray(value) && value.every(isKey));
 }
 
+/**
+ * This function gives the runner of an `if` with its own truth (RUN.IF-TRUTH). A branch can wait for the host, thus a
+ * language with the function `truthy` of a profile does not need a copy of `if`. A missing test and a test without a
+ * truth give `#VALUE!`, a failed test gives its failure, and a missing branch gives `null`.
+ *
+ * @param truth - The function that gives the truth of a value, or `undefined` for a value without a truth.
+ * @returns The runner.
+ */
+export function ifRunner(truth: (value: unknown) => boolean | undefined): Runner {
+  return function* ({ parts }) {
+    const test = parts.find((part) => part.key === "test");
+    if (test === undefined) return fail("#VALUE!", "if needs a test.");
+    const chosen = yield* test.evaluate();
+    if (!chosen.ok) return chosen;
+    const held = truth(chosen.value);
+    if (held === undefined) return fail("#VALUE!", "The test of if must give a truth value.");
+    const branch = parts.find((part) => part.key === (held ? "then" : "else"));
+    return branch === undefined ? ok(null) : yield* branch.evaluate();
+  };
+}
+
 /**
  * The runners of the standard world, by name: the kinds that can hold effects. Each one evaluates its parts in
  * order. In a run, an effect ends before the next step starts.
@@ -1576,15 +1602,7 @@ export const STD_RUNNERS: Readonly<Record<string, Runner>> = {
     if (!result.ok || after === undefined) return result;
     return yield* after.evaluate({ ...context, names: { ...context.names, result: result.value } });
   },
-  "control.if": function* ({ parts }) {
-    const test = parts.find((part) => part.key === "test");
-    if (test === undefined) return fail("#VALUE!", "if needs a test.");
-    const chosen = yield* test.evaluate();
-    if (!chosen.ok) return chosen;
-    if (typeof chosen.value !== "boolean") return fail("#VALUE!", "The test of if must give a truth value.");
-    const branch = parts.find((part) => part.key === (chosen.value === true ? "then" : "else"));
-    return branch === undefined ? ok(null) : yield* branch.evaluate();
-  },
+  "control.if": /* @__PURE__ */ ifRunner((value) => (typeof value === "boolean" ? value : undefined)),
   "list.all": function* ({ parts }) {
     const all = yield* inOrder(parts);
     return "error" in all ? all.error : ok(all.values);