@voxgig/sdkgen 4.9.0 → 4.11.0

package/src/testkit.ts

@@ -26,6 +26,12 @@
 //   consumer.compile()                             // as a consumer's build does
 //   const { files, leaks } = await generateInto(consumer, { model })
 //
+// A target with `output: path` writes outside the consumer root, so declare
+// its destinations and read them back per destination:
+//
+//   const { outside } = await generateInto(
+//     consumer, { model, outside: ['../acme-provider'] })
+//
 // That runs the REAL add pipeline and the REAL generation, so provenance,
 // index handling, the feature fan-out and the trim catalogue are all exercised
 // against the package as published rather than as described.
@@ -615,6 +621,24 @@ type GenerateOptions = {
   // Placeholder mentions that are NOT leaks, exactly as `parity.test.ts`
   // keeps its list: a stated policy, not a mute button.
   allowPlaceholder?: (path: string, token: string) => boolean
+
+  // OUT-OF-TREE DESTINATIONS THE CALLER EXPECTS — the `output: path` of every
+  // external target in the model, exactly as the model spells it.
+  //
+  // Needed because a target with `output: path` writes OUTSIDE the consumer
+  // root, and the check below treats a path outside the root as a bug rather
+  // than a result. That check is worth keeping (see it for what it catches),
+  // so the way to express out-of-tree output is to DECLARE the destination
+  // rather than to loosen it: a path under neither the root nor a declared
+  // destination is still a bug and still throws.
+  //
+  // Without this a package shipping an out-of-tree target — which is what
+  // `seneca-provider` is, and the reason it was the first consumer target to
+  // migrate — could not test its defining mode at all.
+  //
+  // A relative destination resolves against the consumer ROOT, which is what
+  // `output: path` itself resolves against: the SDK project, not the CWD.
+  outside?: string[]
 }
 
 
@@ -622,7 +646,15 @@ type GenerateResult = {
   // Every generated path, relative to the consumer root, mapped to content.
   files: Record<string, string>
 
-  // `<path>: <token>` for each surviving placeholder.
+  // Files written OUTSIDE the consumer root, one map per destination declared
+  // in `outside`, keyed by the destination as the caller spelled it and then
+  // by the path relative to that destination. Empty unless `outside` was
+  // passed.
+  outside: Record<string, Record<string, string>>
+
+  // `<path>: <token>` for each surviving placeholder, across `files` AND
+  // every `outside` destination — an external target's output is generated
+  // by the same replace maps and leaks the same way.
   leaks: string[]
 }
 
@@ -698,50 +730,107 @@ async function generateInto(
   // On POSIX both transformations are identity, so this changes nothing there.
   const rootkey = volumeKey(consumer.root)
 
+  // The declared out-of-tree destinations, resolved the way `output: path` is
+  // — against the consumer root — and reduced to volume keys so they compare
+  // with generated paths on the same terms as the root does.
+  //
+  // LONGEST KEY FIRST. A destination nested inside another would otherwise be
+  // matched by whichever came first in the array, silently filing its files
+  // under the wrong one; sorting makes the most specific destination win, the
+  // same rule a router uses.
+  const declared = (opts.outside ?? [])
+    .map((dest) => ({ dest, key: volumeKey(Path.resolve(consumer.root, dest)) }))
+    .sort((a, b) => b.key.length - a.key.length)
+
   const files: Record<string, string> = {}
+  const outside: Record<string, Record<string, string>> = {}
+  for (const { dest } of declared) {
+    outside[dest] = {}
+  }
+
   for (const [path, content] of Object.entries(vol.toJSON() as Record<string, string>)) {
     const key = volumeKey(path)
 
-    // A KEY OUTSIDE THE ROOT IS A BUG HERE, NOT A RESULT.
+    const under = (base: string) => key === base || key.startsWith(base + '/')
+    const rel = (base: string) => key === base ? '' : key.slice(base.length + 1)
+
+    // The generator's own bookkeeping, wherever it landed. Skipped in both
+    // views for the same reason: the caller is asking what package was
+    // written, not what jostraca recorded about writing it.
+    const junk = (p: string) =>
+      p.startsWith('.jostraca/') || p.includes('/.jostraca/')
+
+    if (under(rootkey)) {
+      const p = rel(rootkey)
+      if (!junk(p)) files[p] = content
+      continue
+    }
+
+    const hit = declared.find((d) => under(d.key))
+    if (null != hit) {
+      const p = rel(hit.key)
+      if (!junk(p)) outside[hit.dest][p] = content
+      continue
+    }
+
+    // A KEY OUTSIDE THE ROOT AND EVERY DECLARED DESTINATION IS A BUG HERE,
+    // NOT A RESULT.
     //
     // It means the string generation wrote under and the string being stripped
     // off have diverged, and the caller would otherwise get a file map keyed
     // by absolute path — which reads as "my component never ran" rather than
     // as a path problem, and is exactly how this presented on Windows.
-    if (key !== rootkey && !key.startsWith(rootkey + '/')) {
-      throw new Error(
-        'testkit: generated path is not under the consumer root, so the ' +
-        'result cannot be keyed.\n  root: ' + consumer.root +
-        '\n  path: ' + path +
-        '\n  compared as: ' + rootkey + '  vs  ' + key +
-        '\nThese must agree once separators and any drive letter are ' +
-        'normalised — memfs stores volume keys, not OS paths.')
-    }
-
-    const rel = key === rootkey ? '' : key.slice(rootkey.length + 1)
-
-    if (rel.startsWith('.jostraca/') || rel.includes('/.jostraca/')) continue
-    files[rel] = content
+    //
+    // An out-of-tree target is the one legitimate way to be outside the root,
+    // and it is legitimate only because the caller SAID SO: pass its
+    // `output: path` in `outside`. A path under neither still throws, so a
+    // package cannot get here by accident.
+    throw new Error(
+      'testkit: generated path is not under the consumer root or any ' +
+      'declared out-of-tree destination, so the result cannot be keyed.' +
+      '\n  root: ' + consumer.root +
+      '\n  path: ' + path +
+      '\n  compared as: ' + rootkey + '  vs  ' + key +
+      (0 === declared.length
+        ? '\nIf this target declares `output: path`, pass that path in the ' +
+          '`outside` option.'
+        : '\n  declared: ' + declared.map((d) => d.key).join(', ')) +
+      '\nThese must agree once separators and any drive letter are ' +
+      'normalised — memfs stores volume keys, not OS paths.')
   }
 
   const allow = opts.allowPlaceholder ?? (() => false)
   const leaks: string[] = []
-  for (const [path, content] of Object.entries(files)) {
-    if ('string' !== typeof content) continue
 
-    for (const token of PLACEHOLDERS) {
-      if (content.includes(token) && !allow(path, token)) {
-        leaks.push(path + ': ' + token)
+  // SCANNED IN BOTH VIEWS. An out-of-tree target's output goes through the
+  // same replace maps and leaks a placeholder the same way, so a scan that
+  // covered only the in-tree files would report `leaks: []` for a package
+  // whose whole output is external.
+  const scan = (prefix: string, map: Record<string, string>) => {
+    for (const [path, content] of Object.entries(map)) {
+      if ('string' !== typeof content) continue
+
+      const label = prefix + path
+
+      for (const token of PLACEHOLDERS) {
+        if (content.includes(token) && !allow(label, token)) {
+          leaks.push(label + ': ' + token)
+        }
       }
-    }
 
-    const ref = content.match(PLACEHOLDER_REF)
-    if (null != ref && !allow(path, ref[0])) {
-      leaks.push(path + ': ' + ref[0])
+      const ref = content.match(PLACEHOLDER_REF)
+      if (null != ref && !allow(label, ref[0])) {
+        leaks.push(label + ': ' + ref[0])
+      }
     }
   }
 
-  return { files, leaks: leaks.sort() }
+  scan('', files)
+  for (const { dest } of declared) {
+    scan(dest + '/', outside[dest])
+  }
+
+  return { files, outside, leaks: leaks.sort() }
 }
 
 

package/src/utility.ts

@@ -29,17 +29,27 @@ function resolvePath(ctx$: any, path: string): any {
 
 // True unless the model declares auth off. Templates use this to gate
 // apikey-related code, docs, and examples for public APIs that need no
-// authentication. Two opt-outs, in priority order:
-//   1. main.kit.info.auth: false        (user-facing, set in api-info.aon)
-//   2. main.kit.config.auth.active: false
+// authentication.
+//
+// The project's own word comes first: `main.kit.config.auth.active` set
+// EXPLICITLY (true or false) decides. GitHub's official OpenAPI declares no
+// securitySchemes, so apidef faithfully writes `info.auth: false` and every
+// generated client sent no credential; the only override lived in a
+// generated file. A project that knows its API takes a bearer token says so
+// once in its own config and that wins over the spec's silence.
+//
+// Otherwise the spec-derived signal governs:
+//   1. main.kit.config.auth.active: true|false  (per-SDK, in config.aon)
+//   2. main.kit.info.auth: false                (apidef: the spec declares
+//                                               no authentication)
 function isAuthActive(model: any): boolean {
-  const info = getModelPath(model, `main.${KIT}.info`,
+  const auth = getModelPath(model, `main.${KIT}.config.auth`,
     { only_active: false, required: false })
-  if (info && false === info.auth) return false
+  if (null != auth && 'boolean' === typeof auth.active) return auth.active
 
-  const auth = getModelPath(model, `main.${KIT}.config.auth`,
+  const info = getModelPath(model, `main.${KIT}.info`,
     { only_active: false, required: false })
-  return null == auth || false !== auth.active
+  return !(info && false === info.auth)
 }
 
 

package/project/.sdk/model/target/dart.aon

@@ -1,58 +0,0 @@
-main: kit: target: dart: {
-
-  title: Dart
-  ext: dart
-  comment: line: "//"
-  module: name: '$$name$$'
-  base: 'BASE'
-  srcfeature: false
-
-  # Files earlier toolchains generated that this target has RETIRED
-  # (vendor-tag rollout): the fused corpus runner and the second, independent
-  # struct-corpus engine, both replaced by test/omni.dart over the vendored
-  # @voxgig/omni port. `doctor` reports leftovers; `doctor prune` deletes
-  # them (jostraca only ever writes, it cannot delete).
-  superseded: [
-    'test/runner.dart'
-    'test/struct_corpus.dart'
-  ]
-
-  deps: &: {
-    kind: *'prod' | string
-  }
-
-  # struct utility is vendored under tm/dart/lib/utility/voxgig_struct.dart -
-  # the runtime is dependency-free (dart:io HttpClient + dart:convert only).
-  deps: {}
-}
-
-
-main: kit: feature: &: target: dart: deps: &: {
-  kind: *'prod' | string
-}
-
-
-# Publication: pub.dev registry (declared, publish pending — git-tag only).
-#
-# `target add <t>` OVERWRITES this file, so a project must never set its
-# publication values here — voxgig-solardemo-sdk lost its pinned npm package
-# name exactly that way. Set them in the project's own overlay
-# (`model/project.aon`), which create-sdkgen creates once and never
-# overwrites — NOT `model/sdk.aon`, which it rewrites on every scaffold.
-#
-# For that to work this file must LEAVE THOSE KEYS UNSET: in aontu a concrete
-# value does not yield to another concrete value, it CONFLICTS, and two
-# defaults conflict too. The schema (@voxgig/sdkgen/model/sdkgen.aon)
-# already defaults `tag.active`, `registry.state`, `registry.active` and
-# `registry.package`, so a project's concrete value wins over the default and
-# repeating them here would only take that away.
-#
-# What remains below is per-target registry IDENTITY, which is not a project
-# choice and stays concrete.
-main: kit: target: dart: publish: {
-  registry: {
-    name: 'pub.dev'
-    url: 'https://pub.dev'
-    vault: { alias: 'pubdev', env: 'PUB_CREDENTIALS' }
-  }
-}

package/project/.sdk/model/target/lean.aon

@@ -1,91 +0,0 @@
-
-main: kit: target: lean: {
-
-  title: Lean
-  ext: lean
-  comment: line: "--"
-  module: name: '$$name$$'
-  base: 'BASE'
-  srcfeature: false
-
-  # RETIREMENT. Retired by the move to the vendored @voxgig/omni corpus
-  # runner (vendor-tag rollout): NOTHING, deliberately, and the empty list
-  # says so rather than leaving the key off.
-  #
-  # Lean's corpus ENGINE was never a file of its own. It lived FUSED inside
-  # test/StructCorpus.lean (its own JSON reader, fixJson, eqv, matchval,
-  # doMatch, resolveArgs, checkResult, handleError and runSet) and again
-  # inside test/TPrimaryUtility.lean (runset, deepEq, strCheck, matchDeep).
-  # Both files were rewritten IN PLACE onto test/OmniResolver.lean, so both
-  # KEEP THEIR NAMES, the `structcorpus` and `primary` lean_exe roots are
-  # unchanged, and no emitted call site needed churn. test/TFeature.lean is a
-  # hand-written behavioural suite, not a corpus runner, and is RETAINED;
-  # test/Runner.lean (generated) is the entity/pipeline lane, likewise
-  # RETAINED despite the name. There is therefore no whole-file leftover for
-  # `doctor` to report or `doctor prune` to delete.
-  superseded: []
-
-  # Entities are generic (config-driven F.makeEntity), so no per-entity or
-  # per-feature generated modules — the same model as the Haskell target. The
-  # readme + agentguide phases read the API model directly (not per-entity
-  # generated code), so they are active; entity/feature generation stays off.
-  phase: {
-    entity:     { active: false }
-    feature:    { active: false }
-    readme:     { active: true }
-    agentguide: { active: true }
-    test:       { active: true }
-  }
-
-  deps: &: {
-    kind: *'prod' | string
-  }
-
-  # struct is vendored under src/ (VoxgigStruct.lean + Vregex.lean) and the
-  # runtime is dependency-free: it compiles with the stock Lean 4 toolchain
-  # (only the built-in prelude + Std), no Lake package dependencies. The HTTP
-  # transport shells out to `curl` via IO.Process, so there are no manifest
-  # deps.
-  deps: {}
-}
-
-
-main: kit: feature: &: target: lean: deps: &: {
-  kind: *'prod' | string
-}
-
-
-# Publication: Reservoir (Lean package index) — declared, publish pending
-# (git-tag only for now).
-#
-# `target add <t>` OVERWRITES this file, so a project must never set its
-# publication values here — voxgig-solardemo-sdk lost its pinned npm package
-# name exactly that way. Set them in the project's own overlay
-# (`model/project.aon`), which create-sdkgen creates once and never
-# overwrites — NOT `model/sdk.aon`, which it rewrites on every scaffold.
-#
-# For that to work this file must LEAVE THOSE KEYS UNSET: in aontu a concrete
-# value does not yield to another concrete value, it CONFLICTS, and two
-# defaults conflict too. The schema (@voxgig/sdkgen/model/sdkgen.aon)
-# already defaults `tag.active`, `registry.state`, `registry.active` and
-# `registry.package`, so a project's concrete value wins over the default and
-# repeating them here would only take that away.
-#
-# What remains below is per-target registry IDENTITY, which is not a project
-# choice and stays concrete.
-main: kit: target: lean: publish: {
-  registry: {
-    name: 'reservoir'
-    url: 'https://reservoir.lean-lang.org'
-    vault: { alias: 'reservoir', env: 'RESERVOIR_TOKEN' }
-  }
-}
-
-
-# Feature source is NOT trimmed to the model's selection here: every
-# feature lives inside a single generated module (src/SdkFeatures.lean),
-# not in per-feature source files, so there is nothing per-feature to
-# leave out. Trimming waits on that module becoming model-driven.
-main: kit: target: lean: feature: {
-  trim: false
-}

package/project/.sdk/model/target/seneca-provider.aon

@@ -1,120 +0,0 @@
-# Seneca provider target — a Seneca plugin that exposes this API's entities
-# as Seneca entities (`provider/<name>/<entity>`), layered on the sibling
-# `ts` SDK. It is not a language SDK in its own right, so every standard
-# generation phase is switched off below and Main_seneca-provider emits the
-# whole package, exactly as go-cli / go-mcp / py-data do.
-#
-# Requires the `ts` target in the same SDK project (Main throws when it is
-# absent): the plugin imports the published TypeScript SDK.
-#
-# UNLIKE the other consumer targets, this one generates into ITS OWN REPO.
-# A Seneca provider is an independently released npm package under the
-# @seneca scope, with its own LICENSE, CI workflow and release cadence, and
-# it depends on the SDK as an ordinary published dependency rather than by
-# path. Point it at that repo from the PROJECT model:
-#
-#   main: kit: target: 'seneca-provider': output: path: '../../seneca/seneca-acme-provider'
-#
-# Relative to the SDK repo root. Left unset here on purpose — every project's
-# provider repo is somewhere different, and a concrete value here would
-# CONFLICT with the project's rather than yield to it (see the publication
-# note below). Unset means the ordinary in-tree `<sdk-repo>/seneca-provider/`,
-# which is a usable default for a first look at the output.
-
-main: kit: target: 'seneca-provider': {
-
-  title: 'Seneca Provider'
-  ext: ts
-  comment: line: "//"
-  module: name: '$$name$$'
-  base: 'BASE'
-  srcfeature: false
-
-  # Per-generation-phase activation. Mirrors py-data: every standard phase is
-  # off and Main emits the package. README, docs and tests ARE generated — by
-  # Main, not by the standard cmps, which assume an SDK-shaped package and
-  # would emit wrong content here.
-  phase: {
-    entity:     { active: false }
-    feature:    { active: false }
-    readme:     { active: false }
-    agentguide: { active: false }
-    test:       { active: false }
-  }
-
-  # `kind` is a COMMA-SEPARATED LIST of manifest sections, not a single one.
-  # collectDeps deduplicates by package name and this map is keyed by name, so
-  # a package belonging in two sections cannot be declared twice — it says so
-  # here instead. See `seneca` below for the case that forced it.
-  deps: &: {
-    kind: *'prod' | string
-  }
-
-  # The Seneca plugin contract. `@seneca/provider` supplies entityBuilder and
-  # the keymap message this plugin's `prepare` posts; the rest are the host
-  # framework a plugin runs inside and so are PEER deps — a plugin that
-  # bundled its own seneca would run against a different instance than the
-  # application it is loaded into.
-  #
-  # The ts SDK dependency is emitted by Main from the model's published
-  # package name, so it is not declared here.
-  deps: {
-    '@seneca/maintain':  { active: true, version: '^0.1.0', kind: prod }
-
-    '@seneca/env':       { active: true, version: '>=0.4',  kind: peer }
-    '@seneca/provider':  { active: true, version: '>=4',    kind: peer }
-
-    # PEER *and* DEV. Peer for the reason above — the plugin must attach to
-    # the host application's seneca instance. Dev because the generated test
-    # suite does `require('seneca')` itself, so a clean `npm install && npm
-    # test` in a fresh checkout has to produce one. Relying on npm's automatic
-    # peer installation instead is what dropping this from the manifest
-    # amounted to, and that is npm-version- and client-specific: pnpm and
-    # `--legacy-peer-deps` both leave the suite with no seneca to require.
-    'seneca':            { active: true, version: '>=3||>=4.0.0-rc2', kind: 'peer,dev' }
-
-    'seneca-entity':     { active: true, version: '>=26',   kind: peer }
-    'seneca-promisify':  { active: true, version: '>=3',    kind: peer }
-
-    '@seneca/doc':       { active: true, version: '^8.0.0', kind: dev }
-    '@types/node':       { active: true, version: '^24.0.0', kind: dev }
-    'seneca-msg-test':   { active: true, version: '^4.1.0', kind: dev }
-    'typescript':        { active: true, version: '^5.4.5', kind: dev }
-  }
-}
-
-
-# Feature-deps map slot — every target carries this so the same feature can
-# specify per-target dep variants.
-main: kit: feature: &: target: 'seneca-provider': deps: &: {
-  kind: *'prod' | string
-}
-
-
-# Publication: npm registry, under the @seneca scope rather than the SDK's
-# own. The package name is NOT derived from the SDK slug the way a language
-# target's is — a provider is `@seneca/<name>-provider` — so Main sets it
-# from the model and a project can pin it like any other.
-#
-# `target add <t>` OVERWRITES this file, so a project must never set its
-# publication values here — voxgig-solardemo-sdk lost its pinned npm package
-# name exactly that way. Set them in the project's own overlay
-# (`model/project.aon`), which create-sdkgen creates once and never
-# overwrites — NOT `model/sdk.aon`, which it rewrites on every scaffold.
-#
-# For that to work this file must LEAVE THOSE KEYS UNSET: in aontu a concrete
-# value does not yield to another concrete value, it CONFLICTS, and two
-# defaults conflict too. The schema (@voxgig/sdkgen/model/sdkgen.aon)
-# already defaults `tag.active`, `registry.state`, `registry.active` and
-# `registry.package`, so a project's concrete value wins over the default and
-# repeating them here would only take that away.
-#
-# What remains below is per-target registry IDENTITY, which is not a project
-# choice and stays concrete.
-main: kit: target: 'seneca-provider': publish: {
-  registry: {
-    name: 'npm'
-    url: 'https://registry.npmjs.org'
-    vault: { recipe: 'npm', alias: 'npm' }
-  }
-}

package/project/.sdk/src/cmp/dart/Config_dart.ts

@@ -1,176 +0,0 @@
-
-import * as Path from 'node:path'
-
-
-import {
-  File,
-  Fragment,
-  Line,
-  cmp,
-  configDefinition,
-  configReprSetting,
-  each,
-  isConfigData,
-  isAuthActive,
-  resolveAuthPrefix,
-  targetFeatures,
-} from '@voxgig/sdkgen'
-
-
-import {
-  KIT,
-  Model,
-  getModelPath,
-  nom,
-} from '@voxgig/apidef'
-
-
-import {
-  dartStringLiteral,
-  dartValue,
-} from './utility_dart'
-
-
-const Config = cmp(async function Config(props: any) {
-  const ctx$ = props.ctx$
-  const target = props.target
-
-  const model: Model = ctx$.model
-
-  const entity = getModelPath(model, `main.${KIT}.entity`)
-  // Gated by the applicability tags, so this target never imports or
-  // registers a feature it has no source for. One rule, one place:
-  // helpers/applicability.
-  const feature = targetFeatures(model, target)
-
-  const ff = Path.normalize(__dirname + '/../../../src/cmp/dart/fragment/')
-
-  const headers = getModelPath(model, `main.${KIT}.config.headers`) || {}
-
-  const authActive = isAuthActive(model)
-  // config.auth.prefix override -> spec-derived info.security.prefix -> 'Bearer'
-  const authPrefix = resolveAuthPrefix(model)
-  const authBlock = authActive
-    ? `'auth': <String, dynamic>{
-      'prefix': '${authPrefix}',
-    },
-
-    `
-    : ''
-
-  // Read the base URL here rather than leaving it to a `$$...$$` stdrep
-  // placeholder in the fragment. stdrep can only substitute a path the model
-  // actually has: a model with no `info.servers` left the placeholder itself in
-  // the generated source, so `options.base` came out as the literal string
-  // '$main.kit.info.servers.0.url$'. Reading it explicitly yields '' in that
-  // case, which is what every other target already emits, and is identical to
-  // the old output whenever the model does define a server. Same defect, and
-  // same fix, as ts and js.
-  let baseUrl = ''
-  try {
-    baseUrl = getModelPath(model, `main.${KIT}.info.servers.0.url`)
-  } catch (_e) { }
-
-  // The same config as an OBJECT, built by the shared helper so this target's
-  // literal and the data that replaces it above the threshold are the same
-  // config by construction. The JSON is what the threshold is measured on -
-  // emitted source size varies by language, the model does not. Passing
-  // target.name opts this target into the main slug/version/target identity
-  // fields (read by station's descriptor - see configDefinition).
-  const { def: configDef, json: configJson } = configDefinition(model, target.name)
-  const asData = isConfigData(configJson, configReprSetting(model))
-
-  File({ name: 'Config.' + target.ext }, () => {
-
-    // ABOVE THE THRESHOLD: emit the model as DATA.
-    //
-    // `jsonDecode` yields exactly what the literal declared - Map<String,
-    // dynamic> for objects, List<dynamic> for arrays, and int for a whole
-    // number where Dart source would also have written an int - so the fields
-    // keep their types and callers cannot tell the representations apart.
-    if (asData) {
-      Fragment({
-        from: ff + 'Config.data.fragment.dart',
-
-        replace: {
-          ...ctx$.stdrep,
-
-          '// #ImportFeatures': () => each(feature, (f: any) => {
-            Line(`import 'feature/${f.name}/${nom(f, 'Name')}Feature.dart';`)
-          }),
-
-          '// #FeatureClasses': () => each(feature, (f: any) => {
-            Line(`  '${f.name}': () => ${nom(f, 'Name')}Feature(),`)
-          }),
-
-          "'CONFIGJSON'": dartStringLiteral(configJson),
-        }
-      })
-      return
-    }
-
-    Fragment({
-      from: ff + 'Config.fragment.dart',
-
-      replace: {
-
-        // Config.fragment.dart carries `'name': 'ProjectName'` — without the
-        // standard replacements the generated SDK reports "ProjectName" as its
-        // own name at runtime. Every sibling dart component already spreads
-        // these; this one did not.
-        ...ctx$.stdrep,
-
-        // Identity beyond the camel Name: slug/version/target (station
-        // descriptor inputs). Values from configDefinition's def, not
-        // re-derived here, so the literal rep and the data rep cannot
-        // disagree (the Config_ts #MainMeta discipline).
-        '// #MainMeta': () => {
-          Line(`    'slug': ${dartValue(configDef.main.slug)},`)
-          Line(`    'version': ${dartValue(configDef.main.version)},`)
-          Line(`    'target': ${dartValue(configDef.main.target)},`)
-        },
-
-        // The whole options map from the canonical definition. Assembling it
-        // slot by slot lost `options.server` entirely, so a spec with a
-        // templated server URL described a different config either side of the
-        // threshold.
-        "'OPTIONSMAP'": dartValue(configDef.options, 1),
-
-        '// #ImportFeatures': () => each(feature, (f: any) => {
-          Line(`import 'feature/${f.name}/${nom(f, 'Name')}Feature.dart';`)
-        }),
-
-        '// #FeatureClasses': () => each(feature, (f: any) => {
-          // Trailing comma: the map has one entry per feature, so entries
-          // must be comma-separated (a single feature hid this until now).
-          Line(`  '${f.name}': () => ${nom(f, 'Name')}Feature(),`)
-        }),
-
-        // Rendered from configDefinition's def, not from f.config, so the
-        // literal carries the feature's `transport` role (station design
-        // §8.4) beside its options and cannot drift from the data rep.
-        '// #FeatureConfigs': () => each(feature, (f: any) => {
-          Line(`    '${f.name}': ${dartValue(configDef.feature[f.name], 2)},`)
-        }),
-
-
-        '// #EntityConfigs': () => each(entity, (entity: any) => {
-          Line(`      '${entity.name}': <String, dynamic>{},`)
-        }),
-
-        // configDefinition's `def.entity` verbatim, NOT rebuilt here. This
-        // reduce was a second copy of that function's entityDefs loop, and
-        // when configDefinition started reconstructing a point's `parts`
-        // from apidef's segment vector (its ADR-003), only the data
-        // representation got it — the literal one emitted empty paths. The
-        // config-repr equivalence test caught it, which is what it is for.
-        "'ENTITYMAP'": dartValue(configDef.entity, 1),
-      }
-    })
-  })
-})
-
-
-export {
-  Config
-}