@owlmeans/viable-common 0.0.43 → 0.0.45

package/src/skills/consts.ts

@@ -85,3 +85,49 @@ export enum ViableSkill {
   LibrariesAi = 'libraries-ai',
   LibrariesGame = 'libraries-game',
 }
+
+/**
+ * Who the model is being asked to be.
+ *
+ * A persona is per HELPER, not per model role: `ModelRole` selects which model answers,
+ * this selects what it is told it does. Two helpers can share a model and need different
+ * personas, and the same persona can run on a cheap or an expensive model depending on
+ * the effort tier — keeping the two axes separate is what makes that possible.
+ */
+export enum ViablePersona {
+  BusinessAnalyst = 'business-analyst',
+  ProductNaming = 'product-naming',
+  /** Decides what KIND of product a prompt describes — which blueprint case builds it. */
+  ProductArchitect = 'product-architect',
+  UxDesigner = 'ux-designer',
+  VisualDesigner = 'visual-designer',
+
+  LayoutArchitect = 'layout-architect',
+  ComponentArchitect = 'component-architect',
+  StateArchitect = 'state-architect',
+  NavigationArchitect = 'navigation-architect',
+  DomainTypesArchitect = 'domain-types-architect',
+  AccessArchitect = 'access-architect',
+  ApiArchitect = 'api-architect',
+  DatalayerArchitect = 'datalayer-architect',
+  BackendDomainArchitect = 'backend-domain-architect',
+
+  CommonCoder = 'common-coder',
+  UiStateCoder = 'ui-state-coder',
+  UiViewCoder = 'ui-view-coder',
+  UiNavCoder = 'ui-nav-coder',
+  DatalayerCoder = 'datalayer-coder',
+  ApiCoder = 'api-coder',
+  BackendModelCoder = 'backend-model-coder',
+  /** Decides whether a story needs a queue, a worker or an agent — and usually decides it does not. */
+  RuntimeArchitect = 'runtime-architect',
+  /** Writes queue declarations, job processors and the application's own agents. */
+  WorkerCoder = 'worker-coder',
+  FreeFlightCoder = 'free-flight-coder',
+
+  Fixer = 'fixer',
+  Orchestrator = 'orchestrator',
+  SourceExtractor = 'source-extractor',
+  DeclarationLookup = 'declaration-lookup',
+  FixAgent = 'fix-agent',
+}

package/src/skills/index.ts

@@ -1,3 +1,2 @@
 
 export * from './consts.js'
-export * from './roles.js'

package/src/slot/command/types.ts

@@ -0,0 +1,21 @@
+import type { SlotCommandType } from '../consts.js'
+
+/** The time bounds of one slot command: the caller's timeout and the executor's deadline. */
+export interface SlotCommandHelper {
+  /**
+   * Resolve the caller-side bound for one command.
+   *
+   * One function rather than three lookups at each call site: an asker that forgets the per-command
+   * table inherits twenty minutes for a fifteen-second command, which is the failure this table was
+   * added to stop.
+   */
+  commandTimeout: (type: SlotCommandType, command: string, override?: number) => number
+  /**
+   * Resolve the executor-side deadline for one command.
+   *
+   * Per-command first, per-type second. It was per-type only, which is how a clone inherited the
+   * bound of a `git status` — the same shape as the shell table above, and added for the same
+   * reason.
+   */
+  commandDeadline: (type: SlotCommandType, command: string) => number
+}

package/src/slot/command.ts

@@ -0,0 +1,38 @@
+import { COMMAND_DEADLINES, COMMAND_TIMEOUTS, DEFAULT_COMMAND_DEADLINE, DEFAULT_COMMAND_TIMEOUT, DEFAULT_FILE_COMMAND_DEADLINE, DEFAULT_GIT_COMMAND_DEADLINE, FILE_COMMAND_DEADLINES, FILE_COMMAND_TIMEOUTS, GIT_COMMAND_DEADLINES, GIT_COMMAND_TIMEOUTS, SHELL_COMMAND_TIMEOUTS, SlotCommandType, SlotFileCommand, SlotGitCommand } from './consts.js'
+import type { SlotCommandHelper } from './command/types.js'
+
+export const createSlotCommandHelper = (): SlotCommandHelper => {
+  /** The per-command caller bound for one command, or nothing where its type's default is right. */
+  const perCommandTimeout = (type: SlotCommandType, command: string): number | undefined => {
+    switch (type) {
+      case SlotCommandType.Shell: return SHELL_COMMAND_TIMEOUTS[command]
+      case SlotCommandType.Git: return GIT_COMMAND_TIMEOUTS[command as SlotGitCommand]
+      case SlotCommandType.Database: return COMMAND_TIMEOUTS[SlotCommandType.Database]
+      default: return FILE_COMMAND_TIMEOUTS[command as SlotFileCommand]
+    }
+  }
+
+  const commandTimeout = (
+    type: SlotCommandType, command: string, override?: number
+  ): number => override
+    ?? perCommandTimeout(type, command)
+    ?? COMMAND_TIMEOUTS[type]
+    ?? DEFAULT_COMMAND_TIMEOUT
+
+  const commandDeadline = (type: SlotCommandType, command: string): number => {
+    switch (type) {
+      case SlotCommandType.Shell:
+        return COMMAND_DEADLINES[command] ?? DEFAULT_COMMAND_DEADLINE
+      case SlotCommandType.Git:
+        return GIT_COMMAND_DEADLINES[command as SlotGitCommand] ?? DEFAULT_GIT_COMMAND_DEADLINE
+      case SlotCommandType.Database:
+        return 30_000
+      default:
+        return FILE_COMMAND_DEADLINES[command as SlotFileCommand] ?? DEFAULT_FILE_COMMAND_DEADLINE
+    }
+  }
+
+  return { commandTimeout, commandDeadline }
+}
+
+export const slotCommandHelper = createSlotCommandHelper()

package/src/slot/consts.ts

@@ -19,6 +19,8 @@
  * commands are executed by the connector on that machine, and nothing about it is provisioned,
  * routed, reconciled or published.
  */
+import { TargetLayout } from '../integrity/index.js'
+
 export enum WorkloadKind {
   Ephemeral = 'ephemeral',
   Production = 'production',
@@ -368,46 +370,15 @@ export const FILE_COMMAND_TIMEOUTS: Partial<Record<SlotFileCommand, number>> = {
   [SlotFileCommand.ReadHead]: 70_000,
 }
 
-/** The per-command caller bound for one command, or nothing where its type's default is right. */
-const perCommandTimeout = (type: SlotCommandType, command: string): number | undefined => {
-  switch (type) {
-    case SlotCommandType.Shell: return SHELL_COMMAND_TIMEOUTS[command]
-    case SlotCommandType.Git: return GIT_COMMAND_TIMEOUTS[command as SlotGitCommand]
-    case SlotCommandType.Database: return COMMAND_TIMEOUTS[SlotCommandType.Database]
-    default: return FILE_COMMAND_TIMEOUTS[command as SlotFileCommand]
-  }
-}
-
-/**
- * Resolve the caller-side bound for one command.
- *
- * One function rather than three lookups at each call site: an asker that forgets the per-command
- * table inherits twenty minutes for a fifteen-second command, which is the failure this table was
- * added to stop.
- */
-export const commandTimeout = (
-  type: SlotCommandType, command: string, override?: number
-): number => override
-  ?? perCommandTimeout(type, command)
-  ?? COMMAND_TIMEOUTS[type]
-  ?? DEFAULT_COMMAND_TIMEOUT
-
 /**
- * Resolve the executor-side deadline for one command.
+ * The one marker per layout, chosen because it exists in that layout and in no other.
  *
- * Per-command first, per-type second. It was per-type only, which is how a clone inherited the
- * bound of a `git status` — the same shape as the shell table above, and added for the same
- * reason.
+ * `sources/api` cannot appear in a v1 tree and `packages/backend` cannot appear in a v2 one, so a
+ * single `stat` settles it. Deliberately not `sources/` alone: v1 packages each have their own
+ * `src`, and a directory name that differs by one letter is not something to hang a runtime path
+ * resolution on. Ordered — the first marker found wins.
  */
-export const commandDeadline = (type: SlotCommandType, command: string): number => {
-  switch (type) {
-    case SlotCommandType.Shell:
-      return COMMAND_DEADLINES[command] ?? DEFAULT_COMMAND_DEADLINE
-    case SlotCommandType.Git:
-      return GIT_COMMAND_DEADLINES[command as SlotGitCommand] ?? DEFAULT_GIT_COMMAND_DEADLINE
-    case SlotCommandType.Database:
-      return 30_000
-    default:
-      return FILE_COMMAND_DEADLINES[command as SlotFileCommand] ?? DEFAULT_FILE_COMMAND_DEADLINE
-  }
-}
+export const LAYOUT_MARKERS: Array<[TargetLayout, string]> = [
+  [TargetLayout.V2, 'sources/api'],
+  [TargetLayout.V1, 'packages/backend'],
+]

package/src/slot/helpers.ts

@@ -1,34 +1,9 @@
-import { WorkloadKind } from './consts.js'
+import { slotOriginHelper } from './origin.js'
+import type { AddressableSlot } from './types.js'
 
-/** The minimum a caller must know about a slot to address it. */
-export interface AddressableSlot {
-  kind?: WorkloadKind
-  host?: string
-}
+/** @deprecated compat:factory-refactor — use `slotOriginHelper.slotOrigin(…)` */
+export const slotOrigin = (slot: AddressableSlot): string => slotOriginHelper.slotOrigin(slot)
 
-/**
- * The origin a slot's application answers at.
- *
- * Read back from the slot's stored `host`, never recomposed from a slug — a preview host is a
- * CLAIMED resource with a certificate behind it, and the name a slot ended up with is not always
- * the name its project would compose today. What this adds is the scheme, which is the one part
- * that follows from the kind rather than from the record: a local target is a loopback address and
- * therefore `http`, everything else is TLS-terminated at an edge and therefore `https`.
- */
-export const slotOrigin = (slot: AddressableSlot): string => {
-  const host = slot.host ?? ''
-  if (host === '') return ''
-  if (host.startsWith('http://') || host.startsWith('https://')) return host
-
-  return `${slot.kind === WorkloadKind.Local ? 'http' : 'https'}://${host}`
-}
-
-/**
- * The exact redirect URIs a target's OIDC client must carry for one origin.
- *
- * Exact, because a provider matches a redirect URI literally and refuses a wildcard — and both
- * entries are needed: the callback the login round trip returns to, and the bare origin, which is
- * where the application's own logout lands.
- */
+/** @deprecated compat:factory-refactor — use `slotOriginHelper.targetRedirectUrisForOrigin(…)` */
 export const targetRedirectUrisForOrigin = (origin: string, callbackPath: string): string[] =>
-  origin === '' ? [] : [origin, `${origin}${callbackPath}`]
+  slotOriginHelper.targetRedirectUrisForOrigin(origin, callbackPath)

package/src/slot/index.ts

@@ -1,5 +1,11 @@
 export * from './consts.js'
+export * from './command.js'
+export * from './utils.js'
 export * from './schemas.js'
 export * from './layout.js'
+export * from './origin.js'
 export * from './helpers.js'
 export type * from './types.js'
+export type * from './command/types.js'
+export type * from './layout/types.js'
+export type * from './origin/types.js'

package/src/slot/layout/types.ts

@@ -0,0 +1,17 @@
+import type { TargetLayout } from '../../integrity/consts.js'
+import type { SubProject } from '../consts.js'
+import type { TargetPaths } from '../types.js'
+
+/** Where a target's roles live, per layout — read off {@link LAYOUTS} and {@link ROLE_DIRS}. */
+export interface SlotLayoutHelper {
+  /**
+   * Resolve a wire-level role to the directory it names in a given layout.
+   *
+   * An unknown value — a role from a sender newer than this reader — falls back to the role's own
+   * name, which is the honest guess for a layout whose packages are named after their roles, and
+   * which fails visibly rather than resolving to some other package's directory.
+   */
+  subprojectDirOf: (layout: TargetLayout, role: SubProject) => string
+  /** Where every role lives, for a layout already decided. */
+  pathsOf: (layout: TargetLayout) => TargetPaths
+}

package/src/slot/layout.ts

@@ -1,55 +1,8 @@
 import { TargetLayout } from '../integrity/index.js'
-import { packageForRole, resolveTopology, topologyOf } from '../topology/index.js'
+import { topologyHelper } from '../topology/resolve.js'
 import { SubProject } from './consts.js'
-
-/**
- * Where each role lives, for one layout. Directory names are target-root-relative.
- *
- * The pure half of layout resolution. Whoever holds the tree — the publisher over a pod volume,
- * the connector over a directory on a developer's machine — adds the two filesystem probes that
- * pick the layout and turn these names into absolute paths. The TABLES are shared so the two
- * cannot disagree about what a role means.
- */
-export interface TargetPaths {
-  layout: TargetLayout
-  /** The directory holding the workspace packages — `packages` or `sources`. */
-  dir: string
-  /** The package whose `dist/index.js` runs as the target's HTTP server. */
-  api: string
-  /** The package whose `dist/` is served to a browser. */
-  web: string
-  /** The shared library the other two compile against. */
-  common: string
-  /**
-   * The package whose `dist/index.js` runs as the target's queue worker, when the target has one.
-   *
-   * Absent for v1, which had no such package and never will — a target's tree is the one it was
-   * initialized with. Present for v2 as a NAME, not as a promise: every caller checks the disk
-   * before acting on it.
-   */
-  worker?: string
-  /**
-   * Every package a full build runs, in dependency order.
-   *
-   * Longer than the three roles for v2, whose `backend` is a library that both `api` and `worker`
-   * import. A caller skips whatever is not on disk — a target need not have a worker.
-   */
-  build: string[]
-  /**
-   * The packages built with `tsc -b` and consumed through their `build/` output, in dependency
-   * order — never bundled, so their output has to be on disk at RUN time, not only at build time.
-   *
-   * The bundled packages keep every dependency external, so `bun dist/index.js` resolves
-   * `project-backend` from `node_modules` at startup, follows its `main` to `build/index.js` — and
-   * if nothing built it, Bun answers `Cannot find package 'project-backend'` and the target exits 1
-   * with a message that names a dependency rather than a missing build.
-   *
-   * v1 got away without this list: it had ONE library and the template shipped its `build/`
-   * prebuilt. v2 deleted those artifacts and added a second library, so every path that builds a
-   * target has to build these first or it can never start.
-   */
-  libraries: string[]
-}
+import type { TargetPaths } from './types.js'
+import type { SlotLayoutHelper } from './layout/types.js'
 
 /**
  * Where every role lives, per layout — DERIVED from that layout's topology.
@@ -63,8 +16,8 @@ export interface TargetPaths {
  * The VALUES are unchanged, and `topology.spec.ts` pins them against the tables they replaced.
  */
 const pathsOfTopology = (layout: TargetLayout): TargetPaths => {
-  const topology = resolveTopology(topologyOf(layout))
-  const dirOf = (role: SubProject): string | undefined => packageForRole(topology, role)?.name
+  const topology = topologyHelper.resolveTopology(topologyHelper.topologyOf(layout))
+  const dirOf = (role: SubProject): string | undefined => topologyHelper.packageForRole(topology, role)?.name
 
   return {
     layout,
@@ -100,10 +53,10 @@ export const LAYOUTS: Record<TargetLayout, TargetPaths> = {
  * so an unmapped role falls back to its own name here, which is that same visible failure.
  */
 const roleDirsOfTopology = (layout: TargetLayout): Record<SubProject, string> => {
-  const topology = resolveTopology(topologyOf(layout))
+  const topology = topologyHelper.resolveTopology(topologyHelper.topologyOf(layout))
 
   return Object.values(SubProject).reduce<Record<SubProject, string>>((dirs, role) => {
-    dirs[role] = packageForRole(topology, role)?.name ?? role
+    dirs[role] = topologyHelper.packageForRole(topology, role)?.name ?? role
 
     return dirs
   }, {} as Record<SubProject, string>)
@@ -114,28 +67,17 @@ export const ROLE_DIRS: Record<TargetLayout, Record<SubProject, string>> = {
   [TargetLayout.V2]: roleDirsOfTopology(TargetLayout.V2),
 }
 
-/**
- * The one marker per layout, chosen because it exists in that layout and in no other.
- *
- * `sources/api` cannot appear in a v1 tree and `packages/backend` cannot appear in a v2 one, so a
- * single `stat` settles it. Deliberately not `sources/` alone: v1 packages each have their own
- * `src`, and a directory name that differs by one letter is not something to hang a runtime path
- * resolution on. Ordered — the first marker found wins.
- */
-export const LAYOUT_MARKERS: Array<[TargetLayout, string]> = [
-  [TargetLayout.V2, 'sources/api'],
-  [TargetLayout.V1, 'packages/backend'],
-]
+export const createSlotLayoutHelper = (): SlotLayoutHelper => {
+  const subprojectDirOf = (layout: TargetLayout, role: SubProject): string =>
+    ROLE_DIRS[layout][role] ?? role
 
-/**
- * Resolve a wire-level role to the directory it names in a given layout.
- *
- * An unknown value — a role from a sender newer than this reader — falls back to the role's own
- * name, which is the honest guess for a layout whose packages are named after their roles, and
- * which fails visibly rather than resolving to some other package's directory.
- */
-export const subprojectDirOf = (layout: TargetLayout, role: SubProject): string =>
-  ROLE_DIRS[layout][role] ?? role
+  const pathsOf = (layout: TargetLayout): TargetPaths => LAYOUTS[layout]
 
-/** Where every role lives, for a layout already decided. */
-export const pathsOf = (layout: TargetLayout): TargetPaths => LAYOUTS[layout]
+  return { subprojectDirOf, pathsOf }
+}
+
+export const slotLayoutHelper = createSlotLayoutHelper()
+
+/** @deprecated compat:factory-refactor — use `slotLayoutHelper.subprojectDirOf(…)` */
+export const subprojectDirOf = (layout: TargetLayout, role: SubProject): string =>
+  slotLayoutHelper.subprojectDirOf(layout, role)

package/src/slot/origin/types.ts

@@ -0,0 +1,23 @@
+import type { AddressableSlot } from '../types.js'
+
+/** Where a slot's application answers, and the redirect URIs its OIDC client needs there. */
+export interface SlotOriginHelper {
+  /**
+   * The origin a slot's application answers at.
+   *
+   * Read back from the slot's stored `host`, never recomposed from a slug — a preview host is a
+   * CLAIMED resource with a certificate behind it, and the name a slot ended up with is not always
+   * the name its project would compose today. What this adds is the scheme, which is the one part
+   * that follows from the kind rather than from the record: a local target is a loopback address and
+   * therefore `http`, everything else is TLS-terminated at an edge and therefore `https`.
+   */
+  slotOrigin: (slot: AddressableSlot) => string
+  /**
+   * The exact redirect URIs a target's OIDC client must carry for one origin.
+   *
+   * Exact, because a provider matches a redirect URI literally and refuses a wildcard — and both
+   * entries are needed: the callback the login round trip returns to, and the bare origin, which is
+   * where the application's own logout lands.
+   */
+  targetRedirectUrisForOrigin: (origin: string, callbackPath: string) => string[]
+}

package/src/slot/origin.ts

@@ -0,0 +1,20 @@
+import { WorkloadKind } from './consts.js'
+import type { AddressableSlot } from './types.js'
+import type { SlotOriginHelper } from './origin/types.js'
+
+export const createSlotOriginHelper = (): SlotOriginHelper => {
+  const slotOrigin = (slot: AddressableSlot): string => {
+    const host = slot.host ?? ''
+    if (host === '') return ''
+    if (host.startsWith('http://') || host.startsWith('https://')) return host
+
+    return `${slot.kind === WorkloadKind.Local ? 'http' : 'https'}://${host}`
+  }
+
+  const targetRedirectUrisForOrigin = (origin: string, callbackPath: string): string[] =>
+    origin === '' ? [] : [origin, `${origin}${callbackPath}`]
+
+  return { slotOrigin, targetRedirectUrisForOrigin }
+}
+
+export const slotOriginHelper = createSlotOriginHelper()

package/src/slot/types.ts

@@ -1,4 +1,5 @@
-import type { SlotCommandType, SlotDatabaseCommand, SlotFileCommand, SlotGitCommand, SlotShellCommand, SubProject } from './consts.js'
+import { type SlotCommandType, type SlotDatabaseCommand, type SlotFileCommand, type SlotGitCommand, type SlotShellCommand, type SubProject, WorkloadKind } from './consts.js'
+import { TargetLayout } from '../integrity/index.js'
 
 export type SlotCommand = SlotFileCommand | SlotShellCommand | SlotGitCommand | SlotDatabaseCommand
 
@@ -21,6 +22,7 @@ export interface SlotDatabaseQueryArgs {
   timeoutMs?: number
 }
 
+// Kept as a type: a union of the success and the failure shape.
 export type SlotDatabaseQueryResult = {
   ok: true
   columns: Array<{ name: string; dataType: string }>
@@ -191,3 +193,58 @@ export interface SlotShellArgs {
   args?: string
   skipBuild?: boolean
 }
+
+/** The minimum a caller must know about a slot to address it. */
+export interface AddressableSlot {
+  kind?: WorkloadKind
+  host?: string
+}
+
+/**
+ * Where each role lives, for one layout. Directory names are target-root-relative.
+ *
+ * The pure half of layout resolution. Whoever holds the tree — the publisher over a pod volume,
+ * the connector over a directory on a developer's machine — adds the two filesystem probes that
+ * pick the layout and turn these names into absolute paths. The TABLES are shared so the two
+ * cannot disagree about what a role means.
+ */
+export interface TargetPaths {
+  layout: TargetLayout
+  /** The directory holding the workspace packages — `packages` or `sources`. */
+  dir: string
+  /** The package whose `dist/index.js` runs as the target's HTTP server. */
+  api: string
+  /** The package whose `dist/` is served to a browser. */
+  web: string
+  /** The shared library the other two compile against. */
+  common: string
+  /**
+   * The package whose `dist/index.js` runs as the target's queue worker, when the target has one.
+   *
+   * Absent for v1, which had no such package and never will — a target's tree is the one it was
+   * initialized with. Present for v2 as a NAME, not as a promise: every caller checks the disk
+   * before acting on it.
+   */
+  worker?: string
+  /**
+   * Every package a full build runs, in dependency order.
+   *
+   * Longer than the three roles for v2, whose `backend` is a library that both `api` and `worker`
+   * import. A caller skips whatever is not on disk — a target need not have a worker.
+   */
+  build: string[]
+  /**
+   * The packages built with `tsc -b` and consumed through their `build/` output, in dependency
+   * order — never bundled, so their output has to be on disk at RUN time, not only at build time.
+   *
+   * The bundled packages keep every dependency external, so `bun dist/index.js` resolves
+   * `project-backend` from `node_modules` at startup, follows its `main` to `build/index.js` — and
+   * if nothing built it, Bun answers `Cannot find package 'project-backend'` and the target exits 1
+   * with a message that names a dependency rather than a missing build.
+   *
+   * v1 got away without this list: it had ONE library and the template shipped its `build/`
+   * prebuilt. v2 deleted those artifacts and added a second library, so every path that builds a
+   * target has to build these first or it can never start.
+   */
+  libraries: string[]
+}

package/src/slot/utils.ts

@@ -0,0 +1,10 @@
+import { slotCommandHelper } from './command.js'
+import type { SlotCommandType } from './consts.js'
+
+/** @deprecated compat:factory-refactor — use `slotCommandHelper.commandTimeout(…)` */
+export const commandTimeout = (type: SlotCommandType, command: string, override?: number): number =>
+  slotCommandHelper.commandTimeout(type, command, override)
+
+/** @deprecated compat:factory-refactor — use `slotCommandHelper.commandDeadline(…)` */
+export const commandDeadline = (type: SlotCommandType, command: string): number =>
+  slotCommandHelper.commandDeadline(type, command)

package/src/topology/card/types.ts

@@ -0,0 +1,21 @@
+import type { TopologyDescriptor, TopologyMeta } from '../types.js'
+
+/** The topology file `.agents/memory/topology.md`: its frontmatter, read and written, and its body. */
+export interface TopologyCardHelper {
+  /**
+   * Narrow a parsed frontmatter block into a topology, or answer `null`.
+   *
+   * `null` means "use the layout default", and every caller treats it that way. A topology file
+   * written by a platform version this one cannot read must not stop a project from building — the
+   * arrangement it describes is almost certainly still the default one.
+   */
+  parseTopologyMeta: (data: unknown) => TopologyDescriptor | null
+  topologyMeta: (topology: TopologyDescriptor) => TopologyMeta
+  /**
+   * The body of `.agents/memory/topology.md` — what a model reads, and what a person reads.
+   *
+   * Rendered from the descriptor rather than maintained beside it, for the same reason the layout
+   * tables are: a card that disagrees with the frontmatter teaches the wrong tree.
+   */
+  renderTopologyCard: (topology: TopologyDescriptor) => string
+}