aontu 0.61.0 → 0.63.0

package/src/utility.ts

@@ -1,18 +1,9 @@
 /* Copyright (c) 2023-2025 Richard Rodger, MIT License */
 
 
-
 import type { AontuOptions, TrustOptions, Val } from './type'
 
 
-// THE INCLUDE OPTIONS AN ENGINE HANDS ITS Aontu INSTANCE. Every verb
-// engine builds one, and until there were two such options each did it
-// inline -- `null == options.trust ? undefined : { trust: options.trust }`,
-// written out twelve times. That is fine while there is one option and
-// a latent bug the moment there are two: `textExt` had to reach the
-// same twelve places, and the one it missed refused a `.md` include
-// under a flag the bare command honoured. One function now, so a third
-// include option is threaded once.
 type IncludeOptions = {
   trust?: TrustOptions
   textExt?: string[]
@@ -27,11 +18,6 @@ function includeOpts(options: IncludeOptions): Partial<AontuOptions> {
 }
 
 
-// Default walk() depth limit. High enough that real configs are never
-// silently truncated (the old default of 32 dropped marks on deeply
-// nested refs/funcs → wrong output), while still bounding runaway or
-// accidentally-cyclic walks (walk has no cycle detection). Pass null for
-// truly unbounded.
 const WALK_DEFAULT_MAXDEPTH = 9999
 
 
@@ -47,12 +33,6 @@ function propagateMarks(source: Val, target: Val): void {
 }
 
 
-// Collect every value in the tree carrying the deprecation record (G3
-// phase 4), with its path — the one walk behind vet's `deprecated`
-// warnings and the LSP's Deprecated tags. The record travels on meets
-// (the unite rider) and clones, so this sees the declaration and every
-// use resolving through it. The non-Val guard is for a bag's raw peg
-// entries, which degenerate parses can leave behind.
 function collectDeprecations(
   root: Val): Array<{ val: Val, path: string[] }> {
   const out: Array<{ val: Val, path: string[] }> = []
@@ -97,17 +77,6 @@ function deprecationMessage(d: Record<string, string>): string {
 }
 
 
-// The canonical form of a value, wrapped in the RIDER it carries —
-// the deprecation record (G3 phase 4) — reparseably, so
-// `deprecate(x, m)` survives canon. Bags render their children through
-// this (MapVal/ListVal canon), which is where a marked FIELD — the
-// realistic case — lives.
-//
-// The rider renders HERE and not in the value's own `canon` for the
-// same reason the guard at the MapVal call site tests the isVal flag:
-// a bag's canon recursion visits each child once, and a child that
-// wrapped itself as well would render its subtree twice per level —
-// 2^depth on a nested document.
 function canonRiders(v: Val): string {
   const c = v.canon
   const d = v.deprecation

package/src/val/AbnfFuncVal.ts

@@ -0,0 +1,181 @@
+/* Copyright (c) 2026 Richard Rodger, MIT License */
+
+// The grammar pair, ADR-033. Twin of go/abnf.go.
+
+import type { Val, ValSpec } from '../type'
+import { DONE } from '../type'
+import { AontuContext } from '../ctx'
+import { FuncBaseVal } from './FuncBaseVal'
+import { StringVal } from './StringVal'
+import { MapVal } from './MapVal'
+import { ListVal } from './ListVal'
+import { ConjunctVal } from './ConjunctVal'
+import { makeNilErr } from '../err'
+import { compileGrammar, parseWith } from '../grammar'
+
+
+class AbnfFuncVal extends FuncBaseVal {
+  isAbnfFunc = true
+
+  constructor(spec: ValSpec, ctx?: AontuContext) {
+    super(spec, ctx)
+  }
+
+  funcname() {
+    return 'abnf'
+  }
+
+  resolve(ctx: AontuContext, args: Val[]): Val {
+    const a: any = args[0]
+
+    // Not an arity check: the arity and signature gates run first, so
+    // what reaches here is a nil argument, which both pass over.
+    if ('string' !== typeof a?.peg) {
+      return this.place(makeNilErr(ctx, 'abnf_grammar', this, undefined,
+        'abnf'))
+    }
+
+    const [, why] = compileGrammar(a.peg)
+    if (undefined !== why) {
+      return this.place(makeNilErr(ctx, 'abnf_grammar', this, undefined,
+        'abnf', { reason: why }))
+    }
+
+    return this.place(new StringVal({ peg: a.peg }, ctx))
+  }
+}
+
+
+// A tree node is just the map {rule, src, kids}, so it needs no case of
+// its own. Keys are sorted so both ports build the same member order.
+function astVal(node: any, ctx: AontuContext): Val {
+  if ('string' === typeof node) {
+    return new StringVal({ peg: node }, ctx)
+  }
+
+  if (Array.isArray(node)) {
+    return new ListVal({
+      peg: node.map(
+        (e: any, i: number) => astVal(e, ctx.descend(String(i)))),
+    }, ctx)
+  }
+
+  const peg: Record<string, Val> = {}
+  for (const k of Object.keys(node).sort()) {
+    peg[k] = astVal(node[k], ctx.descend(k))
+  }
+  return new MapVal({ peg }, ctx)
+}
+
+
+class ParseFuncVal extends FuncBaseVal {
+  isParseFunc = true
+
+  constructor(spec: ValSpec, ctx?: AontuContext) {
+    super(spec, ctx)
+  }
+
+  funcname() {
+    return 'parse'
+  }
+
+
+  // Meets its peer instead of resolving, so it must see the peer
+  // before the base drives to resolve().
+  unify(peer: Val, ctx: AontuContext): Val {
+    if (1 !== this.peg.length) {
+      return super.unify(peer, ctx)
+    }
+
+    this.driveStagedArgs(ctx, 1)
+
+    const g: any = this.peg[0]
+    if ('string' !== typeof g?.peg) {
+      return this.residuate(peer, ctx)
+    }
+
+    // A settled constraint is stable, as a residual constraint atom is.
+    // Without this a `type()` holding one never resolves.
+    this.dc = DONE
+
+    const p: any = peer
+    if (true !== p?.isString || 'string' !== typeof p?.peg) {
+      return this.hold(peer, ctx)
+    }
+
+    const [grammar, why] = compileGrammar(g.peg)
+    if (undefined !== why) {
+      return makeNilErr(ctx, 'abnf_grammar', this, peer, 'parse',
+        { reason: why })
+    }
+    if ('' === p.peg) {
+      return makeNilErr(ctx, 'parse_failed', this, peer, 'parse',
+        { reason: 'the empty string parses under no grammar' })
+    }
+    const [, err] = parseWith(grammar, p.peg, ctx)
+    if (undefined !== err) {
+      return makeNilErr(ctx, 'parse_failed', this, peer, 'parse',
+        { reason: err })
+    }
+
+    return peer
+  }
+
+
+  // The stable twin of residuate: no `notdone()`, because a settled
+  // constraint stays done while it waits for a value.
+  hold(peer: Val, ctx: AontuContext): Val {
+    if (peer.isTop || peer.id === this.id) {
+      // Cloned, or a driver meeting it twice reports `unify_cycle`.
+      const out: Val = this.clone(ctx)
+      out.dc = DONE
+      return out
+    }
+
+    if (peer.isFunc
+      && (peer as any).funcname() === this.funcname()
+      && peer.path.join('.') === this.path.join('.')
+      && peer.canon === this.canon) {
+      return this
+    }
+
+    return new ConjunctVal({ peg: [this, peer] }, ctx)
+  }
+
+
+  resolve(ctx: AontuContext, args: Val[]): Val {
+    const g: any = args[0]
+    const v: any = args[1]
+
+    // Not an arity check: see the abnf twin above.
+    if ('string' !== typeof g?.peg || 'string' !== typeof v?.peg) {
+      return this.place(makeNilErr(ctx, 'parse_arg', this, undefined, 'parse'))
+    }
+
+    const [grammar, why] = compileGrammar(g.peg)
+    if (undefined !== why) {
+      return this.place(makeNilErr(ctx, 'abnf_grammar', this, undefined,
+        'parse', { reason: why }))
+    }
+
+    // The host answers an empty tree for empty input.
+    if ('' === v.peg) {
+      return this.place(makeNilErr(ctx, 'parse_failed', this, undefined,
+        'parse', { reason: 'the empty string parses under no grammar' }))
+    }
+
+    const [node, err] = parseWith(grammar, v.peg, ctx)
+    if (undefined !== err) {
+      return this.place(makeNilErr(ctx, 'parse_failed', this, undefined,
+        'parse', { reason: err }))
+    }
+
+    return this.place(astVal(node, ctx))
+  }
+} /* node:coverage ignore next 6 */
+
+
+export {
+  AbnfFuncVal,
+  ParseFuncVal,
+}

package/src/val/AbsentVal.ts

@@ -0,0 +1,54 @@
+/* Copyright (c) 2026 Richard Rodger, MIT License */
+
+
+import type {
+  Val,
+  ValSpec,
+} from '../type'
+
+import {
+  DONE,
+} from '../type'
+
+import {
+  AontuContext,
+} from '../ctx'
+
+import { FeatureVal } from './FeatureVal'
+
+
+// Top with one difference (ADR-034): absence is GENERABLE, and
+// generates nothing, so a bag drops it at a required key too.
+class AbsentVal extends FeatureVal {
+  isAbsent = true
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    super(spec, ctx)
+    this.dc = DONE
+    this.mark.type = false
+    this.mark.hide = false
+  }
+
+  // The unit of the meet, called for EITHER operand so `&` commutes.
+  // Nothing here meets an absence with TOP, so there is no top arm;
+  // Go has one because it MEETS an op's result where this port places
+  // it. edge-plus-list-absent guards the day that changes.
+  unify(peer: Val, _ctx: AontuContext): Val {
+    return peer
+  }
+
+  get canon() { return 'maybe()' }
+
+  gen(_ctx?: AontuContext) {
+    return undefined
+  }
+
+} /* node:coverage ignore next 6 */
+
+
+export {
+  AbsentVal,
+}