@mark1russell7/coeval 0.11.0 → 0.12.0

package/package.json

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

@@ -363,6 +363,8 @@ export function context(parts: Partial<Context> = {}): Context {
 }
 
 const MAX_COLLAPSE = 64;
+/** The reason of a resolution that reaches the bound of collapses without a cycle that it found (DEREF.CHAIN-REASON). It is a plain string, thus a bundle drops it (PKG.PURE). */
+const CHAIN_REASON = "The path follows more than 64 references. One resolution follows at most 64.";
 const NO_HOPS: readonly Hop[] = /* @__PURE__ */ Object.freeze([]);
 
 /** A value that can be a reference document: a record with the type `ref`. The full check comes after. */
@@ -560,7 +562,8 @@ function walkersOf(nav: Navigator, path: readonly unknown[]): KnownWalkers | und
  * - `#NAME?`: the root `names` has no such name.
  * - `#N/A`: a step reaches nothing.
  * - `#STEP?`: a step is not a key and not a step document.
- * - `#CYCLE!`: the references form a cycle.
+ * - `#CYCLE!`: the references form a cycle, or the resolution follows more than 64 references. The reason tells
+ *   which (DEREF.CHAIN-REASON).
  *
  * @param nav - The world and the code of the evaluators.
  * @param ctx - The context.
@@ -590,15 +593,21 @@ function resolveFully(nav: Navigator, ctx: Context, path: readonly unknown[], ho
   const done = hops ?? NO_HOPS;
   const failed = (code: ResolveCode | ErrorCode, reason: string): Resolution => ({ ok: false, code, reason, hops: done });
   let collapses = 0;
+  // The references whose paths are in evaluation. A reference that is in this list again closes a cycle.
+  let open: object[] | undefined;
   const adopt = nav.adopt ?? ((value: unknown): Thing => value);
 
   const collapse = (thing: Thing): Resolution => {
     let here = thing;
     if (nav.plain === true) return { ok: true, thing: here, hops: done };
     while (isRef(here)) {
+      if (open?.includes(here) === true) return failed("#CYCLE!", "The references form a cycle.");
       collapses += 1;
-      if (collapses > MAX_COLLAPSE) return failed("#CYCLE!", "The references form a cycle.");
+      if (collapses > MAX_COLLAPSE) return failed("#CYCLE!", CHAIN_REASON);
+      open ??= [];
+      open.push(here);
       const inner = walk(here.value, undefined);
+      open.pop();
       if (!inner.ok) return inner;
       here = adopt(inner.thing);
       hops?.push({ step: "collapse", thing: here, by: "collapse" });

package/src/evaluate.ts

@@ -156,6 +156,22 @@ function granted(ctx: Context): Context {
   return out;
 }
 
+/**
+ * This function gives the context in which the runtime resolves a path of compiled code (CAP.CAPS-GRANT). A path from
+ * the root `caps` reads the capabilities that both the context and its grant permit, and a context without a grant
+ * reads none. Thus a context that compiled code widened gives the capabilities of its document, and a context that it
+ * narrowed keeps its own list. Each other path, and each context whose grant is its own list, keeps the same context.
+ */
+function readable(ctx: Context, path: readonly unknown[]): Context {
+  if (path[0] !== "caps") return ctx;
+  const grant = (ctx as Granted)[GRANT];
+  if (grant === ctx.caps) return ctx;
+  const caps = grant === undefined ? NO_CAPS : intersectCaps(ctx.caps, grant);
+  if (caps === ctx.caps) return ctx;
+  const out: Granted = { ...ctx, caps, [GRANT]: caps };
+  return out;
+}
+
 /**
  * This function gives the context of a part of a function evaluator. It is the context that the evaluator gives,
  * narrowed by the context of the document (CAP.NARROW), with the grant of its capabilities.
@@ -896,15 +912,18 @@ class Session implements Runtime {
     return this.reading !== undefined;
   }
 
+  /** This function resolves a path. A path from the root `caps` reads the capabilities through the grant (CAP.CAPS-GRANT). */
   resolve(ctx: Context, path: readonly unknown[], options?: ResolveOptions): Resolution {
-    return this.read(ctx, path, undefined, options);
+    return this.read(readable(ctx, path), path, undefined, options);
   }
 
   /**
    * This function resolves a compiled path (PLAN.PATH). Without a list of reads and without a trace, the compiled
-   * path answers at once. Each other resolution records its read, as `resolve` does.
+   * path answers at once. Each other resolution records its read, as `resolve` does. A path from the root `caps` reads
+   * the capabilities through the grant (CAP.CAPS-GRANT).
    */
-  resolvePath(ctx: Context, compiled: CompiledPath): Resolution {
+  resolvePath(given: Context, compiled: CompiledPath): Resolution {
+    const ctx = readable(given, compiled.path);
     if (this.reading === undefined && !this.traced && compiled.nav === this.machine) return compiled.resolve(ctx);
     return this.read(ctx, compiled.path, compiled, undefined);
   }

package/src/world.ts

@@ -270,10 +270,28 @@ export interface World {
   readonly fallback?: Kind;
 }
 
-/** The result of a lookup of a type in the world. */
+/**
+ * The result of a lookup of a type in the world. The reasons of a failure:
+ *
+ * - `unknown`: the world has no entry for a key, and no fallback kind.
+ * - `cycle`: the aliases form a cycle. The lookup reached a path a second time.
+ * - `too-long`: the lookup followed more than 32 aliases without a path a second time (DEREF.CHAIN-REASON).
+ * - `not-a-kind`: the path reaches an entry of the wrong sort. An example is an alias whose target is not in the world.
+ * - `computed`: the type is a computed type, thus it has no keys.
+ */
 export type Lookup =
   | { readonly ok: true; readonly kind: Kind; readonly path: readonly Key[]; readonly aliases: number }
-  | { readonly ok: false; readonly reason: "unknown" | "cycle" | "not-a-kind" | "computed"; readonly path: readonly Key[] };
+  | { readonly ok: false; readonly reason: "unknown" | "cycle" | "too-long" | "not-a-kind" | "computed"; readonly path: readonly Key[] };
+
+/** The most aliases that one lookup follows (WORLD.ALIAS-LIMIT). */
+const MAX_ALIASES = 32;
+
+/** This function tells if two paths of a lookup have the same keys. */
+function samePath(a: readonly Key[], b: readonly Key[]): boolean {
+  if (a.length !== b.length) return false;
+  for (let index = 0; index < a.length; index += 1) if (a[index] !== b[index]) return false;
+  return true;
+}
 
 /**
  * This function tells if an entry of the world is a kind.
@@ -312,7 +330,8 @@ function entryAt(entries: Readonly<Record<string, WorldEntry>>, key: Key): World
 
 /**
  * This function finds the kind that a type names. It walks the path from the root of the world, one key at a
- * time. An alias on the way is followed until a kind answers (collapse). A cycle of aliases stops the lookup. In a
+ * time. An alias on the way is followed until a kind answers (collapse). A cycle of aliases stops the lookup, and so
+ * does a chain of more than 32 aliases. In a
  * namespace with a fallback, a key that the namespace does not have gets the fallback kind. In an open world, a first
  * key that the world does not have gets the fallback kind of the world.
  *
@@ -325,6 +344,8 @@ export function lookupKind(world: World, type: TypeRef): Lookup {
   if (start === undefined) return { ok: false, reason: "computed", path: [] };
   let path: readonly Key[] = start;
   let aliases = 0;
+  // The paths before each alias. The same path again closes a cycle, because the lookup of a path is always the same.
+  let seen: (readonly Key[])[] | undefined;
   for (;;) {
     let entries = world.kinds;
     let fallback: Kind | undefined = world.fallback;
@@ -339,12 +360,16 @@ export function lookupKind(world: World, type: TypeRef): Lookup {
       }
       if (isAlias(entry)) {
         aliases += 1;
-        if (aliases > 32) return { ok: false, reason: "cycle", path };
+        if (aliases > MAX_ALIASES) return { ok: false, reason: "too-long", path };
         const target = entry.value.slice(1);
         if (entry.value[0] !== "world" || !target.every((item) => typeof item === "string" || typeof item === "number")) {
           return { ok: false, reason: "not-a-kind", path };
         }
+        seen ??= [];
+        seen.push(path);
         path = [...(target as readonly Key[]), ...path.slice(index + 1)];
+        const next = path;
+        if (seen.some((before) => samePath(before, next))) return { ok: false, reason: "cycle", path };
         followed = true;
         break;
       }