@mark1russell7/coeval 0.9.0 → 0.11.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/coeval",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "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",

package/src/conform.ts

@@ -32,7 +32,7 @@ import { type Definitions, STD_DEFINITIONS } from "./reference.ts";
 import { STD_EVALUATORS } from "./stdlib.ts";
 import { sameValue } from "./agree.ts";
 import { type Random, random } from "./generate.ts";
-import { type Kind, type LazyRule, type Shape, type World, type WorldEntry, isKind, isNamespace, lookupKind } from "./world.ts";
+import { type Kind, type LazyRule, type Shape, type World, type WorldEntry, effectsOfVerb, isKind, isNamespace, lookupKind } from "./world.ts";
 
 /*
  * The conformance tests of one evaluator (K92, R7 P3, D36). `conforms` calls the code of one evaluator or runner
@@ -85,8 +85,9 @@ export interface Finding {
 /** The options of `conforms`. */
 export interface ConformOptions {
   /**
-   * The verb that the evaluator serves. The default is `eval`. The facts of a contract (`effects`, `pure` and `lazy`)
-   * describe only `eval`, thus `conforms` checks C2, C3 and C4 only for `eval` (D23).
+   * The verb that the evaluator serves. The default is `eval`. The facts `pure` and `lazy` of a contract describe only
+   * `eval`, thus `conforms` checks C3 and C4 only for `eval` (D23). `conforms` checks C2 for each verb that the
+   * contract declares effects for: `eval`, and each verb with an entry in `verbEffects` (D49).
    */
   readonly verb?: string;
   /**
@@ -276,6 +277,8 @@ interface Contract {
   readonly lazy: readonly LazyRule[] | undefined;
   /** `true` when the facts describe the verb: they describe only `eval`. */
   readonly describes: boolean;
+  /** `true` when the contract declares the effects of the verb: for `eval`, and for a verb in `verbEffects`. */
+  readonly declares: boolean;
   readonly caps: readonly Cap[];
 }
 
@@ -487,13 +490,16 @@ function typesNaming(world: World, name: string, verb: string): readonly TypeRef
 /** This function gives the facts of the kind of a type. The hook `facts` of the machine wins over the contract. */
 function contractOf(env: Env, kind: Kind, typePath: readonly Key[], caps: readonly Cap[] | undefined): Contract {
   const facts = env.machine.facts?.(typePath, env.name);
-  const effects = kind.effects;
+  // A verb without a declaration keeps the effects of eval for the capabilities of the probes, as before D49.
+  const own = effectsOfVerb(kind, env.verb);
+  const effects = own ?? kind.effects;
   const declared: readonly Cap[] = effects === undefined ? [] : effects === "type" ? [typePath] : effects;
   return {
     declared,
     pure: (facts?.pure ?? kind.pure) === true,
     lazy: facts?.lazy ?? kind.lazy,
     describes: env.verb === "eval",
+    declares: own !== undefined,
     caps: caps ?? [...declared, "probe"],
   };
 }
@@ -872,13 +878,15 @@ function checkShot(env: Env, sample: Sample, contract: Contract, scenario: Scena
       report(env, "C1", `The code gives its effect ${effect.kind} ${capsText(effect.context.caps)}, and its document has ${capsText(docCaps)}.`, probe);
     }
   }
-  if (contract.describes) {
-    // C2: only the declared effects.
+  if (contract.declares) {
+    // C2: only the declared effects of the verb (VERB.EFFECTS).
     for (const effect of shot.caused) {
       if (!permits(contract.declared, effect.kind)) {
-        report(env, "C2", `The code causes the effect ${effect.kind}, and the contract of ${sample.type} declares ${contract.declared.length === 0 ? "no effects" : capsText(contract.declared)}.`, probe);
+        report(env, "C2", `The code causes the effect ${effect.kind}, and the contract of ${sample.type} declares ${contract.declared.length === 0 ? "no effects" : capsText(contract.declared)}${env.verb === "eval" ? "" : ` for the verb ${env.verb}`}.`, probe);
       }
     }
+  }
+  if (contract.describes) {
     // C4: a pure kind causes no effect.
     const first = shot.caused[0];
     if (contract.pure && first !== undefined) report(env, "C4", `The kind ${sample.type} is pure, and the code causes the effect ${first.kind}.`, probe);

package/src/evaluate.ts

@@ -785,17 +785,13 @@ export interface StopSignal {
   addEventListener(type: "abort", listener: () => void, options?: { readonly once?: boolean }): void;
 }
 
-/** The options of a run. */
-export interface RunOptions {
+/**
+ * The options of `plan.run`. A plan keeps the verb and the declared type of its `prepare`, thus these options do not
+ * have them (PLAN.RUN-OPTIONS).
+ */
+export interface PlanRunOptions {
   /** The host code that does each effect. Without it, an effect gives its payload, as in an evaluation. */
   readonly perform?: Perform;
-  /** The type of a bare root value. */
-  readonly declaredType?: string;
-  /**
-   * The verb of `run`, for example `format`. The default is `eval` (VERB.PREPARE). A plan keeps the verb of its
-   * `prepare`, thus `plan.run` does not read this option.
-   */
-  readonly verb?: string;
   /** A signal of the host. When it aborts, the run stops with `#ABORT`. */
   readonly signal?: StopSignal;
   /**
@@ -805,6 +801,14 @@ export interface RunOptions {
   readonly reads?: Read[];
 }
 
+/** The options of `run`: the options of `plan.run`, and the type of a bare root value and the verb for `prepare`. */
+export interface RunOptions extends PlanRunOptions {
+  /** The type of a bare root value. */
+  readonly declaredType?: string;
+  /** The verb of `run`, for example `format`. The default is `eval` (VERB.PREPARE). */
+  readonly verb?: string;
+}
+
 /** The options of an evaluation of a plan. */
 export interface EvalOptions {
   /** A list that gets each effect, in its order. */
@@ -1303,7 +1307,7 @@ export interface Plan {
    * @param options - The host code that does the effects, a signal to stop the run and a list that gets the reads.
    * @returns The result, when the run ends.
    */
-  run(context?: Context, options?: RunOptions): Promise<Result>;
+  run(context?: Context, options?: PlanRunOptions): Promise<Result>;
 }
 
 interface Compiler {
@@ -1471,7 +1475,8 @@ function compileNode(c: Compiler, value: unknown, place: readonly Key[], declare
   } catch (error) {
     return failingWith(c, meta, placed(thrown(error, `the evaluator ${name}`), place));
   }
-  const done = finish(c, meta, placedCode(inner, place, name), undefined);
+  // 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);
   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;
@@ -1721,6 +1726,24 @@ function copyPlain(value: unknown, memo: Map<object, unknown>): unknown {
  * the split of the value. Thus a plan with these helpers keeps only its code.
  */
 
+/**
+ * The compiled code that cannot fail (PLAN.TOTAL). Such code gives a value and throws nothing. It does not read its
+ * context or its runtime. Only the kits of the kernel mark code, thus the code of a host always gets its grant.
+ */
+const TOTAL: WeakSet<Code> = /* @__PURE__ */ new WeakSet();
+
+/**
+ * This function marks compiled code that cannot fail (PLAN.TOTAL). Then `compileNode` does not wrap the code in
+ * `placedCode`, thus a literal costs one call. The kits of the kernel use it. The package does not export it.
+ *
+ * @param code - The code. It gives a value and throws nothing. It does not read its context or its runtime.
+ * @returns The same code.
+ */
+export function totalCode(code: Code): Code {
+  TOTAL.add(code);
+  return code;
+}
+
 /**
  * This function gives the code of a document: the code of its evaluator, with the place of each error and of each
  * exception. The code gets the context that its grant permits, thus a compiled parent cannot widen it (CAP.NARROW-CODE).
@@ -1952,7 +1975,7 @@ class CompiledPlan implements Plan {
     return this.code(ctx, s);
   }
 
-  run(context: Context = makeContext(), runOptions: RunOptions = {}): Promise<Result> {
+  run(context: Context = makeContext(), runOptions: PlanRunOptions = {}): Promise<Result> {
     const machine = this.machine;
     const ctx = rootContext(machine, context);
     const s = new Session(machine, true, this.traced, runOptions.perform, runOptions.signal, undefined, readingOf(runOptions.reads, ctx));

package/src/formula.ts

@@ -2,9 +2,9 @@ import { type Json, type Key, docEquals, isKey, isRecord } from "./doc.ts";
 import type { Kind, KindFacts, LazyRule, WorldEntry } from "./world.ts";
 import { type CompiledPath, type Context, type Resolution, compilePath, valueOfThing } from "./deref.ts";
 import { type EvalError, type Failed, type Result, Failure, fail, ok, thrown } from "./errors.ts";
-import { type Code, type CompileInput, type CompiledEvaluator, type CompiledPart, type Evaluator, type Machine, type Runtime, resolveCompiled } from "./evaluate.ts";
+import { type Code, type CompileInput, type CompiledEvaluator, type CompiledPart, type Evaluator, type Machine, type Runtime, resolveCompiled, totalCode } from "./evaluate.ts";
 import { type MachinePart, mergeMachines } from "./merge.ts";
-import { type Domain, type ValueType, HEADER_KEYS, STD_DOMAINS, callable, fieldOf, fits, fnOf, holdsEnvelope, isPrecise, isUnknown, itemOf, join, stepType, typeText } from "./types.ts";
+import { type Domain, type ValueType, HEADER_KEYS, STD_DOMAINS, callable, fieldOf, fits, fnOf, holdsEnvelope, isPrecise, isUnknown, itemOf, join, member, stepType, typeText } from "./types.ts";
 import type { TypeInput, TypeRule } from "./typing.ts";
 import { decodeDomain, domainTypeOf } from "./codec.ts";
 
@@ -42,6 +42,8 @@ export type ExtFn = (data: Json, context: Context, domains?: Readonly<Record<str
  *   evaluates, and one failed part gives its own error. Without it, the first error stops the evaluation.
  * - `pure`: the pure operations, for `factsOf` (D24). `true` names each operation that is not volatile. The default
  *   names no operation.
+ * - `pureExt`: the pure extensions of `ext`, by their name, for `factsOf` and the folds of a plan (PLAN.FOLD, D47).
+ *   The default names no extension. A standard extension is pure without a name here.
  * - `volatile`: the operations whose results can change while their arguments stay the same, for example a clock.
  * - `sigs`: the signatures of the operations, by their name, for a check of types (TYPE.SIGNATURE). A list gives
  *   overloads. An operation without a signature takes and gives `unknown` (TYPE.GRADUAL).
@@ -61,13 +63,14 @@ export interface FormulaProfile {
   readonly check?: (value: unknown, op: string) => Result | undefined;
   readonly combine?: (errors: readonly EvalError[]) => EvalError;
   readonly pure?: true | readonly string[];
+  readonly pureExt?: readonly string[];
   readonly volatile?: readonly string[];
   readonly sigs?: Readonly<Record<string, Signature | readonly Signature[]>> | ((name: string) => Signature | readonly Signature[] | undefined);
 }
 
 /**
- * The signature of an operation: the value types of its parameters and of its result (TYPE.SIGNATURE). A parameter of
- * the type `unknown` at the end of `params` is optional. A later version can add a key, for example the type that a
+ * The signature of an operation: the value types of its parameters and of its result (TYPE.SIGNATURE). A parameter at
+ * the end of `params` is optional when `undefined` is a member of its type, for example `unknown`. A later version can add a key, for example the type that a
  * true result proves.
  */
 export interface Signature {
@@ -209,9 +212,13 @@ export function formulaKinds(): Readonly<Record<string, WorldEntry>> {
   return kinds as Readonly<Record<string, WorldEntry>>;
 }
 
-/** This function gives the type of a value of a profile: the value itself as `one`. `undefined` and a function give `unknown`. */
+/**
+ * This function gives the type of a value of a profile: the value itself as `one`. `undefined` gives the base type
+ * `undefined`, because JSON and thus `one` cannot hold it (D48). A function gives `unknown`.
+ */
 function valueType(value: unknown): ValueType {
-  return value === undefined || typeof value === "function" ? "unknown" : { one: [value as Json] };
+  if (value === undefined) return "undefined";
+  return typeof value === "function" ? "unknown" : { one: [value as Json] };
 }
 
 /** This function tells if a value has the form of a signature: a record with `params` as a list, and `to`. */
@@ -236,14 +243,14 @@ function listText(names: readonly string[]): string {
 }
 
 /**
- * This function tells if a signature takes a count of arguments. A parameter of the type `unknown` at the end is
- * optional, because a missing argument is `undefined`.
+ * This function tells if a signature takes a count of arguments. A parameter at the end is optional when its type
+ * holds `undefined`, because a missing argument is `undefined`. `unknown` and the base type `undefined` hold it.
  *
  * @returns `undefined` when the number is correct, or else the text of the numbers that the signature takes.
  */
 function arityOf(sig: Signature, count: number, domains: Machine["domains"]): string | undefined {
   let least = sig.params.length;
-  while (least > 0 && isUnknown(sig.params[least - 1], domains)) least -= 1;
+  while (least > 0 && member(undefined, sig.params[least - 1] as ValueType, domains)) least -= 1;
   const most = sig.rest === undefined ? sig.params.length : Number.POSITIVE_INFINITY;
   if (count >= least && count <= most) return undefined;
   if (most === Number.POSITIVE_INFINITY) return `at least ${argumentsText(least)}`;
@@ -487,6 +494,8 @@ function formulaTypes(profile: FormulaProfile): Readonly<Record<string, TypeRule
         const name = nameOf(input);
         const own = profile.ext !== undefined && Object.hasOwn(profile.ext, name);
         if (own) return "unknown";
+        // The standard extensions give the values that JSON cannot write, thus each has a base type (D48).
+        if (name === "undefined") return "undefined";
         if (name === "number") return "number";
         return name === "domain" ? domainTypeOf(input.doc.value, input.machine.domains) : "unknown";
       },
@@ -534,6 +543,7 @@ const PROFILE_KEYS = /* @__PURE__ */ Object.freeze([
   "check",
   "combine",
   "pure",
+  "pureExt",
   "volatile",
   "sigs",
 ] as const satisfies readonly (keyof FormulaProfile)[]);
@@ -687,8 +697,9 @@ function formulaCode(profile: FormulaProfile): Readonly<Record<string, CompiledE
 
   return {
     "formula.lit": compiled(({ doc }) => {
+      // A literal cannot fail, thus its code needs no place (PLAN.TOTAL).
       const result = ok(doc.value);
-      return () => result;
+      return totalCode(() => result);
     }),
 
     "formula.ref": compiled(({ doc, parts, fill, address, machine }) => {
@@ -708,7 +719,7 @@ function formulaCode(profile: FormulaProfile): Readonly<Record<string, CompiledE
       // A step document without parts is its own value. A step document with parts gets the result of each part.
       if (parts.length === 0) {
         const same = ok(doc);
-        return () => same;
+        return totalCode(() => same);
       }
       return (ctx, rt) => {
         const values = valuesOf(parts, ctx, rt);
@@ -979,10 +990,13 @@ function makeKnown(profile: FormulaProfile): (path: readonly Key[], evaluator: s
   };
 }
 
-/** The facts of an extension of the profile. It gets the context, thus it can read outside `resolve`. */
+/**
+ * The facts of an extension of the profile that `pureExt` does not name. It gets the context, thus it can read outside
+ * `resolve`.
+ */
 const NOT_PURE: KindFacts = /* @__PURE__ */ Object.freeze({ pure: false });
 
-/** The facts of a standard extension. */
+/** The facts of a standard extension, and of an extension that `pureExt` names. */
 const PURE: KindFacts = /* @__PURE__ */ Object.freeze({ pure: true });
 
 /** The lazy rule of a lazy operation: it covers each argument. */
@@ -994,7 +1008,8 @@ const EACH_PART: readonly LazyRule[] = /* @__PURE__ */ Object.freeze([/* @__PURE
  *
  * - An operation of `lazy` has a lazy rule for each argument.
  * - 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.
+ * - A standard extension is pure. An extension of the profile is pure only when the profile names it in `pureExt` (D47).
+ *   Such an extension keeps C4: it reads the context only through `resolve`.
  *
  * Equal profiles give the same hook (D46).
  *
@@ -1009,10 +1024,14 @@ export function formulaFacts(profile: FormulaProfile = {}): (path: readonly Key[
 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 pureExt = new Set(profile.pureExt ?? []);
   return (path, code) => {
     if (code !== "formula.op" && code !== "formula.ext") return undefined;
     const name = path.slice(1).join(".");
-    if (code === "formula.ext") return profile.ext !== undefined && Object.hasOwn(profile.ext, name) ? NOT_PURE : Object.hasOwn(STD_EXT, name) ? PURE : undefined;
+    if (code === "formula.ext") {
+      if (profile.ext !== undefined && Object.hasOwn(profile.ext, name)) return pureExt.has(name) ? PURE : NOT_PURE;
+      return Object.hasOwn(STD_EXT, name) ? PURE : undefined;
+    }
     // An operation that the language does not have gives #NAME?. The kit gives it no facts.
     if (known(path, code) !== true) return undefined;
     const isVolatile = volatile.has(name);

package/src/generate.ts

@@ -146,9 +146,11 @@ export function generate(world: World, options: GenerateOptions): unknown {
   const keys = options.keys ?? KEYS;
   const steps = options.steps ?? 2;
   const roots: readonly Root[] = options.roots ?? ROOTS;
+  // A kind with the verb step walks a step document. With a default of step, each other kind walks one too (GEN.STEPS).
+  const defaultStep = Object.hasOwn(world.defaults, "step");
   const stepTypes = types.filter((type) => {
     const found = lookupKind(world, type);
-    return found.ok && Object.hasOwn(found.kind.verbs, "step");
+    return found.ok && (defaultStep || Object.hasOwn(found.kind.verbs, "step"));
   });
   // A name under each namespace with a fallback that no evaluator knows, for example ["ops", "nope"].
   const unknownNames: readonly (readonly Key[])[] = Object.keys(world.kinds)
@@ -205,7 +207,10 @@ export function generate(world: World, options: GenerateOptions): unknown {
     return out;
   };
 
-  /** A path from a root (D10). It uses the names in scope, and sometimes a step document. */
+  /**
+   * A path from a root (D10). It uses the names in scope, and sometimes a step document. The kind of a step document
+   * has the verb `step`, or the default of the world for `step` serves it.
+   */
   const pathFor = (pos: Position, refKind: Kind | undefined): Json => {
     if (rng.chance(malformed)) return rng.pick<Json>(["names", [], { names: "a" }, ["nowhere", "a"]]);
     const others = roots.filter((name) => name !== "names");

package/src/index.ts

@@ -49,8 +49,10 @@ export {
   type Shape as PartShape,
   type Side,
   type TreeContract,
+  type VerbEffects,
   type World,
   type WorldEntry,
+  effectsOfVerb,
   entriesAsJson,
   equationType,
   isAlias,
@@ -132,6 +134,7 @@ export {
   type Part,
   type Perform,
   type Plan,
+  type PlanRunOptions,
   type PrepareOptions,
   type Read,
   type Run,

package/src/providers.ts

@@ -235,6 +235,7 @@ function samplesAt(values: readonly unknown[], closed: boolean, depth: number):
   let lists = false;
   for (const value of values) {
     if (value === null) bases.add("null");
+    else if (value === undefined) bases.add("undefined");
     else if (typeof value === "boolean") bases.add("bool");
     else if (typeof value === "number") bases.add("number");
     else if (typeof value === "string") bases.add("text");
@@ -243,10 +244,10 @@ function samplesAt(values: readonly unknown[], closed: boolean, depth: number):
       // A hole of a list holds undefined, thus a loop by index reads it too.
       for (let index = 0; index < value.length; index += 1) items.push(value[index]);
     } else if (isRecord(value)) records.push(value);
-    // A value without a type of the kernel, for example a function or undefined, has each type.
+    // A value without a type of the kernel, for example a function, has each type.
     else return "unknown";
   }
-  for (const base of ["null", "bool", "number", "text"]) if (bases.has(base)) types.push(base);
+  for (const base of ["null", "undefined", "bool", "number", "text"]) if (bases.has(base)) types.push(base);
   if (lists) types.push({ list: samplesAt(items, closed, depth + 1) });
   if (records.length > 0) {
     // All records join into one record. A field that a record does not have is optional.
@@ -268,7 +269,7 @@ function samplesAt(values: readonly unknown[], closed: boolean, depth: number):
  * This function infers a value type from sample values (TYPE.SAMPLES), as a type provider of F# does. A host uses it
  * for the type of a root, for example from some events.
  *
- * - `null`, a truth value, a number and a text give their base types, not their values.
+ * - `null`, `undefined`, a truth value, a number and a text give their base types, not their values.
  * - The items of each list join into one type of items.
  * - All records join into one record with each key of the samples. A key that a record does not have is optional.
  * - Values of different forms give a union, as `join` gives. No samples give `never`.

package/src/static.ts

@@ -1,5 +1,5 @@
 import { type Envelope, type Json, type Key, isKey, isRecord, typeName } from "./doc.ts";
-import { type Kind, type Namespace, type World, type WorldEntry, equationType, isKind, isNamespace } from "./world.ts";
+import { type Kind, type Namespace, type World, type WorldEntry, effectsOfVerb, equationType, isKind, isNamespace } from "./world.ts";
 import { ask } from "./ladder.ts";
 import { type PartSlot, partsOf, scopesOf } from "./parts.ts";
 import { type Cap, type Context, type Root, ROOTS, context, isRef, walkerOf, worldThing } from "./deref.ts";
@@ -364,8 +364,11 @@ export interface CheckOptions {
   readonly caps?: readonly Cap[];
   /**
    * The verb that goes up the ladder at each document, as in `prepare`. The default is `eval`. `#NOEVAL` and the hook
-   * `known` follow this verb. The contract declares the effects and the value types of `eval` only, thus only `eval`
-   * checks them (VERB.CHECK). The type rule of an evaluator serves each verb.
+   * `known` follow this verb. The type rule of an evaluator serves each verb.
+   *
+   * The check tests the effects that the contract declares for this verb (VERB.EFFECTS). A kind without a declaration
+   * for the verb gives no effect issue. The contract declares the value types of `eval` only, thus only `eval` checks
+   * them (VERB.CHECK).
    */
   readonly verb?: string;
   /**
@@ -408,16 +411,28 @@ const EACH: readonly Cap[] = /* @__PURE__ */ Object.freeze([[]]);
 const NO_EFFECTS: readonly (readonly Key[])[] = /* @__PURE__ */ Object.freeze([]);
 
 /**
- * This function gives the effects that the contract of the kind of a visit declares, as keys (FACTS.EFFECTS). The
- * text `"type"` gives the type of the document after each alias. A visit without a kind declares no effect. `check`,
- * `factsOf` and `effectsOf` read the declarations with this one function (D27).
+ * This function gives the effects that the contract of the kind of a visit declares for a verb, as keys
+ * (FACTS.EFFECTS, VERB.EFFECTS). The text `"type"` gives the type of the document after each alias. A visit without a
+ * kind declares no effect. `check`, `factsOf` and `effectsOf` read the declarations with this one function (D27).
  *
  * @param v - The visit.
+ * @param verb - The verb. The default is `eval`. A kind without a declaration for the verb gives no effect.
  * @returns The keys of each declared effect, in the order of the contract.
  */
-export function declaredEffects(v: DocVisit): readonly (readonly Key[])[] {
-  const effects = v.kind?.effects;
-  if (effects === undefined || effects.length === 0) return NO_EFFECTS;
+export function declaredEffects(v: DocVisit, verb = "eval"): readonly (readonly Key[])[] {
+  return verbDeclared(v, verb) ?? NO_EFFECTS;
+}
+
+/**
+ * This function gives the effects that the contract of the kind of a visit declares for a verb, as keys. The result
+ * is `undefined` when the contract has no declaration for the verb (D49). A visit without a kind declares no effect
+ * for `eval` and no declaration for another verb.
+ */
+function verbDeclared(v: DocVisit, verb: string): readonly (readonly Key[])[] | undefined {
+  if (v.kind === undefined) return verb === "eval" ? NO_EFFECTS : undefined;
+  const effects = effectsOfVerb(v.kind, verb);
+  if (effects === undefined) return undefined;
+  if (effects.length === 0) return NO_EFFECTS;
   return effects === "type" ? [v.typePath ?? []] : effects.map((kind) => kind.split("."));
 }
 
@@ -472,7 +487,9 @@ function capReason(v: DocVisit, kind: readonly Key[], allowed: (caps: readonly C
  *   A run does not always fail there, thus a type issue is a static finding, not an error of a run.
  *
  * The check asks the ladder for the verb of the options, `eval` by default (VERB.CHECK). The shapes, the paths and the
- * names follow the contracts, thus they are the same for each verb. Only `eval` checks the declared effects.
+ * names follow the contracts, thus they are the same for each verb. The check tests the effects that each contract
+ * declares for the verb: `effects` for `eval`, and the entry of `verbEffects` for another verb (VERB.EFFECTS). A kind
+ * without a declaration for the verb gives no `#CAP!` and no `#CALC!` for an effect.
  *
  * @param machine - The world and the code of the evaluators.
  * @param doc - The document, as JSON.
@@ -651,9 +668,8 @@ function checkAll(machine: Machine, doc: unknown, options: CheckOptions, nodes:
     issues.push(issue);
     if (current !== undefined) current.marked = true;
   };
-  // The effects of a contract are the effects of eval (VERB.CONTRACT). An effect of another verb meets its test when
-  // it happens (RUN.CAP).
-  const effects = verb === "eval";
+  // The field effects declares eval, and verbEffects declares the other verbs (VERB.EFFECTS). An effect of a verb
+  // without a declaration meets its test when it happens (RUN.CAP).
   const allowed = options.caps === undefined ? undefined : permitsOf(machine);
   // In a run, a part that can wait needs a parent that can wait (RUN.CAN-WAIT). The map tells for each document with
   // code if its code passes a wait on: false for an evaluator, true for a runner whose waits reach the driver of the
@@ -704,7 +720,8 @@ function checkAll(machine: Machine, doc: unknown, options: CheckOptions, nodes:
         if (known !== true) push({ code: "#NAME?", place: v.place, reason: known, at: v.at });
       }
       const caps = v.caps;
-      const declared = effects ? declaredEffects(v) : NO_EFFECTS;
+      const stated = verbDeclared(v, verb);
+      const declared = stated ?? NO_EFFECTS;
       if (allowed !== undefined && caps !== undefined) {
         for (const kind of declared) {
           if (!allowed(caps, kind)) push({ code: "#CAP!", place: v.place, reason: capReason(v, kind, allowed), at: v.at });
@@ -718,16 +735,17 @@ function checkAll(machine: Machine, doc: unknown, options: CheckOptions, nodes:
           // The run drives a runner under an evaluator, and only a real wait fails (RUN.DRIVE-NESTED). Its issue goes in
           // here, in the order of the document, when an effect of its runners can wait.
           const issue: Issue = { code: "#CALC!", place: v.place, reason: waitedReason(typeName(v.doc.type)), at: v.at };
-          chain = { issue, index: issues.length, node: current, wait: !effects };
+          chain = { issue, index: issues.length, node: current, wait: false };
           drives.push(chain);
         } else if (runner) {
           chain = up ?? true;
         }
         waits.set(v, chain);
-        // A runner waits only for an effect that reaches the host (C6). A refused effect gives #CAP! without a wait.
+        // A runner waits only for an effect that reaches the host (C6). A refused effect gives #CAP! without a wait. A
+        // runner without a declaration for the verb can cause each effect, thus it can wait.
         if (typeof chain === "object" && !chain.wait) {
           const rule = allowed ?? permits;
-          chain.wait = declared.some((kind) => caps === undefined || rule(caps, kind));
+          chain.wait = stated === undefined || declared.some((kind) => caps === undefined || rule(caps, kind));
         }
         // In a run, the host does each effect, thus an evaluator cannot cause one.
         const first = declared[0];

package/src/types.ts

@@ -9,8 +9,8 @@ import { type Json, type Key, docEquals, isEnvelope, isRecord } from "./doc.ts";
 /**
  * A value type: a set of values that a result can have, as a JSON term.
  *
- * - A text names a base type: `unknown`, `never`, a domain of the kernel (`null`, `bool`, `number`, `text`), or a
- *   domain of a language.
+ * - A text names a base type: `unknown`, `never`, a domain of the kernel (`null`, `undefined`, `bool`, `number`,
+ *   `text`), or a domain of a language.
  * - `list`: a list whose items have the type.
  * - `record`: a plain record with the named fields. `optional` names the fields that can be absent. A `closed`
  *   record has no other fields. The other fields of an open record can hold each value.
@@ -95,6 +95,8 @@ export interface TypeIssue {
  */
 export const STD_DOMAINS: Readonly<Record<string, Domain>> = {
   null: { is: (value) => value === null, summary: "The value null." },
+  // JSON has no undefined, thus a document holds it as ext.undefined (D48). The domain has no codec: the codec of values writes undefined first.
+  undefined: { is: (value) => value === undefined, summary: "The value undefined. A document holds it as the extension ext.undefined." },
   bool: { is: (value) => typeof value === "boolean", summary: "A truth value: true or false." },
   number: { is: (value) => typeof value === "number", summary: "A number of the host, also NaN, an infinity and -0." },
   text: { is: (value) => typeof value === "string", summary: "A text." },

package/src/world.ts

@@ -172,7 +172,8 @@ export function equationType(kind: Kind): string | undefined {
 /**
  * A kind gives the name of an evaluator for each verb, and the contract of its value. The contract serves each verb.
  * For each verb, the kernel splits the parts and narrows their capabilities by it, and `check` reads its scope rules.
- * `side` and `effects` tell what the verb `eval` does (VERB.CONTRACT).
+ * `side` and `effects` tell what the verb `eval` does (VERB.CONTRACT). `verbEffects` tells the effects of the other
+ * verbs (VERB.EFFECTS).
  */
 export interface Kind extends KindFacts {
   /**
@@ -200,6 +201,13 @@ export interface Kind extends KindFacts {
    * (CAP.LATENT).
    */
   readonly effects?: "type" | readonly string[];
+  /**
+   * The effects that the other verbs of a document of this kind can cause, by verb, in the form of `effects`
+   * (VERB.EFFECTS, D49). An entry `view: []` declares no effect for `view`. A verb without an entry has no
+   * declaration, thus `check` does not test its effects. The field `effects` declares `eval`, thus this field has no
+   * entry `eval`.
+   */
+  readonly verbEffects?: VerbEffects;
   /**
    * The value type of the result of the verb `eval`, when it is fixed (TYPE.SYNTH). A check of types gives it to each
    * document of the kind, in the place of the type that the rule of the evaluator synthesizes.
@@ -214,6 +222,28 @@ export interface Kind extends KindFacts {
   readonly summary?: string;
 }
 
+/**
+ * The effects that a contract declares for the verbs other than `eval`, by verb (D49). Each entry has the form of the
+ * field `effects` of a kind. The type has no entry `eval`, because the field `effects` declares `eval`.
+ */
+export type VerbEffects = Readonly<Record<string, "type" | readonly string[]>> & { readonly eval?: never };
+
+/**
+ * This function gives the effects that the contract of a kind declares for a verb (VERB.EFFECTS, D49). For `eval`,
+ * the field `effects` declares them, and a kind without the field declares no effect. For another verb, the entry of
+ * `verbEffects` declares them. `check` and `conforms` read the declarations with this one function.
+ *
+ * @param kind - The kind.
+ * @param verb - The verb.
+ * @returns The declaration in the form of `effects`, or `undefined` when the contract does not declare the effects of
+ *   the verb.
+ */
+export function effectsOfVerb(kind: Kind, verb: string): "type" | readonly string[] | undefined {
+  if (verb === "eval") return kind.effects ?? [];
+  const table = kind.verbEffects as Readonly<Record<string, "type" | readonly string[]>> | undefined;
+  return table !== undefined && Object.hasOwn(table, verb) ? table[verb] : undefined;
+}
+
 /** A namespace: a group of entries under one key of the world. `fallback` is the kind of each other key in it. */
 export interface Namespace {
   readonly kinds: Readonly<Record<string, WorldEntry>>;