aontu 0.60.0 → 0.62.0

package/src/std.ts

@@ -1,19 +1,23 @@
 /* Copyright (c) 2025 Richard Rodger, MIT License */
 
-// THE BUNDLED VOCABULARY (G4 phase 4,
-// docs/capability-review/g4-identity-relations.md): `@"std/system"` is
-// served from the engine itself — no filesystem, no package resolution
-// — so a document may use it under every include capability except
-// `none`, and the hermeticity posture is not widened by a source that
-// never leaves the process.
+// THE LANGUAGE-SUPPLIED MODELS (G4 phase 4,
+// docs/capability-review/g4-identity-relations.md): `@"aontu:system"`
+// is served from the engine itself — no filesystem, no package
+// resolution — so a document may use it under every include capability
+// except `none`, and the hermeticity posture is not widened by a source
+// that never leaves the process.
+//
+// EVERY name here carries the `aontu:` prefix (ADR-028): a
+// language-supplied schema is spelled one way, and the scheme is what
+// makes it unshadowable. There is no second, bare-name spelling.
 //
 // The TEXT is the shared artifact: go/std.go carries the same bytes,
-// and test/spec/std-system.tsv pins its canon and its canon-hash in
+// and test/spec/aontu-system.tsv pins its canon and its canon-hash in
 // both engines, so the two copies cannot drift without a red suite.
 // It carries no backtick for that reason: one string literal per port,
 // and Go's raw string has no escape.
 
-const STD_SYSTEM = `# std/system --- the SYSTEM VOCABULARY (G4 phase 4). Ports, components
+const STD_SYSTEM = `# aontu:system --- the SYSTEM VOCABULARY (G4 phase 4). Ports, components
 # and relations need no syntax: they are schemas. Everything here is
 # ordinary unification --- conjunction, spreads, marks, defaults ---
 # so the vocabulary costs the language nothing, and an author who wants
@@ -24,31 +28,57 @@ const STD_SYSTEM = `# std/system --- the SYSTEM VOCABULARY (G4 phase 4). Ports,
 # identity and version makes "v1 and v2 describe the same entity"
 # inexpressible.
 
-std: {
-
+aontu: System: {
   # One end of a connection.
-  Port: type({
-    direction: *in | out | inout
-    protocol?: string
-  })
+  Port: type({ direction:*in | out | inout protocol?:string })
 
   # A node with ports. Where a Component sits in the tree is what it
   # is a component OF -- containment is the document's own structure
   # and needs no mark of its own.
-  Component: type({
-    ports?: {&: $.std.Port}
-  })
+  Component: type({ ports?:{ &: $.aontu.System.Port } })
 
   # A component that is a service. Written out rather than as
-  # $.std.Component & {kind: service}: a reference from one member of
+  # $.aontu.System.Component & {kind: service}: a reference from one member of
   # this file to another does not survive being INCLUDED into a
   # document (the marks the include carries make the referring member
   # unusable), so the vocabulary states each schema on its own.
-  Service: type({
-    kind: service
-    ports?: {&: $.std.Port}
-  })
-
+  Service: type({ kind:service ports?:{ &: $.aontu.System.Port } })
+
+  # A semantic version (semver.org 2.0.0) as an ORDERED TUPLE: major,
+  # minor, patch, pre-release. A list and not a dotted string, because a
+  # version is COMPARED and the comparison runs component by component
+  # from the left: "1.10.0" sorts below "1.9.0" as text. A list and not
+  # a map, because a map has no order of its own to compare along.
+  #
+  # THE TAIL DEFAULTS, so [1] is [1 0 0 ""] and [1 2] is [1 2 0 ""].
+  # A major-only version is the common case and should cost one token.
+  #
+  # LEADING ZEROES ARE IMPOSSIBLE HERE rather than merely forbidden:
+  # the numeric parts are integers, and 01 is not a distinct integer
+  # literal. The spec's "MUST NOT contain leading zeroes" needs no rule.
+  #
+  # THE PRE-RELEASE CHECK IS PARTIAL, and deliberately says so. The
+  # spec's grammar is dot-separated identifiers, each non-empty, each
+  # [0-9A-Za-z-], numeric ones without leading zeroes -- which as a
+  # regex is a quantified group containing a quantifier, and re()
+  # refuses that shape outright (constraint_pattern) because it
+  # backtracks exponentially. So the alphabet is checked and the
+  # STRUCTURE is not: "beta_1" is refused, "alpha..1" and "01" are not.
+  # Carrying the pre-release as a LIST of identifiers would check it in
+  # full, one identifier per element, and is the change to make if that
+  # matters more than [1 0 0 ""] does.
+  #
+  # BUILD METADATA IS NOT CARRIED. The spec has it, and the spec also
+  # says it MUST be ignored when determining precedence -- so a type
+  # whose purpose is comparison is the wrong place for it.
+  Semver: type(
+    [
+      integer & min(0)
+      *0 | (integer & min(0))
+      *0 | (integer & min(0))
+      *"" | (string & re("^[0-9A-Za-z.-]+$"))
+    ] & length(4)
+  )
   # (The Relation schema that used to sit here is retired with the
   # relations: magic key, RELATIONS.0.md P2: a relation is declared
   # by the graph atoms at its field -- rel(t) & acyclic() &
@@ -57,17 +87,17 @@ std: {
 `
 
 
-const STD_VIEW = `# std/view --- the FIGURE VOCABULARY (VIEWS.0.md, "6. The view
+const STD_VIEW = `# aontu:view --- the FIGURE VOCABULARY (VIEWS.0.md, "6. The view
 # document"). A view document declares its figures as data, and a
 # declaration is just a map: this is the schema for one, so a typo is
 # refused where every other mistake in an aontu document is refused --
 # at evaluation, by unification -- rather than by the verb that reads
 # it afterwards.
 #
-#   @"std/view"
+#   @"aontu:view"
 #   @"./system.aon"
 #
-#   views: {&: $.view.Figure} & {
+#   views: {&: $.aontu.View.Figure} & {
 #     arch: {kind: matrix, order: partition, out: "docs/arch.dsm.txt"}
 #   }
 #
@@ -81,8 +111,7 @@ const STD_VIEW = `# std/view --- the FIGURE VOCABULARY (VIEWS.0.md, "6. The view
 # canon-hash. This file carries no backtick: it is one string literal
 # per port, and Go raw strings have no escape.
 
-view: {
-
+aontu: View: {
   # One declared figure. The kind says what to draw and out says where
   # it belongs; everything else narrows the drawing, and each option
   # belongs to the kinds that read it.
@@ -186,6 +215,7 @@ const STD_CODE = String.raw`# aontu:code --- THE OUTPUT VOCABULARY. An aontu tra
   k: "prim"
   prim: "string" | "int" | "bigint" | "float" | "decimal" | "bool" | "null" | "any"
 })
+
 %ref = close({ k:"ref" name:%name unit?:string })
 %leaf = %prim | %ref | %text
 
@@ -208,6 +238,7 @@ const STD_CODE = String.raw`# aontu:code --- THE OUTPUT VOCABULARY. An aontu tra
 })
 
 %member = close({ name:%name value?:string | number doc?:%doc x?:{} })
+
 %param = close({
   name: %name
   type: %type
@@ -221,12 +252,14 @@ const STD_CODE = String.raw`# aontu:code --- THE OUTPUT VOCABULARY. An aontu tra
 %inline = string & re("^[^\n\r]*$") | %ref
 %line = close({ k:"line" at:*0 | integer & min(0) & max(64) of:[&: %inline] })
 %blank = close({ k:"blank" n:*1 | integer & min(1) & max(16) })
+
 %raw = close({
   k: "raw"
   at: *0 | integer & min(0) & max(64)
   text: string
   reindent: *true | boolean
 })
+
 %piece = %line | %blank | %raw | string & re("^[^\n\r]*$")
 %frag = close({ k:"frag" of:[&: %piece] })
 %body = %frag | close({ k:"abstract" })
@@ -241,7 +274,9 @@ const STD_CODE = String.raw`# aontu:code --- THE OUTPUT VOCABULARY. An aontu tra
   check?: [&: %check]
   x?: {}
 })
+
 %enum = close({ k:"enum" name:%name doc?:%doc members:[&: %member] x?:{} })
+
 %alias = close({
   k: "alias"
   name: %name
@@ -250,6 +285,7 @@ const STD_CODE = String.raw`# aontu:code --- THE OUTPUT VOCABULARY. An aontu tra
   check?: [&: %check]
   x?: {}
 })
+
 %const = close({
   k: "const"
   name: %name
@@ -258,6 +294,7 @@ const STD_CODE = String.raw`# aontu:code --- THE OUTPUT VOCABULARY. An aontu tra
   value: string | number | boolean | null
   x?: {}
 })
+
 %func = close({
   k: "func"
   name: %name
@@ -290,7 +327,7 @@ const STD_CODE = String.raw`# aontu:code --- THE OUTPUT VOCABULARY. An aontu tra
 
 %source = close({ path?:string hash?:string & re("^aon1-[A-Za-z0-9_-]+$") })
 
-code: close({ source?:%source units:[&: %unit] })
+aontu: Code: close({ source?:%source units:[&: %unit] })
 `
 
 
@@ -364,7 +401,7 @@ const STD_PROFILE = String.raw`# aontu:profile --- THE PROFILE VOCABULARY. A pro
   banner?: string
 })
 
-profile: %profile
+aontu: Profile: %profile
 `
 
 
@@ -381,7 +418,7 @@ const STD_LANG_TEXT = String.raw`# aontu:lang/text --- THE TEXT PROFILE. The pro
 
 @"aontu:profile"
 
-profile: { lang:"text" indent:{ unit:" " width:2 } }
+aontu: Profile: { lang:"text" indent:{ unit:" " width:2 } }
 `
 
 // THE TYPESCRIPT PROFILE (docs/design/RENDER.0.md D5, P5): the data the
@@ -402,7 +439,7 @@ const STD_LANG_TYPESCRIPT = String.raw`# aontu:lang/typescript --- THE TYPESCRIP
 
 @"aontu:profile"
 
-profile: {
+aontu: Profile: {
   lang: "typescript"
   lowering: "typescript"
   indent: { unit:" " width:2 }
@@ -410,13 +447,15 @@ profile: {
   comment: block: { open:"/*" prefix:" * " close:" */" }
   comment: doc: { open:"/**" prefix:" * " close:" */" }
   str: quote: "\""
-  str: escape: "8": "\\b"
-  str: escape: "9": "\\t"
-  str: escape: "10": "\\n"
-  str: escape: "12": "\\f"
-  str: escape: "13": "\\r"
-  str: escape: "34": "\\\""
-  str: escape: "92": "\\\\"
+  str: escape: {
+    "8": "\\b"
+    "9": "\\t"
+    "10": "\\n"
+    "12": "\\f"
+    "13": "\\r"
+    "34": "\\\""
+    "92": "\\\\"
+  }
   ident: {
     chars: "ascii-word"
     reserved: [
@@ -477,14 +516,16 @@ profile: {
     case: alias: "pascal"
     acronyms: []
   }
-  types: prim: string: "string"
-  types: prim: int: "number"
-  types: prim: bigint: "bigint"
-  types: prim: float: "number"
-  types: prim: decimal: "string"
-  types: prim: bool: "boolean"
-  types: prim: null: "null"
-  types: prim: any: "unknown"
+  types: prim: {
+    string: "string"
+    int: "number"
+    bigint: "bigint"
+    float: "number"
+    decimal: "string"
+    bool: "boolean"
+    null: "null"
+    any: "unknown"
+  }
   types: list: { close:"[]" childPrec:2 }
   types: map: { open:"Record<" close:">" }
   types: opt: { close:" | null" prec:1 childPrec:2 }
@@ -512,21 +553,23 @@ const STD_LANG_GO = String.raw`# aontu:lang/go --- THE GO PROFILE. The data a un
 
 @"aontu:profile"
 
-profile: {
+aontu: Profile: {
   lang: "go"
   lowering: "go"
   indent: { unit:"\t" width:1 }
   comment: { line:prefix:"// " block:{ open:"/*" close:"*/" } doc:prefix:"// " }
   str: quote: "\""
-  str: escape: "7": "\\a"
-  str: escape: "8": "\\b"
-  str: escape: "9": "\\t"
-  str: escape: "10": "\\n"
-  str: escape: "11": "\\v"
-  str: escape: "12": "\\f"
-  str: escape: "13": "\\r"
-  str: escape: "34": "\\\""
-  str: escape: "92": "\\\\"
+  str: escape: {
+    "7": "\\a"
+    "8": "\\b"
+    "9": "\\t"
+    "10": "\\n"
+    "11": "\\v"
+    "12": "\\f"
+    "13": "\\r"
+    "34": "\\\""
+    "92": "\\\\"
+  }
   ident: {
     chars: "ascii-word"
     reserved: [
@@ -605,14 +648,16 @@ profile: {
       "XSS"
     ]
   }
-  types: prim: string: "string"
-  types: prim: int: "int64"
-  types: prim: bigint: "string"
-  types: prim: float: "float64"
-  types: prim: decimal: "string"
-  types: prim: bool: "bool"
-  types: prim: null: "any"
-  types: prim: any: "any"
+  types: prim: {
+    string: "string"
+    int: "int64"
+    bigint: "string"
+    float: "float64"
+    decimal: "string"
+    bool: "bool"
+    null: "any"
+    any: "any"
+  }
   types: list: open: "[]"
   types: map: open: "map["
   types: opt: open: "*"
@@ -621,10 +666,8 @@ profile: {
 `
 
 export const STD_SOURCES: Record<string, string> = {
-  'std/system': STD_SYSTEM,
-  'std/system.aon': STD_SYSTEM,
-  'std/view': STD_VIEW,
-  'std/view.aon': STD_VIEW,
+  'aontu:system': STD_SYSTEM,
+  'aontu:view': STD_VIEW,
   'aontu:code': STD_CODE,
   'aontu:lang/go': STD_LANG_GO,
   'aontu:lang/text': STD_LANG_TEXT,

package/src/template.ts

@@ -24,12 +24,22 @@
 // comment, and derives for a language this table has never seen: the
 // caller passes the token.
 //
-// A MARKER IS RECOGNISED AFTER LEADING WHITESPACE AND KEEPS ITS OWN
-// INDENTATION (D2). That is what lets a template be written exactly
-// where its output appears (D7): a body line is verbatim, so a line
-// indented two spaces in the template is indented two spaces in the
-// generated file, and the marker lines around it are indented to match
-// the code they sit in rather than to the aontu they carry.
+// A MARKER IS RECOGNISED AFTER LEADING WHITESPACE, AND THE INDENTATION
+// THE RESUGARING WRITES IS THE AONTU'S (D2, amended 2026-09-07). An
+// output line is verbatim -- a line indented two spaces in the template
+// is indented two spaces in the generated file (D7) -- and that is the
+// half a reader of the TARGET needs. The other half is the document:
+// the marker lines carry a tree, and a tree nobody can see the shape of
+// is the one thing this surface took away. So the marker stands at the
+// left margin and the aontu is indented AFTER it, which `aontu fmt`
+// (FMT.0.md M-BM-'3.14) is what writes.
+//
+// Reading is unchanged and stays generous: a marker after leading
+// whitespace is a marker, and its own indentation still counts toward
+// the aontu it carries, so a template written the other way desugars to
+// the same document. What changes is the spelling the round trip
+// answers, and `template --check` names the difference as the drift it
+// is.
 //
 // THE SUGAR IS THE FIXPOINT OF THE TWO TRANSFORMS (D6), and that is
 // the whole of the resugaring's safety. A canonical line that looks
@@ -128,13 +138,19 @@ function indentOf(line: string): number {
 }
 
 
-// The line without its indentation or its trailing spaces and tabs.
-function trimLine(line: string): string {
+// The line without its trailing spaces and tabs.
+function trimEnd(line: string): string {
   let end = line.length
   while (0 < end && (' ' === line[end - 1] || '\t' === line[end - 1])) {
     end--
   }
-  return line.slice(indentOf(line), end)
+  return line.slice(0, end)
+}
+
+
+// The line without its indentation or its trailing spaces and tabs.
+function trimLine(line: string): string {
+  return trimEnd(line).slice(indentOf(line))
 }
 
 
@@ -159,12 +175,15 @@ function readLine(line: string, marker: string): Line {
   // The block form's closer is part of the marker, not of the aontu.
   // A block marker line that never closes is not a marker line: the
   // language's own parser would not read it as a comment either.
+  // Only the TRAILING space goes: what stands between the opener and
+  // the aontu is the aontu's indentation, exactly as it is for a line
+  // marker, and the one-space rule below takes the marker's own.
   if (isBlock(marker)) {
     const end = body.lastIndexOf(BLOCK_CLOSE)
     if (end < 0) {
       return { marker: false, indent: '', text: line }
     }
-    body = trimLine(body.slice(0, end))
+    body = trimEnd(body.slice(0, end))
   }
   // ONE SPACE AFTER THE MARKER IS THE MARKER'S, so `//- x: 1` carries
   // `x: 1` and the resugaring writes the space back. A marker written
@@ -273,19 +292,40 @@ function resugarTemplate(src: string, marker?: string): string {
     if (undefined !== target && desugarTemplate(target, mark) === trimLine(line)) {
       return target
     }
-    const cut = indentOf(line)
-    const text = line.slice(cut)
-    const open = line.slice(0, cut) + mark
+    // THE MARKER STANDS AT THE LEFT MARGIN and the line's indentation
+    // is written after it, so the aontu's own shape is on the page.
+    // The one space is the marker's, which the reading takes back.
+    const text = trimEnd(line)
     const close = isBlock(mark) ? ' ' + BLOCK_CLOSE : ''
-    return '' === text ? open + close : open + ' ' + text + close
+    return '' === text ? mark + close : mark + ' ' + text + close
   })
   return out.join('\n') + (tail ? '\n' : '')
-} /* node:coverage ignore next 8 */
+}
+
+
+// WHICH LINES OF THE DESUGARED DOCUMENT ARE THE TARGET'S. The
+// desugaring is line for line, so this is one flag per line of what
+// `desugarTemplate` returns: true where the template's line was not a
+// marker, and so where the document's line is one quoted line of the
+// generated file.
+//
+// `aontu fmt` reads it (FMT.0.md M-BM-'3.14) to hold those lines on lines of
+// their own. A body element is a string like any other, and the packing
+// budget would put three of them on one line -- which is aontu where
+// three lines of output were, and a generator that writes them as one.
+function templateOutputs(src: string, marker: string): boolean[] {
+  const lines = src.split('\n')
+  if (1 < lines.length && '' === lines[lines.length - 1]) {
+    lines.pop()
+  }
+  return lines.map((line) => !readLine(line, marker).marker)
+} /* node:coverage ignore next 9 */
 
 
 export {
   desugarTemplate,
   resugarTemplate,
+  templateOutputs,
   markerFor,
   DEFAULT_MARKER,
 }

package/src/val/AggFuncVal.ts

@@ -204,8 +204,8 @@ function unpref(v: any): any {
 //
 //   total: sum(pick($.lines, amountCents))
 //
-// IT IS NOT `each` WITH A CLEVER TEMPLATE. `each(d, t)` MEETS each
-// child with `t`, and a meet cannot select: `each($.lines, _.amount)`
+// IT IS NOT `each` WITH A CLEVER TEMPLATE. `each(d, _ & t)` MEETS each
+// child with `t`, and a meet cannot select: `each($.lines, _ & _.amount)`
 // asks for a child that is simultaneously the whole record and one of
 // its fields, which is why every spelling of it answers `no_path`.
 // Selection is a different operation and gets its own verb.