aontu 0.63.0 → 0.65.0

package/src/aontu.ts

@@ -29,13 +29,13 @@ export type {
 import { graphOf } from './graph'
 import { relationCheck, relationErrors } from './relation'
 import { view, viewSet, viewTree } from './view'
-import { render, renderValue, renderProfile } from './render'
+import { loadProfile } from './profile'
 import { desugarTemplate, resugarTemplate, markerFor } from './template'
 import { format, unifiedDiff } from './format'
 export type { LintFinding, FormatReport, FormatOptions } from './format'
 
 
-const VERSION = '0.63.0'
+const VERSION = '0.65.0'
 
 
 function genQuiet(val: any, aontu: Aontu): any {
@@ -387,12 +387,7 @@ export {
   viewSet,
   viewTree,
 
-  // G9 -- the renderer (docs/design/RENDER.0.md): evaluate, vet and
-  // fold an aontu:code instance into bytes, or the fold alone over
-  // generate() output.
-  render,
-  renderValue,
-  renderProfile,
+  loadProfile,
 
   desugarTemplate,
   resugarTemplate,

package/src/aontumodel.ts

@@ -8,23 +8,17 @@
 const AONTU_SCHEME = 'aontu:'
 
 const AONTU_SOURCES: Record<string, string> = {
-  "aontu:code": "# aontu:code --- THE OUTPUT VOCABULARY. A transform evaluates to an\n# instance of this schema and 'aontu render' turns it into bytes. The\n# root is not type()-marked because render reads the instance through\n# generate(). EXPERIMENTAL until the distribution layer can version it\n# by canon-hash.\n\n%name = string & re(\"^[A-Za-z_][A-Za-z0-9_]*$\") & length(min(1) & max(255))\n\n%text = close({ k:\"text\" lang:string & length(min(1)) text:string })\n\n%doc = close({\n  text: string\n  deprecated?: close({ msg?:string use?:string since?:string })\n})\n\n%check = close({ c:\"min\" n:number exclusive: *false|boolean })\n  | close({ c:\"max\" n:number exclusive: *false|boolean })\n  | close({ c:\"re\" p:string })\n  | close({ c:\"len\" min?:integer & min(0) max?:integer & min(0) })\n  | close({ c:\"unique\" key?:%name })\n  | close({ c:\"ne\" n: [&: string|number|boolean] })\n  | close({ c:\"must\" note:string })\n\n%prim = close({\n  k: \"prim\"\n  prim: \"string\"|\"int\"|\"bigint\"|\"float\"|\"decimal\"|\"bool\"|\"null\"|\"any\"\n})\n\n%ref = close({ k:\"ref\" name:%name unit?:string })\n%leaf = %prim|%ref|%text\n\n%type = %leaf\n  | close({ k:\"list\" n:%leaf })\n  | close({ k:\"map\" key:%leaf n:%leaf })\n  | close({ k:\"opt\" n:%leaf })\n  | close({ k:\"union\" n: [&: %leaf] })\n  | close({ k:\"lit\" n: [&: string|number|boolean|null] })\n\n%field = close({\n  name: %name\n  type: %type\n  optional: *false|boolean\n  doc?: %doc\n  default?: string|number|boolean|null\n  check?: [&: %check]\n  rel?: close({ to:string name?:string })\n  x?: {}\n})\n\n%member = close({ name:%name value?:string|number doc?:%doc x?: {} })\n\n%param = close({\n  name: %name\n  type: %type\n  default?: string|number|boolean|null\n  x?: {}\n})\n\n# THE FRAGMENT ALGEBRA. A line's inline pieces hold no terminator; a\n# blank is its terminators alone; a raw is the one piece that may carry\n# terminators, re-indented to its depth unless it says not to.\n%inline = string & re(\"^[^\\n\\r]*$\")|%ref\n%line = close({ k:\"line\" at: *0|integer & min(0) & max(64) n: [&: %inline] })\n%blank = close({ k:\"blank\" n: *1|integer & min(1) & max(16) })\n\n%raw = close({\n  k: \"raw\"\n  at: *0|integer & min(0) & max(64)\n  text: string\n  reindent: *true|boolean\n})\n\n%piece = %line|%blank|%raw|string & re(\"^[^\\n\\r]*$\")\n%frag = close({ k:\"frag\" n: [&: %piece] })\n%body = %frag|close({ k:\"abstract\" })\n\n%record = close({\n  k: \"record\"\n  name: %name\n  doc?: %doc\n  open: *false|boolean\n  fields: [&: %field]\n  entity?: string\n  check?: [&: %check]\n  x?: {}\n})\n\n%enum = close({ k:\"enum\" name:%name doc?:%doc members: [&: %member] x?: {} })\n\n%alias = close({\n  k: \"alias\"\n  name: %name\n  doc?: %doc\n  type: %type\n  check?: [&: %check]\n  x?: {}\n})\n\n%const = close({\n  k: \"const\"\n  name: %name\n  doc?: %doc\n  type?: %type\n  value: string|number|boolean|null\n  x?: {}\n})\n\n%func = close({\n  k: \"func\"\n  name: %name\n  doc?: %doc\n  params: [&: %param]\n  returns?: %type\n  body: %body\n  x?: {}\n})\n\n%decl = %record|%enum|%alias|%const|%func|%text|%frag\n\n%import = close({\n  from: string & length(min(1))\n  names?: [&: %name]\n  alias?: %name\n  x?: {}\n})\n\n%unit = close({\n  path: string & length(min(1))\n  lang: string & length(min(1))\n  pkg?: string\n  doc?: %doc\n  imports?: [&: %import]\n  decls: [&: %decl]\n  profile?: {}\n  x?: {}\n})\n\n%source = close({ path?:string hash?:string & re(\"^aon1-[A-Za-z0-9_-]+$\") })\n\naontu: Code: close({ source?:%source units: [&: %unit] })\n",
-  "aontu:render": "# aontu:render --- THE RENDER VOCABULARY. A profile is the data\n# 'aontu render' applies to a unit of one language, and only data: a\n# field belongs here if the renderer applies it without looking at the\n# shape of any node. The root is not type()-marked because a profile is\n# read through generate(). EXPERIMENTAL, versioned by canon-hash later.\n\n%name = string & re(\"^[A-Za-z_][A-Za-z0-9_]*$\")\n\n%case = \"as-is\"|\"camel\"|\"pascal\"|\"snake\"|\"screaming\"|\"kebab\"\n\n%comment = close({ open?:string prefix?:string close?:string })\n\n%form = close({\n  open: *\"\"|string\n  close: *\"\"|string\n  prec: *9|integer & min(0) & max(9)\n  childPrec: *0|integer & min(0) & max(9)\n})\n\n%profile = close({\n  lang: string & length(min(1))\n  lowering?: \"typescript\"|\"go\"\n  indent: close({\n    unit: *\" \"|string & length(min(1))\n    width: *2|integer & min(0) & max(16)\n  })\n  comment?: close({ line?:%comment block?:%comment doc?:%comment })\n  str?: close({\n    quote: *\"\\\"\"|string & length(min(1) & max(1))\n    escape: { &: string }\n  })\n  ident?: close({\n    chars: *\"ascii-word\"|\"ascii-word\"\n    reserved?: [&: string]\n    case?: close({\n      record?: %case\n      field?: %case\n      enum?: %case\n      member?: %case\n      const?: %case\n      func?: %case\n      param?: %case\n      alias?: %case\n    })\n    acronyms?: [&: %name]\n  })\n  types?: close({\n    prim?: { &: string }\n    list?: %form\n    map?: %form\n    opt?: %form\n    union?: %form\n    lit?: %form\n  })\n  template?: close({\n    marker: string & length(min(1))\n    close?: string & length(min(1))\n    ext?: [&: string & re(\"^[A-Za-z0-9_+-]+$\")]\n  })\n  banner?: string\n})\n\n# Profile names the schema; Lang is where one lands. type() so naming\n# the schema neither generates it nor asks a document to fill it.\naontu: render: { Profile:type(%profile) Lang:%profile }\n",
-  "aontu:render/lang/go": "# aontu:render/lang/go --- THE GO PROFILE. Indentation, comment forms, string\n# escapes, identifier case and type forms. Lowering a declaration to a\n# struct is code; what the renderer applies without looking at a node's\n# shape is here. EXPERIMENTAL until the distribution layer can version\n# it by canon-hash.\n\n@\"aontu:render\"\n\naontu: render: Lang: {\n  lang: \"go\"\n  lowering: \"go\"\n  indent: { unit:\"\\t\" width:1 }\n  comment: line: prefix: \"// \"\n  comment: block: { open:\"/*\" close:\"*/\" }\n  comment: doc: prefix: \"// \"\n  str: quote: \"\\\"\"\n  str: escape: {\n    \"7\": \"\\\\a\"\n    \"8\": \"\\\\b\"\n    \"9\": \"\\\\t\"\n    \"10\": \"\\\\n\"\n    \"11\": \"\\\\v\"\n    \"12\": \"\\\\f\"\n    \"13\": \"\\\\r\"\n    \"34\": \"\\\\\\\"\"\n    \"92\": \"\\\\\\\\\"\n  }\n  ident: {\n    chars: \"ascii-word\"\n    reserved: [\n      \"break\"\n      \"case\"\n      \"chan\"\n      \"const\"\n      \"continue\"\n      \"default\"\n      \"defer\"\n      \"else\"\n      \"fallthrough\"\n      \"for\"\n      \"func\"\n      \"go\"\n      \"goto\"\n      \"if\"\n      \"import\"\n      \"interface\"\n      \"map\"\n      \"package\"\n      \"range\"\n      \"return\"\n      \"select\"\n      \"struct\"\n      \"switch\"\n      \"type\"\n      \"var\"\n    ]\n    case: record: \"pascal\"\n    case: field: \"pascal\"\n    case: enum: \"pascal\"\n    case: member: \"pascal\"\n    case: const: \"pascal\"\n    case: func: \"pascal\"\n    case: param: \"camel\"\n    case: alias: \"pascal\"\n    acronyms: [\n      \"ACL\"\n      \"API\"\n      \"ASCII\"\n      \"CPU\"\n      \"CSS\"\n      \"DNS\"\n      \"EOF\"\n      \"GUID\"\n      \"HTML\"\n      \"HTTP\"\n      \"HTTPS\"\n      \"ID\"\n      \"IP\"\n      \"JSON\"\n      \"LHS\"\n      \"QPS\"\n      \"RAM\"\n      \"RHS\"\n      \"RPC\"\n      \"SLA\"\n      \"SMTP\"\n      \"SQL\"\n      \"SSH\"\n      \"TCP\"\n      \"TLS\"\n      \"TTL\"\n      \"UDP\"\n      \"UI\"\n      \"UID\"\n      \"UUID\"\n      \"URI\"\n      \"URL\"\n      \"UTF8\"\n      \"VM\"\n      \"XML\"\n      \"XMPP\"\n      \"XSRF\"\n      \"XSS\"\n    ]\n  }\n  types: prim: {\n    string: \"string\"\n    int: \"int64\"\n    bigint: \"string\"\n    float: \"float64\"\n    decimal: \"string\"\n    bool: \"bool\"\n    null: \"any\"\n    any: \"any\"\n  }\n  types: list: open: \"[]\"\n  types: map: open: \"map[\"\n  types: opt: open: \"*\"\n  banner: \"Code generated by aontu from {path}. DO NOT EDIT.\"\n}\n",
-  "aontu:render/lang/markdown": "# aontu:render/lang/markdown --- THE MARKDOWN PROFILE. No declarations to\n# lower, so this is the text profile plus markdown's own two: the HTML\n# comment form and the template marker its files carry. EXPERIMENTAL\n# until the distribution layer can version it by canon-hash.\n\n@\"aontu:render\"\n\naontu: render: Lang: lang: \"markdown\"\naontu: render: Lang: indent: { unit:\" \" width:2 }\naontu: render: Lang: comment: block: { open:\"<!--\" close:\"-->\" }\naontu: render: Lang: template: { marker:\"<!---\" ext: [\"md\" \"markdown\"] }\n",
-  "aontu:render/lang/text": "# aontu:render/lang/text --- THE TEXT PROFILE. Indentation and nothing else:\n# a fold over fragments applies nothing else. Every language without a\n# lowering renders under it. EXPERIMENTAL until the distribution layer\n# can version it by canon-hash.\n\n@\"aontu:render\"\n\naontu: render: Lang: { lang:\"text\" indent: { unit:\" \" width:2 } }\n",
-  "aontu:render/lang/typescript": "# aontu:render/lang/typescript --- THE TYPESCRIPT PROFILE. Indentation,\n# comment forms, string escapes, identifier case and type forms.\n# Lowering a declaration to an interface is code; what the renderer\n# applies without looking at a node's shape is here. EXPERIMENTAL until\n# the distribution layer can version it by canon-hash.\n\n@\"aontu:render\"\n\naontu: render: Lang: {\n  lang: \"typescript\"\n  lowering: \"typescript\"\n  indent: { unit:\" \" width:2 }\n  comment: line: prefix: \"// \"\n  comment: block: { open:\"/*\" prefix:\" * \" close:\" */\" }\n  comment: doc: { open:\"/**\" prefix:\" * \" close:\" */\" }\n  str: quote: \"\\\"\"\n  str: escape: {\n    \"8\": \"\\\\b\"\n    \"9\": \"\\\\t\"\n    \"10\": \"\\\\n\"\n    \"12\": \"\\\\f\"\n    \"13\": \"\\\\r\"\n    \"34\": \"\\\\\\\"\"\n    \"92\": \"\\\\\\\\\"\n  }\n  ident: {\n    chars: \"ascii-word\"\n    reserved: [\n      \"await\"\n      \"break\"\n      \"case\"\n      \"catch\"\n      \"class\"\n      \"const\"\n      \"continue\"\n      \"debugger\"\n      \"default\"\n      \"delete\"\n      \"do\"\n      \"else\"\n      \"enum\"\n      \"export\"\n      \"extends\"\n      \"false\"\n      \"finally\"\n      \"for\"\n      \"function\"\n      \"if\"\n      \"implements\"\n      \"import\"\n      \"in\"\n      \"instanceof\"\n      \"interface\"\n      \"let\"\n      \"new\"\n      \"null\"\n      \"package\"\n      \"private\"\n      \"protected\"\n      \"public\"\n      \"return\"\n      \"static\"\n      \"super\"\n      \"switch\"\n      \"this\"\n      \"throw\"\n      \"true\"\n      \"try\"\n      \"typeof\"\n      \"var\"\n      \"void\"\n      \"while\"\n      \"with\"\n      \"yield\"\n    ]\n    case: record: \"pascal\"\n    case: field: \"camel\"\n    case: enum: \"pascal\"\n    case: member: \"pascal\"\n    case: const: \"camel\"\n    case: func: \"camel\"\n    case: param: \"camel\"\n    case: alias: \"pascal\"\n    acronyms: []\n  }\n  types: prim: {\n    string: \"string\"\n    int: \"number\"\n    bigint: \"bigint\"\n    float: \"number\"\n    decimal: \"string\"\n    bool: \"boolean\"\n    null: \"null\"\n    any: \"unknown\"\n  }\n  types: list: { close:\"[]\" childPrec:2 }\n  types: map: { open:\"Record<\" close:\">\" }\n  types: opt: { close:\" | null\" prec:1 childPrec:2 }\n  types: union: { prec:1 childPrec:2 }\n  types: lit: prec: 1\n  banner: \"Code generated by aontu from {path}. DO NOT EDIT.\"\n}\n",
+  "aontu:lang/markdown": "# aontu:lang/markdown --- THE MARKDOWN PROFILE. The text profile plus\n# markdown's own two: the HTML comment form, and the template marker\n# its files carry.\n\n@\"aontu:profile\"\n\naontu: Lang: lang: \"markdown\"\naontu: Lang: indent: { unit:\" \" width:2 }\naontu: Lang: comment: block: { open:\"<!--\" close:\"-->\" }\naontu: Lang: template: { marker:\"<!---\" ext: [\"md\" \"markdown\"] }\n",
+  "aontu:lang/text": "# aontu:lang/text --- THE TEXT PROFILE. Indentation and nothing else.\n# Every language without one of its own is read under it.\n\n@\"aontu:profile\"\n\naontu: Lang: { lang:\"text\" indent: { unit:\" \" width:2 } }\n",
+  "aontu:profile": "# aontu:profile --- THE PROFILE VOCABULARY. A language declared as\n# data: its name, its indentation, its comment forms and the marker its\n# generators carry. `aontu template` and `aontu fmt` read one through\n# --profile. EXPERIMENTAL, versioned by canon-hash later.\n\n%comment = close({ open?:string prefix?:string close?:string })\n\n%profile = close({\n  lang: string & length(min(1))\n  indent: close({\n    unit: *\" \"|string & length(min(1))\n    width: *2|integer & min(0) & max(16)\n  })\n  comment?: close({ line?:%comment block?:%comment doc?:%comment })\n  template?: close({\n    marker: string & length(min(1))\n    close?: string & length(min(1))\n    ext?: [&: string & re(\"^[A-Za-z0-9_+-]+$\")]\n  })\n})\n\n# Profile names the schema; Lang is where one lands. type() so naming\n# the schema neither generates it nor asks a document to fill it.\naontu: { Profile:type(%profile) Lang:%profile }\n",
   "aontu:system": "# aontu:system --- the SYSTEM VOCABULARY. EXPERIMENTAL until the\n# distribution layer can version it by canon-hash.\n\naontu: System: {\n  Port: type({ direction: *in|out|inout protocol?:string })\n\n  Component: type({ ports?: { &: $.aontu.System.Port } })\n\n  # Written out rather than Component & { kind: service }: a reference\n  # to a type()-marked member does not survive the include.\n  Service: type({ kind:service ports?: { &: $.aontu.System.Port } })\n\n  # A grammar, not re(): the identifier shape is a quantified group\n  # holding a quantifier, which re() refuses. hide()n so a schema's\n  # grammar does not generate into the document it checks.\n  semverPreRelease: hide(\n    abnf(\n      `pre-release = pre-release-id *( \".\" pre-release-id )\npre-release-id = \"0\" [ *digit alnum-tail ]\n  / positive-digit *digit [ alnum-tail ] / alnum-tail\nalnum-tail = non-digit *id-char\nid-char = digit / non-digit\nnon-digit = letter / \"-\"\ndigit = \"0\" / positive-digit\npositive-digit = %x31-39\nletter = %x41-5A / %x61-7A\n`\n    )\n  )\n  semverBuild: hide(\n    abnf(\n      `build = build-id *( \".\" build-id )\nbuild-id = 1*id-char\nid-char = digit / non-digit\nnon-digit = letter / \"-\"\ndigit = \"0\" / positive-digit\npositive-digit = %x31-39\nletter = %x41-5A / %x61-7A\n`\n    )\n  )\n\n  # major minor patch pre-release build, tail defaulted.\n  Semver: type(\n    [\n      integer & min(0)\n      *0|(integer & min(0))\n      *0|(integer & min(0))\n      *\"\"|parse($.aontu.System.semverPreRelease)\n      *\"\"|parse($.aontu.System.semverBuild)\n    ] & length(5)\n  )\n}\n",
   "aontu:view": "# aontu:view --- the FIGURE VOCABULARY. EXPERIMENTAL until the\n# distribution layer can version it by canon-hash.\n\naontu: View: Figure: type({\n  kind: doc|lattice|tree|matrix|graph|layer|sets|layers\n    | ladder\n  out: string\n\n  # Every kind.\n  as?: text|mermaid|dot|er|svg\n  at?: string\n  maxRows?: integer & min(0)\n\n  # doc.\n  depth?: integer & min(0)\n\n  # tree, matrix, layer, graph.\n  relation?: string\n  relations?: [&: string]\n  roots?: [&: string]\n\n  # matrix.\n  order?: canon|partition\n  closure?: boolean\n\n  # graph, layer.\n  groupBy?: string\n  label?: string\n  layers?: [&: string]\n  edges?: upward|all|none\n\n  # sets, layers.\n  sets?: string\n  member?: string\n  universe?: string\n  minDegree?: integer & min(0)\n  maxCols?: integer & min(0)\n  minSize?: integer & min(0)\n})\n"
 }
 
 const AONTU_MODELS: string[] = [
-  "aontu:code",
-  "aontu:render",
-  "aontu:render/lang/go",
-  "aontu:render/lang/markdown",
-  "aontu:render/lang/text",
-  "aontu:render/lang/typescript",
+  "aontu:lang/markdown",
+  "aontu:lang/text",
+  "aontu:profile",
   "aontu:system",
   "aontu:view"
 ]

package/src/casing.ts

@@ -0,0 +1,95 @@
+/* Copyright (c) 2026 Richard Rodger, MIT License */
+
+
+function isUpper(c: string): boolean {
+  return 'A' <= c && c <= 'Z'
+}
+
+function isLower(c: string): boolean {
+  return 'a' <= c && c <= 'z'
+}
+
+function isDigit(c: string): boolean {
+  return '0' <= c && c <= '9'
+}
+
+function isASCII(c: string): boolean {
+  return (c.codePointAt(0) as number) < 0x80
+}
+
+export function splitWords(name: string): string[] {
+  const words: string[] = []
+  let cur = ''
+  const chars = Array.from(name)
+  for (let i = 0; i < chars.length; i++) {
+    const c = chars[i]
+    if ('_' === c || '-' === c || ' ' === c) {
+      if ('' !== cur) {
+        words.push(cur)
+      }
+      cur = ''
+      continue
+    }
+    if ('' !== cur) {
+      const prev = chars[i - 1]
+      const next = chars[i + 1]
+      const boundary = isASCII(c) && isASCII(prev) && (
+        (isUpper(c) && (isLower(prev) || isDigit(prev))) ||
+        (isDigit(c) !== isDigit(prev)) ||
+        (isUpper(c) && isUpper(prev) && undefined !== next && isLower(next)))
+      if (boundary) {
+        words.push(cur)
+        cur = ''
+      }
+    }
+    cur += c
+  }
+  if ('' !== cur) {
+    words.push(cur)
+  }
+  return words
+}
+
+export function lowerASCII(s: string): string {
+  return Array.from(s).map((c) =>
+    isUpper(c) ? String.fromCharCode(c.charCodeAt(0) + 32) : c).join('')
+}
+
+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.
+export function capitalise(word: string, acronyms: string[]): string {
+  const low = lowerASCII(word)
+  for (const a of acronyms) {
+    if (lowerASCII(a) === low) {
+      return a
+    }
+  }
+  const chars = Array.from(low)
+  return upperASCII(chars[0]) + chars.slice(1).join('')
+}
+
+// THE CASE STYLES, over the words. `nom` maps its own style names
+// onto these.
+export function caseName(name: string, style: string, acronyms: string[]): string {
+  const words = splitWords(name)
+  if ('snake' === style) {
+    return words.map(lowerASCII).join('_')
+  }
+  if ('screaming' === style) {
+    return words.map(upperASCII).join('_')
+  }
+  if ('kebab' === style) {
+    return words.map(lowerASCII).join('-')
+  }
+  const caps = words.map((w) => capitalise(w, acronyms))
+  if ('pascal' === style) {
+    return caps.join('')
+  }
+  // camel: the first word lower, and never an acronym.
+  return lowerASCII(words[0]) + caps.slice(1).join('')
+}