aontu 0.56.0 → 0.57.0

package/src/hints.ts

@@ -222,11 +222,33 @@ const hints: Record<string, string> = {
 
   match_none: 'No pattern matched, and there is no default. `match` tries each\npattern in the order written and takes the first the value unifies\nwith; the value {value} unified with none of {tried}. Add a trailing\ndefault — the argument after the last pair — if the rest was meant\nto be allowed.\n \nExamples:\n  match(1, integer, ok)             -> "ok"   # The first pattern matches;\n  match(x, integer, ok, other)      -> "other"  # ... or the default does;\n  match(x, integer, ok)             -> nil    # ... but nothing here does.',
 
+  emit_data: 'The first argument to emit() is not a bag. `emit` visits the\nchildren of its SELECTION, so the selection has to have children: a\nlist of nodes, or a map whose values are the nodes.\n \nExamples:\n  emit([{k:1}], {match:{k:1},body:[a]})   -> [..]  # A list of nodes;\n  emit({x:{k:1}}, {match:{k:1},body:[a]}) -> [..]  # ... or a map of them;\n  emit(1, {match:{k:1},body:[a]})         -> nil   # ... but not a scalar.',
+
+  emit_table: 'The second argument to emit() is not a rule table. A table is a\nLIST of templates, tried in order; a single template may be written\nas the map itself, which is that list of one.\n \nExamples:\n  emit($.n, [{match:integer,body:[a]}]) -> [..]  # A table of rules;\n  emit($.n, {match:integer,body:[a]})   -> [..]  # ... or one rule alone;\n  emit($.n, integer)                    -> nil   # ... but not a value.',
+
+  emit_template: 'A template in an emit() table is not a rule. Every rule is a map\nnaming both a `match` — the pattern the node is tried against — and a\n`body`, the pieces to emit. A rule with no pattern would claim every\nnode by accident; one with no body would claim a node and emit\nnothing.\n \nExamples:\n  {match: {kind: sqs}, body: [a]}  # A rule;\n  {match: {kind: sqs}}             # ... but a pattern is not one;\n  {body: [a]}                      # ... nor is a body alone.',
+
+  emit_body: 'A template body in an emit() table is not a list. A body is the\nSEQUENCE of pieces the matched node emits, so it is written as a\nlist even when it holds one piece — which is what lets bodies\ncompose, since a body element that is itself a list splices.\n \nExamples:\n  {match: integer, body: [a]}    -> [..]  # One piece;\n  {match: integer, body: [a,b]}  -> [..]  # ... or several;\n  {match: integer, body: a}      -> nil   # ... but not a bare value.',
+
+  emit_ref: 'A template body names {ref}, and the node it matched cannot\nanswer it. Inside a body a relative reference is a field of the\nMATCHED NODE — `.pin` is that node\'s `pin` — so the node has to have\nthe field; the node was {value}. An absolute reference (`$.x`) reads\nthe document root instead, and is untouched.\n \nExamples:\n  {match:{pin:string}, body:[.pin]}  -> [..]  # A field of the node;\n  {match:{pin:string}, body:[$.z]}   -> [..]  # ... or the root;\n  {match:{pin:string}, body:[.port]} -> nil   # ... but not a field it\n                                             #     has not got.',
+
+  emit_none: 'No template matched a node, and there is no catch-all. `emit`\ntries each template in the order written and takes the first the\nnode unifies with; the node {value} unified with none of {tried}.\nAdd a template whose `match` is `any` — last, since the first match\nwins — if the rest of the selection was meant to be allowed.\n \nExamples:\n  emit([1], [{match:integer,body:[a]}])  -> [..]  # A pattern matches;\n  emit([x], [{match:any,body:[a]}])      -> [..]  # ... or a catch-all;\n  emit([x], [{match:integer,body:[a]}])  -> nil   # ... but nothing here.',
+
+  esc_variant: 'esc() and usc() were given a variant that names no convention.\nA variant names a CONVENTION rather than a language, because several\nlanguages share one and one language has several. The names are `sq`,\n`sql`, `shell`, `xml`, `uri` and `regex`; written with no variant at\nall it is the C escape, JSON canonical, which covers the double-quoted\nliteral of every C-family language.\n \nExamples:\n  esc(text)          -> ...   # C / JSON, the default;\n  esc(text, sq)      -> ...   # ... single-quoted C-family;\n  esc(text, pascal)  -> nil   # ... but that is not a convention.',
+
+  usc_malformed: 'usc() was given text the convention could not have produced,\nso there is nothing to read back out: a truncated code-point escape, an\nescape the convention does not define, or an escape character standing\nalone where the convention doubles it. `usc` is the LEFT inverse of\n`esc` and it is partial — every escaped value has an original, but not\nevery string is an escaped value.\n \nExamples:\n  usc(esc(text))     -> ...   # Whatever esc() wrote;\n  usc(text, sql)     -> ...   # ... in the same convention;\n  usc(text, shell)   -> nil   # ... but not in another one.',
+
+  rep_pattern: 'The pattern given to rep() is outside the portable subset. It is\nthe same subset re() takes — RE2-compatible, no backreferences, no\nlookaround — so one document has one regexp language rather than two,\nand so a generator running a pattern over model data cannot take\nexponential time doing it.\n \nExamples:\n  rep(s, "[:,]", " ")     -> ...   # A class;\n  rep(s, "(a)(b)", "$2$1") -> ...   # ... a group;\n  rep(s, "(?=a)", "x")    -> nil   # ... but not a lookahead.',
+
+  rep_sub: 'The substitution given to rep() names something the pattern has\nnot got. `$1` to `$9` are the numbered groups, `$&` is the whole match\nand `$$` is a literal `$`; a `$` naming anything else, or a group\nnumber the pattern does not have, is refused rather than expanded to\nnothing — a generator that writes a file with a hole in it and says\nnothing is the failure this refusal exists to close.\n \nExamples:\n  rep(s, "(a)", "[$1]")  -> ...   # A group the pattern has;\n  rep(s, "a", "$$")      -> ...   # ... a literal dollar;\n  rep(s, "a", "$1")      -> nil   # ... but not a group it has not.',
+
+  split_sep: 'The separator given to split() is neither a string nor a pattern.\nA plain string is a LITERAL and an `re(…)` argument is a pattern — the\nasymmetry with rep() is deliberate, since splitting is usually on a\nliteral, and it removes the trap where `split(v, ".")` silently cuts\nbetween every character.\n \nExamples:\n  split("a,b", ",")        -> [..]  # A literal separator;\n  split("a1b", re("[0-9]")) -> [..]  # ... or a pattern;\n  split("a,b", 1)          -> nil   # ... but not a number.',
+
   place_pair: 'Two placeholders met, and neither has a value to fill the other.\n`_` is a HOLE: it is filled by whatever the call is unified with, so\na call holding one needs a peer that does not. Give one side a\nvalue.\n \nExamples:\n  upper(_) & hello        -> "HELLO"  # The peer fills the hole;\n  _ + 2 & 1               -> 3        # ... whatever the call is;\n  upper(_) & lower(_)     -> nil      # ... but two holes fill nothing.',
 
 
   module_path: 'A module import is domain-shaped and carries a major, but its\npath cannot be a directory on every platform the toolchain runs on --\nso it is refused before anything is built from it. An element may not\nbe empty, may not begin or end with `.` (which is what forbids `..`),\nand may not be a reserved device name. These are Go\'s module-path\nrules, for Go\'s reason: a module path becomes a real directory.\n \nExamples:\n  @"corp.example/s@1"        -> {..} # An ordinary path is fine;\n  @"corp.example/../s@1"     -> nil  # ... `..` would escape the store;\n  @"corp.example/nul@1"      -> nil  # ... and Windows has no such file.',
-  module_missing: 'A module import names a module that is not in this project. A\nmodule is resolved from LOCAL stores only -- `aon_vendor/` beside the\nproject\'s mod.aon, then the user cache -- because evaluation never\ntouches the network. Fetching is a separate step, and the message\nnames it.\n \nExamples:\n  @"corp.example/s@1"        -> nil  # Not fetched: run aontu mod get;\n  @"./local.aon"             -> {..} # ... a local path is not a module;\n  @"corp.example/s@1#aon1-…" -> {..} # ... and a pin does not fetch it either.',
+  module_missing: 'A module import names a module that is not in this project. A\nmodule is resolved from LOCAL stores only -- `aontu_meta/vendor/` beside the\nproject\'s mod.aon, then the user cache -- because evaluation never\ntouches the network. Fetching is a separate step, and the message\nnames it.\n \nExamples:\n  @"corp.example/s@1"        -> nil  # Not fetched: run aontu mod get;\n  @"./local.aon"             -> {..} # ... a local path is not a module;\n  @"corp.example/s@1#aon1-…" -> {..} # ... and a pin does not fetch it either.',
 
   module_integrity: 'A module resolved locally does not have the MEANING it was pinned\nto. The pin is a canon-hash -- the hash of the module unified\nstandalone -- so it survives comments, formatting and refactoring and\nbreaks on any semantic change in the module\'s transitive closure.\nVerification is always local: the registry\'s annotation is advisory.\n \nExamples:\n  @"corp.example/s@1"        -> {..} # No pin, no check;\n  @"corp.example/s@1#aon1-x" -> nil  # ... a pin that disagrees refuses;\n  aontu hash <file>                  # ... and this is what it should be.',
 
@@ -549,6 +571,31 @@ const codeClasses: Record<string, string> = {
   filter_data: 'parse',
   match_none: 'conflict',
 
+  // G9 phase 6 -- the string builtins. All five are class `parse`:
+  // what is wrong is the CALL as written -- a variant that names no
+  // convention, a pattern outside the subset, a substitution naming a
+  // group that does not exist, a separator that is neither string nor
+  // pattern. `usc_malformed` is the odd one and still `parse`: the
+  // TEXT the call was given has no inverse, which is a fact about the
+  // argument rather than about any meet.
+  esc_variant: 'parse',
+  usc_malformed: 'parse',
+  rep_pattern: 'parse',
+  rep_sub: 'parse',
+  split_sep: 'parse',
+
+  // G9 phase 6 -- apply-templates. The four shape codes are class
+  // `parse`: what is wrong is the CALL as written -- a selection with
+  // no children, a table that is not one, a rule missing a half.
+  // `emit_none` is class `conflict` for `match_none`'s reason: the
+  // node and every pattern written for it disagreed.
+  emit_data: 'parse',
+  emit_table: 'parse',
+  emit_template: 'parse',
+  emit_body: 'parse',
+  emit_none: 'conflict',
+  emit_ref: 'conflict',
+
   // G8 phase 3 -- the placeholder. Class `conflict`: two values met
   // and neither could answer for the other, which is what every
   // conflict is.

package/src/lang.ts

@@ -145,6 +145,10 @@ import { PackFuncVal } from './val/PackFuncVal'
 import { EachFuncVal } from './val/EachFuncVal'
 import { FilterFuncVal } from './val/FilterFuncVal'
 import { MatchFuncVal } from './val/MatchFuncVal'
+import { EmitFuncVal } from './val/EmitFuncVal'
+import {
+  EscFuncVal, UscFuncVal, RepFuncVal, SplitFuncVal,
+} from './val/StrFuncVal'
 import {
   AddFuncVal, SubFuncVal, MulFuncVal, DivFuncVal, ModFuncVal, RemFuncVal,
 } from './val/ArithFuncVal'
@@ -667,6 +671,25 @@ help isolate the syntax error.`,
     // the language does not grow a second. It is the primitive that
     // turns a bag of computed lines into a file.
     join: JoinFuncVal,
+
+    // G9 phase 6: apply-templates. One flat list of pieces from a
+    // selection and a RULE TABLE -- for each node, the first template
+    // whose `match` it unifies with, its `body` instantiated at that
+    // node. The dispatch is the engine's because a body referenced by
+    // path resolves its references at the definition site, and the
+    // relative resolution that does exist is a dot count that does not
+    // survive a second dispatch (docs/design/EMIT.0.md).
+    emit: EmitFuncVal,
+
+    // G9 phase 6: the string builtins the rule layer needs. `esc`
+    // makes a value safe inside a literal and `usc` reads it back;
+    // `rep` and `split` derive names from model data. All four are
+    // ordinary string functions -- they know nothing about generation,
+    // which is why they can land before the renderer does.
+    esc: EscFuncVal,
+    usc: UscFuncVal,
+    rep: RepFuncVal,
+    split: SplitFuncVal,
   }
 
 
@@ -2065,7 +2088,7 @@ function makeModelResolver(options: any) {
       const found = resolveModule(modref, from, modFs(ctx), {
         // The user cache lives outside any confinement root, so it is
         // consulted only when nothing confines this evaluation. A
-        // rooted profile sees the project's own `aon_vendor/` and
+        // rooted profile sees the project's own `aontu_meta/vendor/` and
         // nothing else, which is what `root` means.
         ...(null == rootDir ? { cache: modCache(options) } : {}),
         eval: options.mod?.eval,

package/src/lsp.ts

@@ -527,13 +527,13 @@ const COMPLETION_KEYWORD = 14
 // between G4 phases 1/2 and G8 phase 1.
 const BUILTIN_FUNCS = [
   'above', 'acyclic', 'add', 'below', 'close', 'copy', 'deprecate', 'div',
-  'each',
+  'each', 'emit', 'esc',
   'filter', 'greatest',
   'hide', 'inverse', 'join', 'key', 'least', 'length', 'list', 'lower',
   'map', 'match', 'max', 'min', 'mod', 'move', 'mul', 'must', 'neq', 'open',
   'pack', 'path', 'pick',
-  'pref', 're', 'refer', 'rel', 'rem', 'sub', 'sum', 'super', 'type', 'unique',
-  'upper',
+  'pref', 're', 'refer', 'rel', 'rem', 'rep', 'split', 'sub', 'sum',
+  'super', 'type', 'unique', 'upper', 'usc',
 ]
 
 // Scalar-kind and literal keywords.

package/src/mcp-server.ts

@@ -30,9 +30,9 @@ import type { McpRequest, McpResponse } from './mcp'
 import { VERSION } from './aontu'
 
 
-const USAGE = 'aontu-mcp - Aontu MCP server (stdio, NDJSON JSON-RPC)\n' +
+const USAGE = 'aontu mcp - Aontu MCP server (stdio, NDJSON JSON-RPC)\n' +
   '\n' +
-  '  aontu-mcp [--root <dir>]\n' +
+  '  aontu mcp [--root <dir>]\n' +
   '\n' +
   '  --root <dir>  Serve <name>Path file arguments and resolve\n' +
   '                @"..." includes, confined below <dir>\n' +
@@ -41,6 +41,7 @@ const USAGE = 'aontu-mcp - Aontu MCP server (stdio, NDJSON JSON-RPC)\n' +
 
 
 // The startup arguments. Parsed here rather than in bin/aontu-mcp.js
+// or the CLI's mcp verb
 // so the parsing is import-testable; unknown options REFUSE rather
 // than warn, because a server whose operator typo'd --root must not
 // come up quietly unconfined.

package/src/mod-tool.ts

@@ -78,7 +78,7 @@ export type ModVerifyReport = {
 
 export type ModVendorReport = {
   verdict: 'ok' | 'missing'
-  // The modules materialised into `aon_vendor/`, sorted.
+  // The modules materialised into `aontu_meta/vendor/`, sorted.
   vendored: string[]
   // Locked modules present in no store, sorted.
   missing: string[]
@@ -193,7 +193,7 @@ function usableRef(mod: string): ModuleRef | undefined {
 function storeDir(
   root: string, ref: ModuleRef, hash: string, options: ModToolOptions,
 ): string | undefined {
-  const stores = [moduleDir(pathJoin(root, 'aon_vendor'), ref)]
+  const stores = [moduleDir(pathJoin(root, 'aontu_meta', 'vendor'), ref)]
   if (null != options.cache && '' !== hash) {
     stores.push(pathJoin(options.cache, hash))
   }
@@ -203,7 +203,7 @@ function storeDir(
 
 // The lockfile's entries, as written.
 function readLock(root: string): Record<string, ModLock> {
-  const file = pathJoin(root, 'mod-lock.aon')
+  const file = pathJoin(root, 'aontu_meta', 'mod-lock.aon')
   if (!existsSync(file)) {
     return {}
   }
@@ -335,7 +335,8 @@ export function modTidy(root: string, options: ModToolOptions): ModTidyReport {
   const uniqueUnevaluable = [...new Set(unevaluable)].sort()
   const held = 0 === uniqueMissing.length && 0 === uniqueUnevaluable.length
   if (held) {
-    writeFileSync(pathJoin(root, 'mod-lock.aon'),
+    mkdirSync(pathJoin(root, 'aontu_meta'), { recursive: true })
+    writeFileSync(pathJoin(root, 'aontu_meta', 'mod-lock.aon'),
       LOCK_HEADER + lockText(lock, options) + '\n')
   }
 
@@ -441,14 +442,14 @@ export function modVerify(root: string, options: ModToolOptions):
 }
 
 
-// `aontu mod vendor`: materialise the locked closure into `aon_vendor/`.
+// `aontu mod vendor`: materialise the locked closure into `aontu_meta/vendor/`.
 export function modVendor(root: string, options: ModToolOptions):
   ModVendorReport {
   const locked = readLock(root)
   const vendored: string[] = []
   const missing: string[] = []
 
-  const vendorRoot = pathJoin(root, 'aon_vendor')
+  const vendorRoot = pathJoin(root, 'aontu_meta', 'vendor')
 
   for (const mod of Object.keys(locked).sort()) {
     const ref = usableRef(mod)
@@ -593,13 +594,13 @@ function majorOf(version: string): string {
 
 
 // Every file of a module's source tree, relative and forward-slashed.
-// `aon_vendor/` is excluded: a published module carries its own
+// `aontu_meta/vendor/` is excluded: a published module carries its own
 // sources, not a copy of everyone else's -- a consumer resolves the
 // closure itself, and a nested vendor tree would publish the world.
 function layerFiles(dir: string, prefix = ''): string[] {
   const out: string[] = []
   for (const name of readdirSync(dir).sort()) {
-    if ('aon_vendor' === name) {
+    if ('aontu_meta' === name) {
       continue
     }
     const full = pathJoin(dir, name)

package/src/mod.ts

@@ -12,7 +12,7 @@
 //   local:   @"./fragment.aon"        <- unchanged, not a module
 //
 // EVALUATION NEVER TOUCHES THE NETWORK. Resolution reads local stores
-// only: `aon_vendor/` beside the project's `mod.aon`, then a
+// only: `aontu_meta/vendor/` beside the project's `mod.aon`, then a
 // content-addressed user cache keyed by canon-hash. Fetching is a
 // separate, explicit tool step, and a module that is in neither store
 // is an evaluation error that says so.
@@ -81,7 +81,7 @@ export function parseModuleRef(spec: string): ModuleRef | undefined {
 // `[A-Za-z0-9._-]` admits `..`, and `moduleDir` joins elements with
 // pathJoin, which CLEANS `..` rather than refusing it:
 //
-//   moduleDir('/store/aon_vendor', 'corp.example/../../etc/passwd@1')
+//   moduleDir('/store/aontu_meta/vendor', 'corp.example/../../etc/passwd@1')
 //     -> /store/etc/passwd@1
 //
 // `mod vendor` then copied a tree THERE, outside the project entirely,
@@ -168,9 +168,9 @@ export function moduleDir(store: string, ref: ModuleRef): string {
 // root being a directory holding a `mod.aon`. This used to answer with
 // the NEAREST one alone, and the plural is the fix, because a
 // VENDORED MODULE IS A PROJECT INSIDE A PROJECT. A module in
-// `aon_vendor/` carries its own `mod.aon`, which stopped the upward
+// `aontu_meta/vendor/` carries its own `mod.aon`, which stopped the upward
 // walk there, so a nested import resolved against the vendored
-// module's own directory: a tree with no `aon_vendor/` of its own, and
+// module's own directory: a tree with no `aontu_meta/vendor/` of its own, and
 // therefore a `module not fetched` for a dependency sitting flat
 // beside it in the CONSUMER's vendor tree — the only layout `mod
 // vendor` produces (use-cases/BUGS.md §31).
@@ -272,7 +272,7 @@ export function modCacheDirFor(
 
 export function lockHash(root: string, ref: ModuleRef, fs: ModuleFs):
   string | undefined {
-  const file = pathJoin(root, 'mod-lock.aon')
+  const file = pathJoin(root, 'aontu_meta', 'mod-lock.aon')
   if (!fs.existsSync(file)) {
     return undefined
   }
@@ -392,7 +392,7 @@ export function resolveModule(
     roots.map((r) => lockHash(r, ref, fs)).find((h) => null != h)
 
   const stores: string[] =
-    roots.map((r) => moduleDir(pathJoin(r, 'aon_vendor'), ref))
+    roots.map((r) => moduleDir(pathJoin(r, 'aontu_meta', 'vendor'), ref))
   if (null != options.cache && null != expect) {
     // Content-addressed: the cache is keyed by the hash, so a cache hit
     // is already the right MEANING before anything is read from it.

package/src/sigdecl.ts

@@ -6,6 +6,6 @@
 // this copy is identical with the shared file.
 
 const SIGDECL: string =
-"# The call surface: one declaration line per built-in function\n# (docs/design/SIGNATURES.0.md). THIS FILE IS THE SOURCE — both ports\n# carry a build-time-inlined copy (ts/src/sigdecl.ts, go/sigdecl.txt;\n# `make sig` regenerates both, and each port's suite asserts its copy\n# is byte-identical with this file) and parse it at initialisation\n# with the signature grammar, a tabnas grammar (ts/src/sig.ts,\n# go/sig.go). The suites also round-trip every line:\n# render(parse(line)) must be the line exactly, in both ports.\n#\n# The syntax (rendered TypeScript-ish, honest about argument MODES):\n#   line = name '(' [ arg {',' arg} ] ')' ':' type\n#   arg  = [mode] name ['?'] ':' type\n#        | '...' name ':' '(' [mode] type {',' [mode] type} ')'\n#   type = word {'|' word}\n#   mode = 'capture' | 'template' | 'trial' | 'projector' | 'text'\n# `value` mode is unmarked. `constraint` is the result word for\n# residuals whose meet depends on the peer; `any` is the honest type\n# where a function is a wrapper.\nupper(s: string|number) : string\nlower(s: string|number) : string\ncopy(v: any) : any\npref(v: any) : any\nsuper(t: any) : any\ntype(t: any) : any\nhide(v: any) : any\nclose(m: any) : any\nopen(m: any) : any\nmove(v: any) : any\npath(capture p?: path) : path\nmap() : map\nlist() : list\nmin(n: number|string) : constraint\nmax(n: number|string) : constraint\nabove(n: number|string) : constraint\nbelow(n: number|string) : constraint\nre(text p: string) : constraint\nlength(n: number|constraint) : constraint\nkey(up?: integer|biginteger) : string\nunique(projector k?: string) : constraint\nneq(...vals: number|string) : constraint\nmust(trial c: any, text msg: string) : constraint\ndeprecate(v: any, r?: map) : any\nacyclic() : constraint\ninverse(projector k: string) : constraint\nrefer(template t?: any) : constraint\nrel(template t?: any) : constraint\npack(d: map|list, template t: any) : map\neach(d: map|list, template t?: any) : list\nfilter(d: map|list, trial c: any) : map|list\nmatch(s: any, ...pr: (trial any, any), dflt?: any) : any\nadd(a: number, b: number) : number\nsub(a: number, b: number) : number\nmul(a: number, b: number) : number\ndiv(a: number, b: number) : number\nmod(a: number, b: number) : number\nrem(a: number, b: number) : number\nsum(d: map|list) : number\nleast(d: map|list) : number\ngreatest(d: map|list) : number\npick(d: map|list, projector k: string|integer) : any\njoin(d: map|list, sep?: string) : string\n"
+"# The call surface: one declaration line per built-in function\n# (docs/design/SIGNATURES.0.md). THIS FILE IS THE SOURCE — both ports\n# carry a build-time-inlined copy (ts/src/sigdecl.ts, go/sigdecl.txt;\n# `make sig` regenerates both, and each port's suite asserts its copy\n# is byte-identical with this file) and parse it at initialisation\n# with the signature grammar, a tabnas grammar (ts/src/sig.ts,\n# go/sig.go). The suites also round-trip every line:\n# render(parse(line)) must be the line exactly, in both ports.\n#\n# The syntax (rendered TypeScript-ish, honest about argument MODES):\n#   line = name '(' [ arg {',' arg} ] ')' ':' type\n#   arg  = [mode] name ['?'] ':' type\n#        | '...' name ':' '(' [mode] type {',' [mode] type} ')'\n#   type = word {'|' word}\n#   mode = 'capture' | 'template' | 'trial' | 'projector' | 'text'\n# `value` mode is unmarked. `constraint` is the result word for\n# residuals whose meet depends on the peer; `any` is the honest type\n# where a function is a wrapper.\nupper(s: string|number) : string\nlower(s: string|number) : string\ncopy(v: any) : any\npref(v: any) : any\nsuper(t: any) : any\ntype(t: any) : any\nhide(v: any) : any\nclose(m: any) : any\nopen(m: any) : any\nmove(v: any) : any\npath(capture p?: path) : path\nmap() : map\nlist() : list\nmin(n: number|string) : constraint\nmax(n: number|string) : constraint\nabove(n: number|string) : constraint\nbelow(n: number|string) : constraint\nre(text p: string) : constraint\nlength(n: number|constraint) : constraint\nkey(up?: integer|biginteger) : string\nunique(projector k?: string) : constraint\nneq(...vals: number|string) : constraint\nmust(trial c: any, text msg: string) : constraint\ndeprecate(v: any, r?: map) : any\nacyclic() : constraint\ninverse(projector k: string) : constraint\nrefer(template t?: any) : constraint\nrel(template t?: any) : constraint\npack(d: map|list, template t: any) : map\neach(d: map|list, template t?: any) : list\nfilter(d: map|list, trial c: any) : map|list\nmatch(s: any, ...pr: (trial any, any), dflt?: any) : any\nadd(a: number, b: number) : number\nsub(a: number, b: number) : number\nmul(a: number, b: number) : number\ndiv(a: number, b: number) : number\nmod(a: number, b: number) : number\nrem(a: number, b: number) : number\nsum(d: map|list) : number\nleast(d: map|list) : number\ngreatest(d: map|list) : number\npick(d: map|list, projector k: string|integer) : any\njoin(d: map|list, sep?: string) : string\nesc(s: string, variant?: string) : string\nusc(s: string, variant?: string) : string\nrep(s: string, text p: string, text sub: string) : string\nsplit(s: string, sep: string|constraint) : list\nemit(s: map|list, template t: map|list) : list\n"
 
 export { SIGDECL }

package/src/val/EachFuncVal.ts

@@ -86,9 +86,7 @@ class EachFuncVal extends FuncBaseVal {
     // ONE argument is driven: the data. The template is not (see
     // prepare above), and driveStagedArgs answers whether the data has
     // settled -- the other half of "ready to fire".
-    const ready = this.driveStagedArgs(ctx, 1)
-
-    if (!ready || !ctx.settle) {
+    if (!this.stagedReady(peer, ctx, 1)) {
       return this.residuate(peer, ctx)
     }