aontu 0.61.0 → 0.63.0

package/src/allow.ts

@@ -0,0 +1,221 @@
+/* Copyright (c) 2025 Richard Rodger, MIT License */
+
+
+import { Aontu } from './aontu'
+import { ConjunctVal } from './val/ConjunctVal'
+import { anchorAt } from './vet'
+import type { VetFinding } from './vet'
+import { evalFailure, nearestKey, pathParts } from './query'
+import { includeOpts } from './utility'
+import type { IncludeOptions } from './utility'
+
+
+// Where the roles map lives when the caller does not say.
+export const ALLOW_AT = '$.roles'
+
+
+export type AllowVerdict = 'allowed' | 'refused' | 'error'
+
+
+// What decided one path: the entry that covers it, the entry that
+// intersects it, nothing at all, or a role the model does not declare.
+export type AllowReason = 'allow' | 'deny' | 'uncovered' | 'no_role'
+
+
+export type AllowDecision = {
+  path: string
+  allowed: boolean
+  reason: AllowReason
+  by?: string           // the deciding entry's path in the role model
+  pattern?: string      // that entry's text, as the author wrote it
+}
+
+
+export type AllowReport = {
+  verdict: AllowVerdict
+  role: string
+  paths: AllowDecision[]
+  findings: VetFinding[]
+}
+
+
+export type AllowOptions = IncludeOptions & {
+  // Where the role model came from: relative loads resolve against
+  // its directory, and a finding's site names it.
+  path?: string
+  // The path of the roles map inside the model (default `$.roles`).
+  at?: string
+}
+
+
+const ENTRY = 'string & re("^[$]") & re("[^.]$")'
+
+// The shape every role must satisfy, in the language: a list of
+// subtree entries to allow, and optionally one to deny.
+const ROLE_SHAPE = `{ allow: [&: ${ENTRY}] deny?: [&: ${ENTRY}] }`
+
+
+function shapeSource(at: string): string {
+  const keys = pathParts(at).map((p) => JSON.stringify(p))
+  return 0 === keys.length
+    ? '&: ' + ROLE_SHAPE
+    : keys.join(': ') + ': { &: ' + ROLE_SHAPE + ' }'
+}
+
+
+// `$.a.b` for a segment list, `$` for none: the spelling every report
+// uses for a path, whatever the caller wrote.
+function pathText(parts: string[]): string {
+  return '$' + (0 < parts.length ? '.' + parts.join('.') : '')
+}
+
+
+function finding(
+  code: string, path: string, message: string, note?: string): VetFinding {
+  return {
+    code,
+    class: 'reference',
+    severity: 'error',
+    path,
+    message,
+    sites: [],
+    ...(null == note ? {} : { note }),
+  }
+}
+
+
+type Entry = {
+  parts: string[]
+  text: string
+  by: string
+}
+
+
+function readEntries(
+  list: any, by: string, ctx: any,
+): { entries: Entry[], finding?: VetFinding } {
+  const entries: Entry[] = []
+  for (let i = 0; i < list.peg.length; i++) {
+    const el: any = list.peg[i]
+    const before = ctx.err.length
+    const text: string = true === el.isString ? el.peg : el.gen(ctx)
+    if (before < ctx.err.length) {
+      const err: any = ctx.err[before]
+      return { entries, finding: finding(err.why, `${by}.${i}`, err.msg) }
+    }
+    entries.push({ parts: pathParts(text), text, by: `${by}.${i}` })
+  }
+  return { entries }
+}
+
+
+// One segment of an entry against one segment of a path: `*` matches
+// any key, anything else matches itself.
+function segmentMatches(pattern: string, segment: string): boolean {
+  return '*' === pattern || pattern === segment
+}
+
+
+function intersects(entry: string[], path: string[]): boolean {
+  const n = Math.min(entry.length, path.length)
+  for (let i = 0; i < n; i++) {
+    if (!segmentMatches(entry[i], path[i])) {
+      return false
+    }
+  }
+  return true
+}
+
+
+function covers(entry: string[], path: string[]): boolean {
+  return entry.length <= path.length && intersects(entry, path)
+}
+
+
+function decide(asked: string, allows: Entry[], denies: Entry[]): AllowDecision {
+  const parts = pathParts(asked)
+  const path = pathText(parts)
+
+  for (const d of denies) {
+    if (intersects(d.parts, parts)) {
+      return { path, allowed: false, reason: 'deny', by: d.by, pattern: d.text }
+    }
+  }
+  for (const a of allows) {
+    if (covers(a.parts, parts)) {
+      return { path, allowed: true, reason: 'allow', by: a.by, pattern: a.text }
+    }
+  }
+  return { path, allowed: false, reason: 'uncovered' }
+}
+
+
+function errorReport(role: string, f: VetFinding): AllowReport {
+  return { verdict: 'error', role, paths: [], findings: [f] }
+}
+
+
+// Evaluate the role model, select the role, and decide every path.
+export function allow(
+  src: string, role: string, paths: string[], opts?: AllowOptions,
+): AllowReport {
+  const options = opts ?? {}
+  const at = pathText(pathParts(options.at ?? ALLOW_AT))
+
+  const aontu = new Aontu(includeOpts(options))
+  const ctx = aontu.ctx({ collect: true })
+  const parseOpts = null == options.path ? undefined : { path: options.path }
+
+  const shape = aontu.parse(shapeSource(at), undefined, ctx)
+  const model = aontu.parse(src, parseOpts, ctx)
+  if (0 < ctx.err.length) {
+    return errorReport(role, evalFailure(ctx))
+  }
+  const root: any = aontu.unify(
+    new ConjunctVal({ peg: [model, shape] }, ctx), undefined, ctx)
+  if (0 < ctx.err.length || true === root.isNil) {
+    return errorReport(role, evalFailure(ctx))
+  }
+
+  const roles: any = anchorAt(root, at)
+  const atRole = `${at}.${role}`
+  if (!Object.prototype.hasOwnProperty.call(roles.peg, role)) {
+    const near = nearestKey(role, Object.keys(roles.peg))
+    return {
+      verdict: 'refused',
+      role,
+      paths: paths.map((p) => ({
+        path: pathText(pathParts(p)), allowed: false, reason: 'no_role',
+      })),
+      findings: [finding(
+        'no_path',
+        atRole,
+        `The role ${role} is not declared at ${at} in this document.`,
+        null == near ? undefined : `did you mean ${near}?`)],
+    }
+  }
+  const node: any = roles.peg[role]
+
+  const allows = readEntries(node.peg.allow, `${atRole}.allow`, ctx)
+  if (null != allows.finding) {
+    return errorReport(role, allows.finding)
+  }
+  const denies = readEntries(node.peg.deny, `${atRole}.deny`, ctx)
+  if (null != denies.finding) {
+    return errorReport(role, denies.finding)
+  }
+
+  const decisions = paths.map((p) => decide(p, allows.entries, denies.entries))
+
+  // Nothing asked is nothing allowed: a gate that answered `allowed`
+  // to an empty question would let a caller that dropped its
+  // arguments through.
+  const allowed = 0 < decisions.length && decisions.every((d) => d.allowed)
+
+  return {
+    verdict: allowed ? 'allowed' : 'refused',
+    role,
+    paths: decisions,
+    findings: [],
+  }
+}

package/src/aontu.ts

@@ -22,6 +22,10 @@ import { get, why } from './query'
 import { patch } from './patch'
 import { diff } from './diff'
 import { agentsMd } from './agentsmd'
+import { allow } from './allow'
+export type {
+  AllowDecision, AllowOptions, AllowReason, AllowReport, AllowVerdict,
+} from './allow'
 import { graphOf } from './graph'
 import { relationCheck, relationErrors } from './relation'
 import { view, viewSet, viewTree } from './view'
@@ -31,22 +35,9 @@ import { format, unifiedDiff } from './format'
 export type { LintFinding, FormatReport, FormatOptions } from './format'
 
 
-// VERSION is the Aontu npm package version, and mirrors
-// go/aontu.go's `Version` (which tracks the Go module version
-// separately — the two version series are independent).
-//
-// Kept in step with package.json by the `version` npm lifecycle script,
-// which runs on `npm version` / `npm run repo-bump`. version.test.ts
-// fails if the two ever drift.
-const VERSION = '0.61.0'
+const VERSION = '0.63.0'
 
 
-// A module file's VALUE, as far as it goes. COLLECTED, not raised: a
-// module file that does not stand up has no `mod.main` to read, and
-// the default entry name is the answer -- the resolution itself fails
-// later, on the file that is not there, rather than here on a metadata
-// read. That is what a collecting context does, so there is nothing to
-// catch: it answers what it could generate and records the rest.
 function genQuiet(val: any, aontu: Aontu): any {
   return val.gen(aontu.ctx({ collect: true }))
 }
@@ -60,25 +51,9 @@ class Aontu {
   constructor(popts?: AontuOptions) {
     this.opts = popts ?? {}
 
-    // THE MODULE EVALUATOR (G6 phase 2, ts/src/mod.ts). Resolving a
-    // module import needs two answers that only evaluation can give:
-    // what a module file SAYS (its `mod.main`), and what a module
-    // MEANS (its canon-hash, for the integrity check). Injected here
-    // rather than imported there, because the resolver runs inside a
-    // parse that this class started, and the file it runs in cannot
-    // import this one without closing a cycle around the language.
-    //
-    // COLLECTED, not raised: a module that leans on consumer context
-    // (a `$.x` its importer supplies) does not stand up alone, and its
-    // hash is still the hash of what it says — that residue is part of
-    // the hashed meaning, which is why `hcanon` keeps it in textual
-    // form (docs/capability-review/g6-distribution.md).
     ;(this.opts as any).mod = {
       ...((this.opts as any).mod ?? {}),
       eval: (this.opts as any).mod?.eval ?? ((src: string, path: string) => {
-        // One deeper: a module verified from inside a module
-        // verification is one more level of nesting, and the resolver
-        // refuses past its bound (MODULE_MAX_DEPTH in ts/src/mod.ts).
         const inner = new Aontu({
           ...this.opts,
           mod: {
@@ -114,12 +89,6 @@ class Aontu {
   }
 
 
-  // Parse source into a matching Val AST, not yet unified.
-  //
-  // NOTE: the returned Val is SINGLE-USE — unify()/generate() refine the
-  // tree in place (see Val.unify), so do not unify or generate the same
-  // parsed Val more than once, and do not share it across threads. Call
-  // parse() again for a fresh tree.
   parse(src: string, opts?: AontuOptions, ac?: AontuContext): Val | undefined {
     let out: Val | undefined
     let errs: any[] = []
@@ -136,12 +105,6 @@ class Aontu {
       errs.push(out)
     }
     else {
-      // A version-control conflict marker is refused BEFORE the parse
-      // (issue #5). None of `<`, `=` or `>` is an aontu operator, so a
-      // marker line is ordinary text and `<<<<<<< HEAD` parsed happily
-      // into the two-string list ["<<<<<<<","HEAD"] -- an unresolved
-      // merge became a plausible document instead of an error, and the
-      // report of it read as a failed `<` operation.
       const marker = findConflictMarker(src)
       if (-1 !== marker.offset) {
         const nil: any = makeNilErr(ac, 'merge_conflict')
@@ -154,10 +117,6 @@ class Aontu {
 
     if (0 === errs.length) {
       out = runparse(src, this.lang, ac)
-      // The include MANIFEST (G5, docs/trust.md): the resolved include
-      // closure as `{ path, capability }`, sorted and deduplicated so
-      // it is deterministic — the "file set" of hermeticity clause 1
-      // made observable. Content hashing and pinning stay with G6.
       out.deps = manifestOf(ac.manifest)
       ac.root = out
     }
@@ -203,10 +162,6 @@ class Aontu {
       out = uni.res
 
       out.deps = pval.deps
-      // THE DERIVED STRUCTURE (G4 phase 3): the edge set, computed
-      // once from the unified tree. Cheap on a document with no links
-      // — one guarded walk — and the thing impact analysis and the
-      // relation checks are traversals over.
       out.graph = graphOf(out)
       out.err = errs
       ac.root = out
@@ -218,19 +173,6 @@ class Aontu {
   }
 
 
-  // Generate output structure from source, which must parse and fully unify.
-  //
-  // The result is made of NATIVE values, and D9 puts two beyond what
-  // `JSON.stringify` can write: a `biginteger` (a `0d` literal with no
-  // fraction or exponent) generates as a native `bigint`, and a
-  // `bigdecimal` generates as a `Decimal`. Both are exact at any
-  // magnitude, which is the whole point of the leaves -- and both are
-  // confined to documents that opt in, so a `0d`-free document generates
-  // exactly what it always did.
-  //
-  // Serialise the result with `exactJSON` (exported alongside this
-  // class), NOT with `JSON.stringify`: the latter throws on a bigint and
-  // has no way to write exact digits as a JSON number.
   generate(src: string, opts?: any, ac?: AontuContext): any {
     try {
       let out = undefined
@@ -243,7 +185,6 @@ class Aontu {
       if (undefined !== pval && 0 === pval.err.length) {
 
         let uval = this.unify(pval, undefined, ac)
-        // console.log('AONTU-GENERATE-UVAL', uval.constructor, uval.mark)
 
         if (undefined !== uval && 0 === uval.err.length) {
 
@@ -251,23 +192,6 @@ class Aontu {
             : 0 < ac.err.length ? undefined
               : uval.gen(ac as any)
 
-          // The relation verdict (RELATIONS P2): declarations the
-          // graph atoms registered during unification are decided
-          // HERE, where no more information can arrive -- the sizing
-          // atoms' model. A violated declaration is a located
-          // evaluation error at the offending edge, and the generated
-          // value is discarded below.
-          //
-          // AFTER GENERATION, and only when generation SUCCEEDED. A
-          // document that cannot be generated has no finished model
-          // to have a graph verdict about: an unsettled disjunction
-          // leaves alternatives the graph walk cannot read, so a
-          // mirror the document writes is absent from the edge set
-          // and `inverse(n)` reports it missing -- a false finding,
-          // and one that buried the `disjunct_no_gen` that actually
-          // stopped the document. The check that a broken document is
-          // not blamed on its relations (`relations` verb, finding F)
-          // holds here too.
           if (!uval.isNil && 0 === ac.err.length) {
             relationErrors(ac as any, uval)
             if (0 < ac.err.length) {
@@ -329,17 +253,6 @@ function handleErrors(errs: any[], out: Val | undefined, ac: AontuContext) {
 }
 
 
-// Locate the first version-control conflict marker in a source, as a
-// 1-based row and column (offset -1 when there is none).
-//
-// The shape is git's, and it is matched exactly: SEVEN of `<`, `=` or `>`
-// at the very start of a line, then either the end of that line or a
-// space before the branch label. Requiring the run length and the line
-// start is what keeps a document that legitimately writes `a:"<<<<<<<"`,
-// or a row of `=` inside a string, from being refused -- the marker is
-// recognised as the artifact it is, not as a suspicious character.
-//
-// Kept byte-identical to findConflictMarker in go/lang.go.
 function findConflictMarker(src: string): {
   offset: number, row: number, col: number
 } {
@@ -440,17 +353,9 @@ export {
   util,
   formatExplain,
 
-  // D9 -- the generate contract. `exactJSON` is the supported way to
-  // turn `generate()` output into JSON when a document uses the exact
-  // leaves, and `Decimal` is the type a `bigdecimal` generates as (a
-  // `biginteger` generates as the language's own `bigint`).
   exactJSON,
   Decimal,
 
-  // G2 phase 2 -- the validation verb. The engine only: the CLI verb
-  // and the text/JSON renderers are phase 3, the Go port phase 4.
-  // `sarifReport` (phase 5) is library API so an embedder can emit the
-  // interchange form without shelling out.
   vet,
   sarifReport,
 
@@ -460,10 +365,6 @@ export {
   subsume,
   trimCheck,
 
-  // G6 -- the hash form and the canon-hash pin. `hcanon` is the
-  // unify-level canon plus the close()/type()/hide() wrappers that
-  // close its semantic gaps; `canonHash` is
-  // "aon1-" + base64url(SHA-256(UTF-8(hcanon(v)))).
   hcanon,
   canonHash,
 
@@ -475,6 +376,11 @@ export {
   patch,
   diff,
   agentsMd,
+
+  // The role gate (docs/design/ALLOW.0.md): may a role modify a
+  // subtree, by a role model that is itself an aontu document. The
+  // question an agent asks before `set`.
+  allow,
   graphOf,
   relationCheck,
   view,
@@ -488,10 +394,6 @@ export {
   renderValue,
   renderProfile,
 
-  // The template surface (docs/design/TEMPLATE.0.md): the two text
-  // transforms behind `aontu template`, and the marker an extension
-  // names. Neither evaluates anything -- a template is a spelling of
-  // a generator, so the transforms are text in and text out.
   desugarTemplate,
   resugarTemplate,
   markerFor,

package/src/aontumodel.ts

@@ -0,0 +1,32 @@
+/* Copyright (c) 2025 Richard Rodger, MIT License */
+
+// GENERATED by ts/scripts/aontu.cjs (`make aontu`) from aontu/ —
+// DO NOT EDIT. The tree is the source;
+// ts/test/aontumodel.test.ts asserts this copy is identical with
+// it.
+
+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: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:system",
+  "aontu:view"
+]
+
+export { AONTU_SCHEME, AONTU_SOURCES, AONTU_MODELS }