aontu 0.60.0 → 0.62.0

package/src/lang.ts

@@ -142,8 +142,10 @@ import { DeprecateFuncVal } from './val/DeprecateFuncVal'
 import { ReferFuncVal, RelFuncVal } from './val/ReferFuncVal'
 import { AcyclicFuncVal, InverseFuncVal } from './val/GraphAtomVal'
 import { PackFuncVal } from './val/PackFuncVal'
+import { CMP_FUNCS } from './val/CmpFuncVal'
+import { NomFuncVal } from './val/NomFuncVal'
+import { TranslateFuncVal } from './val/TranslateFuncVal'
 import { EachFuncVal } from './val/EachFuncVal'
-import { FormFuncVal } from './val/FormFuncVal'
 import { FilterFuncVal } from './val/FilterFuncVal'
 import { MatchFuncVal } from './val/MatchFuncVal'
 import { EmitFuncVal } from './val/EmitFuncVal'
@@ -915,21 +917,24 @@ help isolate the syntax error.`,
     acyclic: AcyclicFuncVal,
     inverse: InverseFuncVal,
 
-    // G8 phase 1: the generation combinators. `pack` makes one keyed
-    // child per child of its data, `each` one list element; both clone
-    // their template per destination exactly as a spread does, and both
-    // wait for the model to settle before they fire (the staging rule,
-    // G8 phase 0).
+    // G8 phase 1: generation to KEYED CHILDREN. `pack` makes one keyed
+    // child per child of its data, cloning its template per
+    // destination exactly as a spread does, and waits for the model to
+    // settle before it fires (the staging rule, G8 phase 0).
     pack: PackFuncVal,
-    each: EachFuncVal,
 
-    // RENDER P6: the order-preserving map. `form` makes one list
-    // element per child of its data, being the template with `_`
-    // bound to the source child -- a construction, where `each` is a
-    // bound (G9 §4). It exists because `pick(pack(...))` re-sorts to
-    // code-point order, and a struct's fields or a file's imports
-    // are the model's order or they are wrong.
-    form: FormFuncVal,
+    // RENDER P6: the order-preserving map, and generation to a LIST.
+    // `each` makes one list element per child of its data, being the
+    // template with `_` bound to the source child. It exists because
+    // `pick(pack(...))` re-sorts to code-point order, and a struct's
+    // fields or a file's imports are the model's order or they are
+    // wrong.
+    //
+    // Mentioning the hole makes it a BOUND instead: `each(d, _ & t)`
+    // meets each child with `t`, and `each(d, _)` is a bag's members
+    // as a list. That is what the retired meet-only `each` spelled
+    // (ADR-026), and why this one could take the name (ADR-027).
+    each: EachFuncVal,
 
     // G8 phase 2: selection. `filter` keeps the children of a bag that
     // unify with a condition; `match` picks the first arm whose
@@ -962,7 +967,8 @@ help isolate the syntax error.`,
 
     // Projection, which is what lets the aggregates reach a bag of
     // RECORDS: `sum(pick($.lines, amountCents))`. Not a clever `each`
-    // template -- `each` MEETS each child, and a meet cannot select.
+    // template -- `each(d, _ & t)` MEETS each child, and a meet cannot
+    // select.
     pick: PickFuncVal,
 
     // G9 phase 2: the fold to a STRING. `sum` folds with `add`; this
@@ -989,6 +995,39 @@ help isolate the syntax error.`,
     usc: UscFuncVal,
     rep: RepFuncVal,
     split: SplitFuncVal,
+
+    // THE COMPONENT PRIMITIVES -- SPIKE (ts/src/val/CmpFuncVal.ts,
+    // docs/design/JOSTRACA.0.md). jostraca's component set, spelled
+    // as functions -- LOWER CASE, like every other builtin in this
+    // language, while the node each one builds names the jostraca
+    // component it drives (`file(...)` is aontu, `"File"` is
+    // jostraca's). A document then says what FILES it produces
+    // instead of filling in the `aontu:code` vocabulary as data.
+    // Eight of jostraca's ten: `copy` and `list` are already builtins
+    // here with unrelated meanings, so those two have no lower-case
+    // spelling to take (see ts/src/val/CmpFuncVal.ts).
+    //
+    // TypeScript only, and so deliberately NOT in
+    // test/spec/signature.tsv, BUILTIN_FUNCS (ts/src/lsp.ts) or the
+    // grammar/ files -- each is asserted in cross-port parity and a
+    // TS-only entry turns the Go suite red. Arity and argument shape
+    // are refused in CmpFuncVal.resolve for the same reason.
+    ...CMP_FUNCS,
+
+    // NAME TRANSFORMATION -- SPIKE (ts/src/val/NamerFuncVal.ts).
+    // Generated code is mostly names, and no two targets spell them
+    // the same way. Splits a name into words whatever format it is
+    // written in, then renders it in the target's. TypeScript only,
+    // and out of the parity-pinned registries for the reason the
+    // component primitives are.
+    nom: NomFuncVal,
+
+    // PER-CHARACTER SUBSTITUTION AND DELETION -- SPIKE
+    // (ts/src/val/TranslateFuncVal.ts), after `tr`. Reads the source
+    // once and consults a table, which is what `rep` cannot do: a
+    // per-character map spelled as N `rep` calls composes wrongly,
+    // since each pass sees the previous one's output.
+    translate: TranslateFuncVal,
   }
 
 
@@ -2250,13 +2289,13 @@ function makeModelResolver(options: any) {
   // remain available under every capability but 'none' — they are
   // host-provided, not document-requested, so confining them would
   // confine the host against itself.
-  // THE BUNDLED VOCABULARY (G4 phase 4, ts/src/std.ts) rides the
-  // memory leg: served from the engine itself, so it needs neither the
-  // filesystem nor package resolution and is available under every
-  // capability but `none` — which denies every include outright, that
-  // being what `none` means. Host entries and the capability's own set
-  // WIN over it: a caller that supplies its own `std/system` gets the
-  // one it supplied.
+  // A LANGUAGE-SUPPLIED MODEL DOES NOT RIDE THIS LEG (ADR-028). Every
+  // bundled schema is named under `aontu:` and answered by the scheme
+  // leg above, which returns before the memory resolver is built, so
+  // neither a host entry nor a capability's own file set can stand in
+  // front of one: `aontu:system` is the engine's, always. That is what
+  // the prefix buys, and it is why the bare-name leg that once let a
+  // caller shadow `std/system` is gone.
   let memResolver = makeMemResolver(memCapability
     ? { ...(capability as any).mem }
     : { ...(options.resolver?.mem || {}) })
@@ -2426,10 +2465,14 @@ function makeModelResolver(options: any) {
     // else -- the memory, module, file and package legs are never
     // asked, so nothing on disk can shadow one and a typo is refused
     // here, naming the set, rather than searched for. Available under
-    // every capability but `none`, checked just above, like the std
-    // names below. A path that is not a string (`a: @1`) is not a name
-    // at all: it falls through to the legs below and is not found there,
-    // as it always was.
+    // every capability but `none`, checked just above. A path that is
+    // not a string (`a: @1`) is not a name at all: it falls through to
+    // the legs below and is not found there, as it always was.
+    //
+    // This is the ONLY leg that serves a bundled model (ADR-028). The
+    // vocabularies once had bare names (`std/system`) and a second leg
+    // below to match them; the prefix is now the whole spelling, so one
+    // leg answers for every language-supplied schema.
     if ('string' === typeof path && path.startsWith(AONTU_SCHEME)) {
       const model = STD_SOURCES[path]
       if (null == model) {
@@ -2439,19 +2482,6 @@ function makeModelResolver(options: any) {
       return { found: true, path, full: path, kind: 'aon', src: model, search: [] }
     }
 
-    // THE BUNDLED VOCABULARY (G4 phase 4, ts/src/std.ts): served from
-    // the engine itself, so it needs neither the filesystem nor package
-    // resolution and is available under every capability but `none` —
-    // checked just above, that being what `none` means. Matched against
-    // the name the author WROTE, before the memory leg, so the kind is
-    // stated rather than guessed from an extension the bare name does
-    // not have.
-    const std = STD_SOURCES[path]
-    if (null != std) {
-      record(ctx, path, 'std')
-      return { found: true, path, full: path, kind: 'aon', src: std, search: [] }
-    }
-
     let search: any = []
     let res = memResolver(path, popts, rule, ctx, jsonic)
     res.path = path
@@ -2581,10 +2611,27 @@ for (const name in funcSig) {
   }
 }
 
+// THE COMPONENT PRIMITIVES, listed by hand (the spike, see funcMap
+// above and ts/src/val/CmpFuncVal.ts). They carry no signature
+// declaration, so the derivation above cannot see them -- and
+// `file("main.ts", [...])` without an entry arrives as ONE raw array
+// term, which the call then reads as its spec. The leaves are here
+// too, so that a written second argument is COUNTED and refused as
+// the arity mistake it is rather than arriving as a one-element list
+// that is merely the wrong shape.
+for (const name of Object.keys(CMP_FUNCS)) {
+  POSITIONAL_ARG_FUNCS[name] = true
+}
+POSITIONAL_ARG_FUNCS['nom'] = true
+POSITIONAL_ARG_FUNCS['translate'] = true
+
 
-// [min, max]; a max of -1 is unbounded. Every name in funcMap has an
+// [min, max]; a max of -1 is unbounded. Every DECLARED name has an
 // entry, and the arity is a property of the language rather than of
-// either port -- go/func.go derives the same table. A required slot
+// either port -- go/func.go derives the same table. The spike's
+// component primitives are the one exception: they carry no
+// declaration, so they have no entry here and refuse a bad count in
+// their own resolve (ts/src/val/CmpFuncVal.ts). A required slot
 // counts toward the minimum; a rest slot makes the maximum unbounded
 // and counts its group size (one, for a plain rest type) toward the
 // minimum, which is what gives `match` its floor of three and `neq`
@@ -2646,7 +2693,16 @@ function arityText(lo: number, hi: number): string {
     return 'one or more arguments'
   }
   if (lo !== hi) {
-    return 0 === lo ? 'no arguments or one' : 'one argument or two'
+    if (0 === lo) {
+      return 'no arguments or one'
+    }
+    // The case range gave `upper` and `lower` a span rather than a
+    // pair, and a two-arm phrasing cannot say it: [1,3] read as "one
+    // argument or two", which is a wrong count rather than an
+    // imprecise one. Each arm here is a shape the table actually
+    // carries, and each is pinned by a row -- a phrasing for a count no
+    // entry has would be untested prose pretending to be tested.
+    return 3 === hi ? 'one to three arguments' : 'one argument or two'
   }
   // The {0,0} arm returned with the container kinds and acyclic()
   // (ADR-015): `map(1)` must not claim map takes exactly one.

package/src/lower.ts

@@ -103,19 +103,19 @@ export function splitWords(name: string): string[] {
   return words
 }
 
-function lowerASCII(s: string): string {
+export function lowerASCII(s: string): string {
   return Array.from(s).map((c) =>
     isUpper(c) ? String.fromCharCode(c.charCodeAt(0) + 32) : c).join('')
 }
 
-function upperASCII(s: string): string {
+export function upperASCII(s: string): string {
   return Array.from(s).map((c) =>
     isLower(c) ? String.fromCharCode(c.charCodeAt(0) - 32) : c).join('')
 }
 
 // A word capitalised: the acronym set wins, so `id` is `ID` under a
 // profile that lists it and `Id` under one that does not.
-function capitalise(word: string, acronyms: string[]): string {
+export function capitalise(word: string, acronyms: string[]): string {
   const low = lowerASCII(word)
   for (const a of acronyms) {
     if (lowerASCII(a) === low) {

package/src/lsp.ts

@@ -528,7 +528,7 @@ const COMPLETION_KEYWORD = 14
 const BUILTIN_FUNCS = [
   'above', 'acyclic', 'add', 'below', 'close', 'copy', 'deprecate', 'div',
   'each', 'emit', 'esc',
-  'filter', 'form', 'greatest',
+  'filter', 'greatest',
   'hide', 'inverse', 'join', 'key', 'least', 'length', 'list', 'lower',
   'map', 'match', 'max', 'min', 'mod', 'move', 'mul', 'must', 'neq', 'open',
   'pack', 'path', 'pick',

package/src/relation.ts

@@ -61,6 +61,12 @@ export type RelationReport = {
   // arrive with an empty list -- something is wrong, and nothing about
   // what. Present ONLY on an `error` verdict.
   errors?: VetFinding[]
+
+  // How many relation declarations the document makes (G11 phase 4).
+  // ZERO is the answer that matters: `pass` over no declarations means
+  // nothing was checked, and without this the two are one word.
+  // Absent unless the run asked for it (`RelationOptions.count`).
+  declared?: number
 }
 
 export type RelationOptions = {
@@ -76,6 +82,14 @@ export type RelationOptions = {
   // Rides beside `trust` because it is the other half of what an
   // include may read.
   textExt?: string[]
+
+  // Count the relation declarations the document makes (G11 phase 4),
+  // so a caller can tell a graph that CHECKED CLEAN from one there was
+  // nothing to check. `pass` is the same word for both, which is the
+  // whole reason this exists. Absent from the report unless asked for,
+  // so no existing caller's report changes shape -- `vet --coverage`
+  // sets the precedent.
+  count?: boolean
 }
 
 
@@ -271,8 +285,13 @@ export function relationCheck(
   }
 
   const decls: Map<string, RelDecl> = (ctx as any)._reldecls
+  // The count rides every report from here down: the engine knows it
+  // at exactly this point, and a caller asking "was there anything to
+  // check?" should not have to evaluate the document a second time to
+  // find out.
+  const counted = true === options.count ? { declared: decls.size } : {}
   if (0 === decls.size) {
-    return { verdict: 'pass', findings: [] }
+    return { verdict: 'pass', findings: [], ...counted }
   }
 
   // NOR IS A DOCUMENT THAT CANNOT BE GENERATED. Unification can
@@ -299,5 +318,6 @@ export function relationCheck(
   return {
     verdict: 0 === findings.length ? 'pass' : 'fail',
     findings,
+    ...counted,
   }
 }

package/src/render.ts

@@ -209,12 +209,13 @@ export function render(src: string, options?: RenderOptions): RenderReport {
     return errorReport(report.findings)
   }
 
-  // The meet, keyed: the vocabulary's root holds `code`, and so does
-  // the instance's (a value the vet admitted is a map), and a document
-  // with no `code` at all is the vocabulary's own empty instance.
-  const codeVal: any = node.peg.code
+  // The meet, keyed: the vocabulary's root holds `aontu.Code`, and so
+  // does the instance's (a value the vet admitted is a map), and a
+  // document with no `code` at all is the vocabulary's own empty
+  // instance. The key is namespaced (ADR-029), so the reach is two deep.
+  const codeVal: any = node.peg.aontu?.peg?.Code
   const instance = new Aontu().generate(
-    VOCABULARY + (undefined === codeVal ? '' : '\ncode: ' + hcanon(codeVal)))
+    VOCABULARY + (undefined === codeVal ? '' : '\naontu: Code: ' + hcanon(codeVal)))
   const folded = renderValue(instance, opts)
 
   // THE TWO REPORTS ARE JOINED TO THE FOLD BY PATH (P7), which is what
@@ -314,7 +315,7 @@ function traceOf(marks: { path: string, mark: any }[], instance: any,
   const pre: { at: string, path: string }[] = []
   unitList(instance).forEach((u: any, i: number) => {
     if (units.some((r) => r.path === u.path)) {
-      pre.push({ at: '$.code.units.' + i, path: u.path })
+      pre.push({ at: '$.aontu.Code.units.' + i, path: u.path })
     }
   })
   const out: RenderTrace[] = []
@@ -361,16 +362,18 @@ function covered(set: Set<string>, a: string): boolean {
 // ROOT, or under `coverageAt` when a document keeps its model under one
 // key (X-3, decided here): the read set is absolute, so a narrower
 // measure is a narrower walk, not a different origin. The render's own
-// output -- `code` under the anchor -- is not model and is never
-// walked into: nothing reads it, so every document would otherwise
-// report it dead.
+// output -- the `aontu` namespace under the anchor -- is not model and
+// is never walked into: nothing reads it, so every document would
+// otherwise report it dead. The whole NAMESPACE is excluded, not just
+// `aontu.Code` (ADR-029): everything under it is language-supplied, so
+// an included vocabulary is not dead model either.
 function coverOf(root: any, node: any, reads: Set<string>,
   opts: RenderOptions, marks: { path: string, mark: any }[], instance: any,
   units: RenderUnit[]): RenderCoverage | undefined {
-  // THE ANCHOR IS THE ONE render() ALREADY FOUND, so `code` under it is
-  // named without asking a second time: `--at` is resolved before the
-  // vet, and an anchor that named nothing never reached here.
-  const codeAddr = addr(node.path.concat('code'))
+  // THE ANCHOR IS THE ONE render() ALREADY FOUND, so the namespace
+  // under it is named without asking a second time: `--at` is resolved
+  // before the vet, and an anchor that named nothing never reached here.
+  const codeAddr = addr(node.path.concat('aontu'))
 
   let from: any = root
   let base: string[] = []
@@ -428,7 +431,7 @@ function coverOf(root: any, node: any, reads: Set<string>,
     }
     const decls: any[] = unit.decls
     decls.forEach((_d: any, j: number) => {
-      const a = '$.code.units.' + i + '.decls.' + j
+      const a = '$.aontu.Code.units.' + i + '.decls.' + j
       if (!covered(stamped, a) && !inside.has(a)) {
         unruled.push({ unit: unit.path, path: a })
       }
@@ -450,7 +453,7 @@ function bundledProfile(lang: string): any {
     return undefined
   }
   if (undefined === bundled[lang]) {
-    bundled[lang] = new Aontu().generate('@"aontu:lang/' + lang + '"').profile
+    bundled[lang] = new Aontu().generate('@"aontu:lang/' + lang + '"').aontu.Profile
   }
   return bundled[lang]
 }
@@ -571,8 +574,9 @@ export function renderProfile(src: string, options?: RenderOptions):
   // The meet, keyed as render's is: the vocabulary requires `profile`,
   // so a value the vet admitted has one.
   const instance = new Aontu().generate(
-    PROFILE_VOCABULARY + '\nprofile: ' + hcanon(root.peg.profile))
-  return { profile: instance.profile }
+    PROFILE_VOCABULARY + '\naontu: Profile: ' +
+    hcanon(root.peg.aontu.peg.Profile))
+  return { profile: instance.aontu.Profile }
 }
 
 
@@ -580,7 +584,8 @@ export function renderProfile(src: string, options?: RenderOptions):
 // key and is always there, `units` is not. One reader, so the fold,
 // the trace and the coverage report all see the same list.
 function unitList(instance: any): any[] {
-  return Array.isArray(instance?.code?.units) ? instance.code.units : []
+  return Array.isArray(instance?.aontu?.Code?.units) ?
+    instance.aontu.Code.units : []
 }
 
 
@@ -598,7 +603,7 @@ export function renderValue(instance: any, options?: RenderOptions): RenderRepor
   const seen: string[] = []
   let selected = 0
   list.forEach((unit: any, i: number) => {
-    const upath = '$.code.units.' + i
+    const upath = '$.aontu.Code.units.' + i
     const path: string = unit.path
     const lang: string = unit.lang
 
@@ -648,7 +653,7 @@ export function renderValue(instance: any, options?: RenderOptions): RenderRepor
 
     let text = ''
     if (undefined !== ctx) {
-      const header = lowerHeader(unit, instance?.code?.source, ctx)
+      const header = lowerHeader(unit, instance?.aontu?.Code?.source, ctx)
       for (const piece of header) {
         text += foldPiece(piece, profile, path, upath, lossy, ctx)
       }
@@ -702,7 +707,7 @@ export function renderValue(instance: any, options?: RenderOptions): RenderRepor
   })
 
   if (undefined !== opts.unit && 0 === selected) {
-    errors.push(finding('render_unit', 'reference', '$.code.units',
+    errors.push(finding('render_unit', 'reference', '$.aontu.Code.units',
       'no unit has the path ' + opts.unit + '.'))
   }
 

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\nform(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"
+"# 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, start?: integer|biginteger, len?: integer|biginteger) : string\nlower(s: string|number, start?: integer|biginteger, len?: integer|biginteger) : 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 }