@voxgig/sdkgen 3.7.2 → 4.0.0

package/project/.sdk/model/feature/feature-index.aon

@@ -0,0 +1,24 @@
+# Features
+
+# Core
+@"test.aon"
+@"log.aon"
+
+# Enterprise capabilities
+@"retry.aon"
+@"timeout.aon"
+@"ratelimit.aon"
+@"cache.aon"
+@"idempotency.aon"
+@"paging.aon"
+@"streaming.aon"
+@"proxy.aon"
+@"telemetry.aon"
+@"metrics.aon"
+@"debug.aon"
+@"audit.aon"
+@"clienttrack.aon"
+@"rbac.aon"
+
+# Test support: network behaviour simulation
+@"netsim.aon"

package/project/.sdk/src/cmp/seneca-provider/Extras_seneca-provider.ts

@@ -242,8 +242,15 @@ function seedRecord(e: any, idx: number): Record<string, any> {
     else if (e.parents.includes(f.name)) {
       // A nested entity's parent id must match a record the parent seeds, or
       // the offline store answers nothing and every nested test reads as a
-      // false pass.
-      out[f.name] = `${f.parentEntity}0`
+      // false pass. Reuses parentSeed's fallback rather than f.parentEntity
+      // directly: when no entity in the model shares this key's name (the
+      // common case for a scoping param like `user_id` with no `user`
+      // entity, or a same-named response field that means something else
+      // entirely, like GitHub's `owner`), f.parentEntity is '' and seeding
+      // '0' desynced the record from every query built against the SAME
+      // key via parentSeed (parentPairs, crudTest, ...) — 0 results, or a
+      // seeded field asserted against the wrong literal.
+      out[f.name] = parentSeed(e, f.name)
     }
     else if ('number' === f.kind) {
       out[f.name] = 100 * (idx + 1)
@@ -407,11 +414,20 @@ describe('${provider.fileBase}', () => {
 
 `)
 
-      if (subject.cmds.includes('list')) {
-        Content(`
-  it('${subject.name}-list', async () => {
+      // Every flat entity (no parent keys), not just one "subject" — a
+      // provider with two or more flat siblings used to leave every one
+      // but the busiest untested beyond the accessor check above. A bare
+      // `list$()`/`load$(id)` call has no way to carry a parent key, so
+      // entities that need one are covered by the `nested` block below
+      // instead, with their keys filled in.
+      const flat = provider.entities.filter((e: any) => 0 === e.parents.length)
+
+      each(flat, (e: any) => {
+        if (e.cmds.includes('list')) {
+          Content(`
+  it('${e.name}-list', async () => {
     const seneca = await makeSeneca()
-    const list = await seneca.entity('provider/${provider.lower}/${subject.name}').list$()
+    const list = await seneca.entity('provider/${provider.lower}/${e.name}').list$()
 
     assert.equal(list.length, 2)
 
@@ -420,25 +436,25 @@ describe('${provider.fileBase}', () => {
     // survive into the Seneca entity.
     assert.equal(
       list[0].canon$({ string: true }),
-      'provider/${provider.lower}/${subject.name}',
+      'provider/${provider.lower}/${e.name}',
     )
   })
 
 `)
-      }
+        }
 
-      if (subject.cmds.includes('load')) {
-        Content(`
-  it('${subject.name}-load', async () => {
+        if (e.cmds.includes('load')) {
+          Content(`
+  it('${e.name}-load', async () => {
     const seneca = await makeSeneca()
     const found = await seneca
-      .entity('provider/${provider.lower}/${subject.name}')
-      .load$('${subject.name}0')
+      .entity('provider/${provider.lower}/${e.name}')
+      .load$('${e.name}0')
 
-    assert.equal(found.${subject.idf || 'id'}, '${subject.name}0')
+    assert.equal(found.${e.idf || 'id'}, '${e.name}0')
     assert.equal(
       found.canon$({ string: true }),
-      'provider/${provider.lower}/${subject.name}',
+      'provider/${provider.lower}/${e.name}',
     )
   })
 
@@ -446,17 +462,18 @@ describe('${provider.fileBase}', () => {
   // A 404 from a single-item read is an ordinary "not found" answer, not a
   // failure: the provider turns it into null rather than letting the SDK
   // throw.
-  it('${subject.name}-load-missing', async () => {
+  it('${e.name}-load-missing', async () => {
     const seneca = await makeSeneca()
     const missing = await seneca
-      .entity('provider/${provider.lower}/${subject.name}')
-      .load$('nosuch${subject.name}')
+      .entity('provider/${provider.lower}/${e.name}')
+      .load$('nosuch${e.name}')
 
     assert.equal(missing, null)
   })
 
 `)
-      }
+        }
+      })
 
       // A nested entity cannot build its path without the parent id. That is
       // the mistake this target exists to make impossible, so pin it.
@@ -469,17 +486,31 @@ describe('${provider.fileBase}', () => {
         const pairs = e.parents
           .map((k: string) => `${k}: '${parentSeed(e, k)}'`).join(', ')
 
-        Content(`
+        // The guard is PER OP (Main's opParents), not a blanket property of
+        // the entity, so the op this test calls has to be one that actually
+        // requires `key` — hardcoding `list` assumed every nested entity's
+        // list is parent-scoped, which fails for e.g. an entity guarded on
+        // load/update/remove but whose list is unscoped (GitHub's `repo`:
+        // owner guards load, not list).
+        const guardOp = ['list', 'load', 'update', 'remove']
+          .find((op: string) => (e.opParents[op] || []).includes(key))
+
+        if (null != guardOp) {
+          const call = 'list' === guardOp ?
+            `${guardOp}$({})` : `${guardOp}$({ id: '${e.name}0' })`
+
+          Content(`
   it('${e.name}-needs-${key}', async () => {
     const seneca = await makeSeneca()
 
     await assert.rejects(
-      () => seneca.entity('provider/${provider.lower}/${e.name}').list$({}),
+      () => seneca.entity('provider/${provider.lower}/${e.name}').${call},
       /${key} is required/,
     )
   })
 
 `)
+        }
         if (e.cmds.includes('list')) {
           // Assert on the SEEDED RECORDS, not merely that an array came back.
           // `Array.isArray` is true of the empty array, so the nested-list
@@ -4024,4 +4055,6 @@ export {
   Workflow,
   Readme,
   Docs,
+  seedRecord,
+  parentSeed,
 }

package/project/.sdk/src/cmp/seneca-provider/Main_seneca-provider.ts

@@ -2,7 +2,7 @@ import {
   cmp, each,
   File, Content, Copy, Folder,
   entityCollection, entityOps, entityIdField, entityClassName,
-  opRequestShape, opParams, entityPath,
+  opRequestShape, opParams, ownPoint, entityPath,
   collectDeps, repoInfo, packageName, packageVersion, apiName, envName,
   authorInfo, contributorList, isAuthActive, jsKey, jsProp,
   SdkGenError,
@@ -74,12 +74,19 @@ function requiredKeys(ent: any, opname: string): string[] {
 // `<entity>_id` path param to `id` besides, which is why most APIs never reach
 // the fallback.
 //
-// When it does NOT answer, the record key is the LAST required path param of a
-// single-item op: a route addresses parents first and the record last, by
-// construction. Without this the key was simply unknown, so a param named
-// `code` failed the `!== idf` test in opParentKeys and was classified as a
-// PARENT — `load$('SAVE20')` threw "coupon load: code is required" instead of
-// loading anything, and the entity was treated as nested throughout.
+// When it does NOT answer, the record key is the LAST path param of the
+// op's own point, in PATH order — a route addresses parents first and the
+// record last, by construction. Without this the key was simply unknown,
+// so a param named `code` failed the `!== idf` test in opParentKeys and
+// was classified as a PARENT — `load$('SAVE20')` threw "coupon load: code
+// is required" instead of loading anything, and the entity was treated as
+// nested throughout.
+//
+// opParams(op) is NOT the source here: it alphabetizes params for output
+// stability, which loses path order on a 3+-param route — Airtable's
+// record (base_id, table_id, record_id) alphabetizes with table_id last,
+// so the old `params[params.length - 1]` picked the wrong parent as the
+// record's own key. The point's own `parts` still has the true order.
 function recordKey(ent: any): string {
   const idf = entityIdField(ent)
   if (null != idf && '' !== idf) {
@@ -88,13 +95,18 @@ function recordKey(ent: any): string {
 
   for (const opname of ['load', 'remove', 'update']) {
     const op = (ent.op || {})[opname]
-    if (null == op) {
+    if (null == op || 0 === (op.points || []).length) {
       continue
     }
 
-    const params = opParams(op).filter((p: any) => false !== p.reqd)
-    if (0 < params.length) {
-      return String((params[params.length - 1] as any).name)
+    const canonical = op.points.filter((pt: any) =>
+      null == (pt && pt.select && pt.select['$action']))
+    const point = ownPoint(0 < canonical.length ? canonical : op.points)
+    const parts: string[] = (point && point.parts) || []
+    const lastParam = [...parts].reverse().find((p: string) => p.startsWith('{'))
+
+    if (null != lastParam) {
+      return lastParam.slice(1, -1)
     }
   }
 
@@ -966,4 +978,5 @@ if ('undefined' !== typeof module) {
 
 export {
   Main,
+  recordKey,
 }

package/project/.sdk/src/cmp/ts/TestDirect_ts.ts

@@ -153,6 +153,92 @@ function unwrapListData(data: any): any[] | null {
 })
 
 
+// GraphQL-backed op: a REST-shaped direct() call (GET, params in the URL)
+// cannot reach it — every op, including list, synthesizes POST with the
+// query/variables as a JSON body, not URL params (see
+// MakeFetchDefUtility: spec.body only ever comes from an explicit `body`
+// field, never derived from `params`). apidef already built a real, valid
+// query or mutation document per point (point.graphql.doc, with variables
+// declared to match), so reuse that verbatim through the SDK's own
+// graphql() escape hatch instead of re-deriving a REST-shaped call that
+// cannot represent one.
+function generateDirectGraphql(
+  opname: 'load' | 'list',
+  entity: ModelEntity,
+  point: any,
+  strict: boolean,
+) {
+  const doc: string = point.graphql.doc
+  const vars: any[] = point.graphql.vars || []
+
+  const varLine = (target: string, key: string, v: any) =>
+    `      ${target}[${JSON.stringify(v.name)}] = ${key}`
+
+  const mockVarLines = vars.map((v: any, i: number) =>
+    varLine('variables', `'direct0${i + 1}'`, v)).join('\n')
+
+  const liveVarLines = vars.map((v: any) => {
+    const from = v.from || v.name
+    const key = ('id' === from ? entity.name : from.replace(/_id$/, '')) + '01'
+    return varLine('variables', `setup.idmap['${key}']`, v)
+  }).join('\n')
+
+  const liveIdKeys = vars.map((v: any) => {
+    const from = v.from || v.name
+    return ('id' === from ? entity.name : from.replace(/_id$/, '')) + '01'
+  })
+
+  const skipMissingLine = 0 < liveIdKeys.length
+    ? `    if (skipIfMissingIds(t, setup, ${JSON.stringify(liveIdKeys)})) return\n`
+    : ''
+
+  // Asserted against the OUTGOING request body (what we sent), not the
+  // mocked response — response-shape correctness is the entity-level
+  // load/list tests' job; direct/graphql only has to prove the raw path
+  // reaches the endpoint with the right method and payload.
+  const varAsserts = vars.map((_v: any, i: number) =>
+    '      assert(calls[0].init.body.includes(\'direct0' + (i + 1) + '\'))\n').join('')
+
+  const offlineChecks = `      assert(result.ok === true)
+      assert(result.status === 200)
+      assert(null != result.data)
+      assert(calls.length === 1)
+      assert(calls[0].init.method === 'POST')
+${varAsserts}`
+
+  const checks = strict ?
+    offlineChecks.replace(/^ {6}/gm, '    ').replace(/^ {4}$/gm, '') :
+    `    if (setup.live) {
+      // Live mode is lenient: synthetic ids frequently fail server-side
+      // validation. Skip rather than fail when the call doesn't come back
+      // clean.
+      if (!result.ok || result.status < 200 || result.status >= 300) {
+        return
+      }
+    } else {
+${offlineChecks}    }`
+
+  Content(`
+  test('direct-${opname}-${entity.name}', async (t: any) => {
+    const setup = directSetup()
+    if (maybeSkipControl(t, 'direct', 'direct-${opname}-${entity.name}', setup.live)) return
+${skipMissingLine}    const { client, calls } = setup
+
+    const variables: any = {}
+    if (setup.live) {
+${liveVarLines || '      // no variables'}
+    } else {
+${mockVarLines || '      // no variables'}
+    }
+
+    const result: any = await client.graphql(${JSON.stringify(doc)}, variables)
+
+${checks}
+  })
+`)
+}
+
+
 function generateDirectLoad(model: Model, entity: ModelEntity, strict: boolean) {
   const loadOp = entity.op?.load
   const loadPoint: ModelPoint | undefined = loadOp?.points?.[0]
@@ -161,6 +247,11 @@ function generateDirectLoad(model: Model, entity: ModelEntity, strict: boolean)
     return
   }
 
+  if ('graphql' === (loadPoint as any).kind) {
+    generateDirectGraphql('load', entity, loadPoint, strict)
+    return
+  }
+
   const allLoadParams = loadPoint.args?.params || []
   const loadPath = normalizePathParams(loadPoint.parts || [], allLoadParams, loadPoint.rename?.param)
 
@@ -377,6 +468,11 @@ function generateDirectList(model: Model, entity: ModelEntity, strict: boolean)
     return
   }
 
+  if ('graphql' === (listPoint as any).kind) {
+    generateDirectGraphql('list', entity, listPoint, strict)
+    return
+  }
+
   const listParams = listPoint.args?.params || []
   const listPath = normalizePathParams(listPoint.parts || [], listParams, listPoint.rename?.param)
 

package/project/.sdk/tm/csharp/Makefile

@@ -11,7 +11,7 @@ clean:
 	rm -rf bin obj test/bin test/obj
 
 # --- Release: tag for NuGet ------------------------------------------------
-# NuGet publication is pending (see model/target/csharp.aontu publish block);
+# NuGet publication is pending (see model/target/csharp.aon publish block);
 # publishing a version currently means pushing the tag csharp/vX.Y.Z. When the
 # registry goes live, `dotnet pack` + `dotnet nuget push` slot in before the
 # tag (mirroring the voxgig/struct csharp Makefile). Run headless under the

package/project/.sdk/tm/rb/utility/struct/voxgig_struct.rb

@@ -5,8 +5,28 @@ module VoxgigStruct
   # --- Debug Logging Configuration ---
   DEBUG = false
   
-  def self.log(msg)
-    puts "[DEBUG] #{msg}" if DEBUG
+  # LAZY. The argument to a Ruby method is evaluated BEFORE the call, so
+  # `log("... #{val.inspect} ...")` built its message on every call and then
+  # threw it away, because DEBUG is false. `val` here is a node of the API
+  # model, and `inspect` serialises the whole subtree — so each property access
+  # cost O(size of the tree it was reading from), turning a walk over the model
+  # into O(n^2).
+  #
+  # Measured on gitlab-sdk (276 entities in config.options), which constructs
+  # one client per generated test:
+  #
+  #   validate(options)      4.620s -> 0.039s   (118x)
+  #   client construction    5.790s -> 0.041s   (141x)
+  #   per-entity validate    0.0182s -> 0.0001s, and flat instead of climbing
+  #
+  # The whole rb suite took 7,894s against 431s for ts and 255s for php on the
+  # SAME model. Ruby was not slow; this was.
+  #
+  # A block is not evaluated unless yielded, so with DEBUG false the message
+  # now costs nothing. Call sites pass `log { "..." }`, never `log("...")`.
+  def self.log(msg = nil)
+    return unless DEBUG
+    puts "[DEBUG] #{block_given? ? yield : msg}"
   end
 
   # --- Helper to convert internal undefined marker to Ruby nil ---
@@ -137,33 +157,33 @@ module VoxgigStruct
   # --- Internal getprop ---
   # Returns the value if found; otherwise returns alt (default is UNDEF)
   def self._getprop(val, key, alt = UNDEF)
-    log("(_getprop) called with val=#{val.inspect} and key=#{key.inspect}")
+    log { "(_getprop) called with val=#{val.inspect} and key=#{key.inspect}" }
     return alt if val.nil? || key.nil?
     if islist(val)
       key = (key.to_s =~ /\A\d+\z/) ? key.to_i : key
       unless key.is_a?(Numeric) && key >= 0 && key < val.size
-        log("(_getprop) index #{key.inspect} out of bounds; returning alt")
+        log { "(_getprop) index #{key.inspect} out of bounds; returning alt" }
         return alt
       end
       result = val[key]
-      log("(_getprop) returning #{result.inspect} from array for key #{key}")
+      log { "(_getprop) returning #{result.inspect} from array for key #{key}" }
       return result
     elsif ismap(val)
       key_str = key.to_s
       if val.key?(key_str)
         result = val[key_str]
-        log("(_getprop) found key #{key_str.inspect} in hash, returning #{result.inspect}")
+        log { "(_getprop) found key #{key_str.inspect} in hash, returning #{result.inspect}" }
         return result
       elsif key.is_a?(String) && val.key?(key.to_sym)
         result = val[key.to_sym]
-        log("(_getprop) found symbol key #{key.to_sym.inspect} in hash, returning #{result.inspect}")
+        log { "(_getprop) found symbol key #{key.to_sym.inspect} in hash, returning #{result.inspect}" }
         return result
       else
-        log("(_getprop) key #{key.inspect} not found; returning alt")
+        log { "(_getprop) key #{key.inspect} not found; returning alt" }
         return alt
       end
     else
-      log("(_getprop) value is not a node; returning alt")
+      log { "(_getprop) value is not a node; returning alt" }
       alt
     end
   end
@@ -210,7 +230,7 @@ module VoxgigStruct
   end
 
   def self.setprop(parent, key, val = :no_val_provided)
-    log(">>> setprop called with parent=#{parent.inspect}, key=#{key.inspect}, val=#{val.inspect}")
+    log { ">>> setprop called with parent=#{parent.inspect}, key=#{key.inspect}, val=#{val.inspect}" }
     return parent unless iskey(key)
     if ismap(parent)
       key_str = key.to_s
@@ -236,7 +256,7 @@ module VoxgigStruct
         end
       end
     end
-    log("<<< setprop result: #{parent.inspect}")
+    log { "<<< setprop result: #{parent.inspect}" }
     parent
   end
 

package/project/.sdk/tm/swift/Makefile

@@ -12,7 +12,7 @@ clean:
 
 # --- Release: tag for the SwiftPM registry ---------------------------------
 # SwiftPM has no upload step - publishing IS the git tag. Publication is
-# pending (see model/target/swift.aontu publish block); publishing a version
+# pending (see model/target/swift.aon publish block); publishing a version
 # currently means pushing the tag swift/vX.Y.Z. Run headless under the boru key
 # vault, which injects the GitHub token so nothing lands on disk or argv:
 #   boru vault exec --for=github=<alias> -- make publish

package/project/.sdk/tm/ts/src/feature/test/TestFeature.ts

@@ -8,6 +8,35 @@ import { BaseFeature } from '../base/BaseFeature'
 const S_NOT_FOUND = 'Not found'
 
 
+// Which param is entity X's own identifier, as opposed to a parent key —
+// the load op's canonical point's LAST path segment, by construction (a
+// route addresses parents first, the record last). Mirrors recordKey in
+// sdkgen's Main_seneca-provider.ts; written again here because a template
+// ships standalone, outside that package. A renamed id (e.g. Airtable's
+// record_id) needs its own seeded field: matching only ever happens
+// against the API's real param names, never a bare 'id' the API itself
+// does not use.
+function ownIdField(config: any, getpath: any, entityName: string): string {
+  for (const opname of ['load', 'remove', 'update']) {
+    const points = getpath(config, ['entity', entityName, 'op', opname, 'points']) || []
+    const canonical = points.filter((pt: any) =>
+      null == (pt && pt.select && pt.select['$action']))
+    const use = 0 < canonical.length ? canonical : points
+    let best = use[0]
+    for (const pt of use) {
+      if (null == pt || null == pt.parts || null == best || null == best.parts) continue
+      const ptterm = 0 < pt.parts.length && String(pt.parts[pt.parts.length - 1]).startsWith('{')
+      const bestterm = 0 < best.parts.length && String(best.parts[best.parts.length - 1]).startsWith('{')
+      if (ptterm !== bestterm ? ptterm : pt.parts.length < best.parts.length) best = pt
+    }
+    const parts: string[] = (best && best.parts) || []
+    const last = [...parts].reverse().find((p: string) => p.startsWith('{'))
+    if (null != last) return last.slice(1, -1)
+  }
+  return 'id'
+}
+
+
 class TestFeature extends BaseFeature {
   version = '0.0.1'
   name = 'test'
@@ -30,10 +59,16 @@ class TestFeature extends BaseFeature {
 
     this._client._mode = 'test'
 
+    const getpath = struct.getpath
+
     // Ensure entity ids are correct.
     walk(entity, (k: any, v: any, _parent: any, path: any) => {
       if (2 === size(path)) {
         setprop(v, 'id', k)
+        const idField = ownIdField(ctx.config, getpath, String(path[0]))
+        if ('id' !== idField) {
+          setprop(v, idField, k)
+        }
       }
       return v
     })
@@ -172,6 +207,16 @@ class TestFeature extends BaseFeature {
 
         const ent = clone(ctx.reqdata)
         setprop(ent, 'id', id)
+
+        // A record created during the run needs the same real-key seeding
+        // the initial walk gives seed data (see ownIdField above) — without
+        // it, only `id` is set, and a load by the entity's own key right
+        // after create (recordKey !== 'id') finds nothing.
+        const idField = ownIdField(ctx.config, struct.getpath, getprop(op, 'entity'))
+        if ('id' !== idField && null == getprop(ent, idField)) {
+          setprop(ent, idField, id)
+        }
+
         setprop(entmap, id, ent)
         delprop(ent, '$KEY')
         const out = clone(ent)
@@ -310,7 +355,8 @@ class TestFeature extends BaseFeature {
 
 
 export {
-  TestFeature
+  TestFeature,
+  ownIdField,
 }
 
 

package/project/sdkgen-package.json

@@ -3,7 +3,7 @@
     "package": 1
   },
   "name": "@voxgig/sdkgen",
-  "version": "3.7.2",
+  "version": "4.0.0",
   "provides": {
     "target": [
       "c",

package/src/action/action.ts

@@ -12,7 +12,7 @@ import type {
 } from '../types'
 
 
-const indexEntry = (name: string) => `@"${name}.aontu"`
+const indexEntry = (name: string) => `@"${name}.aon"`
 
 
 // An index line that is an ACTIVE include, and the name it includes — or
@@ -21,17 +21,17 @@ const indexEntry = (name: string) => `@"${name}.aontu"`
 // Parsed rather than compared as a string, because both spellings around an
 // include are legal aontu and mean opposite things:
 //
-//   @"go.aontu"                 -> active, name 'go'
-//   @"go.aontu"  # pinned       -> active, name 'go'  (trailing comment)
-//     @"go.aontu"               -> active, name 'go'  (indented)
-//   # @"go.aontu"               -> NOT active
+//   @"go.aon"                 -> active, name 'go'
+//   @"go.aon"  # pinned       -> active, name 'go'  (trailing comment)
+//     @"go.aon"               -> active, name 'go'  (indented)
+//   # @"go.aon"               -> NOT active
 //
 // A substring test (what this used to be) reads the commented-out form as
 // present, so `target add go` on a project that had switched the target off
 // by hand appended nothing and reported success while the target stayed
 // absent from the model. A whole-line equality test fixes that but then
 // misses the trailing-comment form, and appends a SECOND active include.
-const INDEX_ENTRY_RE = /^\s*@"([^"]+)\.aontu"\s*(?:#.*)?$/
+const INDEX_ENTRY_RE = /^\s*@"([^"]+)\.aon"\s*(?:#.*)?$/
 
 function indexEntryName(line: string): string | undefined {
   const m = line.match(INDEX_ENTRY_RE)
@@ -46,7 +46,7 @@ function hasIndexEntry(content: string, name: string): boolean {
 }
 
 
-// Append `@"<name>.aontu"` import lines for each name not already present in
+// Append `@"<name>.aon"` import lines for each name not already present in
 // the index content. Checking against the accumulating result (not the
 // original) means duplicate names in the same call are added at most once.
 function appendIndexEntries(content: string, names: string[]): string {
@@ -62,7 +62,7 @@ function appendIndexEntries(content: string, names: string[]): string {
 }
 
 
-// Drop the `@"<name>.aontu"` line for each name — the inverse of
+// Drop the `@"<name>.aon"` line for each name — the inverse of
 // appendIndexEntries, matching line-exact for the same reasons.
 //
 // Nothing calls this yet: a `remove` action is the fast-follow this exists
@@ -100,12 +100,12 @@ function parseAddNames(args: any[]): string[] {
 // The current index file for each kind, which `UpdateIndex` appends to.
 //
 // `seed` IS THE UPGRADE PATH. A project scaffolded before a kind existed has
-// no `model/<kind>/<kind>-index.aontu` — every project alive today is in
+// no `model/<kind>/<kind>-index.aon` — every project alive today is in
 // exactly that position for `docs` — and reading it unguarded made the FIRST
 // `docs add` in any existing project fail on ENOENT before it wrote anything.
 //
 // Seeded per call rather than defaulted for every kind: a missing
-// `target-index.aontu` in a scaffolded project is a broken project, and
+// `target-index.aon` in a scaffolded project is a broken project, and
 // quietly recreating it would hide that. A kind the project has never used is
 // a different thing, and only its own action knows which case it is in.
 function loadContent(
@@ -119,7 +119,7 @@ function loadContent(
   const modelfolder = Path.dirname(actx.url)
 
   which.map((w: string) => {
-    const indexfile = Path.join(modelfolder, w, w + '-index.aontu')
+    const indexfile = Path.join(modelfolder, w, w + '-index.aon')
 
     content[`${w}_index`] = (null != seed?.[w] && !fs.existsSync(indexfile)) ?
       seed[w] : fs.readFileSync(indexfile, 'utf8')
@@ -136,7 +136,7 @@ function loadContent(
 // indexes of the kinds that existed then. So a project scaffolded before a
 // kind existed — which is every project alive today, for `docs` — never
 // includes its index, and the item's model file is an orphan: it is on disk,
-// `<kind>-index.aontu` includes it, and NOTHING includes that. `main.kit.docs`
+// `<kind>-index.aon` includes it, and NOTHING includes that. `main.kit.docs`
 // is then absent from the compiled model, so `package list`, `package update`
 // and `doctor` cannot see the item at all.
 //

package/src/action/check.ts

@@ -302,7 +302,7 @@ function checkDefinition(
     return found
   }
 
-  // 4. Does it declare the key its FILENAME promises? `model/target/iot-go.aontu`
+  // 4. Does it declare the key its FILENAME promises? `model/target/iot-go.aon`
   //    is copied to that name and included by it, so a file still declaring
   //    `main: kit: target: go:` installs an item the consumer's model never
   //    sees — the exact mistake a package author makes copying a bundled
@@ -474,7 +474,7 @@ function checkFeatureSource(
       level: 'warn', point: 'feature-source-unrecognised', file,
       kind: 'target', name: tname,
       note: 'tm/' + tname + ': ' + strays.map((e) => e.path).join(', ') +
-        ' — named like feature source, but no `model/feature/<name>.aontu` ' +
+        ' — named like feature source, but no `model/feature/<name>.aon` ' +
         'declares ' + strays.map((e) => e.name).join(', ') +
         ', so the trim cannot recognise them and every project gets them ' +
         'whatever its model selects'