@swarmclawai/swarmclaw 0.8.4 → 0.8.7

package/src/lib/server/perf.ts

@@ -0,0 +1,161 @@
+/**
+ * Lightweight performance tracing for critical server paths.
+ *
+ * Emits structured `[perf]` log lines with timing data so workbench tests
+ * can measure where time is spent during chat turns, tool calls, queue
+ * processing, and storage operations.
+ *
+ * Usage:
+ *   const end = perf.start('chat-execution', 'streamAgentChat', { sessionId })
+ *   // ... do work ...
+ *   end({ toolCount: 3, tokens: 1200 })
+ *
+ * Output:
+ *   [perf] chat-execution/streamAgentChat 1423ms {sessionId:"abc",toolCount:3,tokens:1200}
+ */
+
+interface PerfEntry {
+  category: string
+  label: string
+  durationMs: number
+  meta?: Record<string, unknown>
+}
+
+type OnEntryCallback = (entry: PerfEntry) => void
+
+// Disabled by default — workbench tests call perf.setEnabled(true) to activate.
+// The SWARMCLAW_PERF env var also enables it for CLI-level benchmarking.
+let _enabled = process.env.SWARMCLAW_PERF === '1'
+let _onEntry: OnEntryCallback | null = null
+const _recentEntries: PerfEntry[] = []
+const MAX_RECENT = 200
+
+function emitEntry(entry: PerfEntry): void {
+  _recentEntries.push(entry)
+  if (_recentEntries.length > MAX_RECENT) _recentEntries.shift()
+
+  if (_onEntry) {
+    try { _onEntry(entry) } catch { /* listener errors are non-critical */ }
+  }
+
+  const metaStr = entry.meta && Object.keys(entry.meta).length > 0
+    ? ' ' + JSON.stringify(entry.meta)
+    : ''
+  console.log(`[perf] ${entry.category}/${entry.label} ${entry.durationMs}ms${metaStr}`)
+}
+
+const _noopEnd = () => 0
+
+/**
+ * Start a performance measurement. Returns a function that, when called,
+ * records the elapsed time and emits a log entry.
+ *
+ * When perf is disabled (default in production), returns a shared no-op —
+ * zero allocation overhead.
+ */
+function start(
+  category: string,
+  label: string,
+  meta?: Record<string, unknown>,
+): (extraMeta?: Record<string, unknown>) => number {
+  if (!_enabled) return _noopEnd
+  const t0 = performance.now()
+  return (extraMeta?: Record<string, unknown>) => {
+    const durationMs = Math.round(performance.now() - t0)
+    const merged = (meta || extraMeta)
+      ? { ...meta, ...extraMeta }
+      : undefined
+    emitEntry({ category, label, durationMs, meta: merged })
+    return durationMs
+  }
+}
+
+/**
+ * Measure an async function. Returns the function's result.
+ */
+async function measureAsync<T>(
+  category: string,
+  label: string,
+  fn: () => Promise<T>,
+  meta?: Record<string, unknown>,
+): Promise<T> {
+  const end = start(category, label, meta)
+  try {
+    const result = await fn()
+    end()
+    return result
+  } catch (err) {
+    end({ error: true })
+    throw err
+  }
+}
+
+/**
+ * Measure a synchronous function. Returns the function's result.
+ */
+function measureSync<T>(
+  category: string,
+  label: string,
+  fn: () => T,
+  meta?: Record<string, unknown>,
+): T {
+  const end = start(category, label, meta)
+  try {
+    const result = fn()
+    end()
+    return result
+  } catch (err) {
+    end({ error: true })
+    throw err
+  }
+}
+
+/** Enable/disable perf tracing at runtime. */
+function setEnabled(enabled: boolean): void { _enabled = enabled }
+
+/** Check if perf tracing is enabled. */
+function isEnabled(): boolean { return _enabled }
+
+/** Register a callback for every perf entry (useful for tests/workbench). */
+function onEntry(cb: OnEntryCallback | null): void { _onEntry = cb }
+
+/** Get recent perf entries (ring buffer, max 200). */
+function getRecentEntries(): readonly PerfEntry[] { return _recentEntries }
+
+/** Clear the recent entries buffer. */
+function clearRecentEntries(): void { _recentEntries.length = 0 }
+
+/**
+ * Wrap a Next.js API route handler with perf timing.
+ * Usage: export const GET = withApiPerf('GET /api/agents', handler)
+ */
+function withApiPerf<T extends (...args: unknown[]) => Promise<Response>>(
+  label: string,
+  handler: T,
+): T {
+  return (async (...args: unknown[]) => {
+    const end = start('api', label)
+    try {
+      const response = await handler(...args)
+      end({ status: response.status })
+      return response
+    } catch (err) {
+      end({ error: true })
+      throw err
+    }
+  }) as T
+}
+
+export const perf = {
+  start,
+  measureAsync,
+  measureSync,
+  setEnabled,
+  isEnabled,
+  onEntry,
+  getRecentEntries,
+  clearRecentEntries,
+  withApiPerf,
+}
+
+export type { PerfEntry }

package/src/lib/server/plugins-approval-guidance.ts

@@ -0,0 +1,115 @@
+import type { PluginHooks, PluginToolDef } from '@/types'
+import { canonicalizePluginId, expandPluginIds } from './tool-aliases'
+import { dedup } from '@/lib/shared-utils'
+
+type ApprovalGuidanceHook = NonNullable<PluginHooks['getApprovalGuidance']>
+
+function trimString(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : ''
+}
+
+function normalizeApprovalGuidanceLines(
+  value: string | string[] | null | undefined,
+): string[] {
+  if (typeof value === 'string') {
+    const trimmed = value.trim()
+    return trimmed ? [trimmed] : []
+  }
+  if (!Array.isArray(value)) return []
+  return value
+    .map((line) => (typeof line === 'string' ? line.trim() : ''))
+    .filter(Boolean)
+}
+
+function dedupeApprovalGuidanceLines(lines: string[]): string[] {
+  return dedup(lines.map((line) => line.trim()).filter(Boolean))
+}
+
+function formatApprovalToolLabel(toolNames: string[]): string {
+  const uniqueNames = dedup(toolNames.map((name) => name.trim()).filter(Boolean))
+  if (uniqueNames.length === 0) return 'its tools'
+  if (uniqueNames.length === 1) return `\`${uniqueNames[0]}\``
+  if (uniqueNames.length === 2) return `\`${uniqueNames[0]}\` and \`${uniqueNames[1]}\``
+  return `${uniqueNames.slice(0, -1).map((name) => `\`${name}\``).join(', ')}, and \`${uniqueNames.at(-1)}\``
+}
+
+function buildDefaultPluginApprovalGuidance(params: {
+  pluginId: string
+  pluginName: string
+  tools: PluginToolDef[]
+}): ApprovalGuidanceHook {
+  const toolNames = params.tools
+    .map((tool) => (typeof tool?.name === 'string' ? tool.name.trim() : ''))
+    .filter(Boolean)
+  const toolLabel = formatApprovalToolLabel(toolNames)
+  const matchIds = new Set(
+    dedupeApprovalGuidanceLines([
+      params.pluginId,
+      ...toolNames,
+      ...expandPluginIds([params.pluginId]),
+      ...toolNames.flatMap((toolName) => expandPluginIds([toolName])),
+    ]).map((value) => canonicalizePluginId(value) || value.toLowerCase()),
+  )
+
+  return ({ approval, phase, approved }) => {
+    if (approval.category !== 'tool_access') return null
+    const requestedIds = [
+      trimString(approval.data.pluginId),
+      trimString(approval.data.toolId),
+      trimString(approval.data.toolName),
+    ].filter(Boolean)
+    const matchesPlugin = requestedIds.some((value) => {
+      const candidates = [value, ...expandPluginIds([value])]
+      return candidates.some((candidate) => matchIds.has(canonicalizePluginId(candidate) || candidate.toLowerCase()))
+    })
+    if (!matchesPlugin) return null
+
+    if (phase === 'connector_reminder') {
+      return `Approving this lets the agent use ${toolLabel} from ${params.pluginName}.`
+    }
+    if (approved === true) {
+      return [
+        `Access to ${params.pluginName} is approved. Continue with ${toolLabel} on the next turn.`,
+        'Do not request the same access again in prose once it has been approved.',
+      ]
+    }
+    if (approved === false) {
+      return `Do not request access to ${params.pluginName} again unless the task or required capability materially changes.`
+    }
+    return [
+      `If access to ${params.pluginName} is granted, continue with ${toolLabel} on the next turn.`,
+      'Do not ask for the same access again in prose while this approval is pending.',
+    ]
+  }
+}
+
+function composeApprovalGuidance(
+  defaultHook: ApprovalGuidanceHook,
+  customHook?: PluginHooks['getApprovalGuidance'],
+): ApprovalGuidanceHook {
+  return (ctx) => {
+    const combined = dedupeApprovalGuidanceLines([
+      ...normalizeApprovalGuidanceLines(defaultHook(ctx)),
+      ...normalizeApprovalGuidanceLines(customHook?.(ctx)),
+    ])
+    return combined.length > 0 ? combined : null
+  }
+}
+
+export function buildPluginHooks(
+  pluginId: string,
+  pluginName: string,
+  hooks: PluginHooks | undefined,
+  tools: PluginToolDef[] | undefined,
+): PluginHooks {
+  const nextHooks: PluginHooks = { ...(hooks || {}) }
+  nextHooks.getApprovalGuidance = composeApprovalGuidance(
+    buildDefaultPluginApprovalGuidance({
+      pluginId,
+      pluginName,
+      tools: tools || [],
+    }),
+    hooks?.getApprovalGuidance,
+  )
+  return nextHooks
+}

package/src/lib/server/plugins.test.ts

@@ -53,7 +53,7 @@ describe('plugin install helpers', () => {
     assert.equal(sanitizePluginFilename('plugin.js'), 'plugin.js')
     assert.equal(sanitizePluginFilename('plugin.mjs'), 'plugin.mjs')
     assert.throws(() => sanitizePluginFilename('../plugin.js'), /Invalid filename/)
-    assert.throws(() => sanitizePluginFilename('plugin.ts'), /Filename must end/)
+    assert.throws(() => sanitizePluginFilename('plugin'), /Filename must end/)
   })
 })
 

package/src/lib/server/plugins.ts

@@ -17,6 +17,8 @@ import { log } from './logger'
 import { createNotification } from './create-notification'
 import { notify } from './ws-hub'
 import { decryptKey, encryptKey, loadSettings, saveSettings } from './storage'
+import { buildPluginHooks } from './plugins-approval-guidance'
+import { errorMessage } from '@/lib/shared-utils'
 
 const PLUGINS_DIR = path.join(DATA_DIR, 'plugins')
 const PLUGIN_WORKSPACES_DIR = path.join(PLUGINS_DIR, '.workspaces')
@@ -107,8 +109,6 @@ type HookRegistrar = {
 type HookContext<K extends keyof PluginHooks> =
   PluginHooks[K] extends ((ctx: infer C) => unknown) | undefined ? C : never
 
-type ApprovalGuidanceHook = NonNullable<PluginHooks['getApprovalGuidance']>
-
 /** Legacy OpenClaw format: activate(ctx)/deactivate() */
 interface OpenClawLegacyPlugin {
   name: string
@@ -117,116 +117,6 @@ interface OpenClawLegacyPlugin {
   deactivate?: () => void
 }
 
-function trimString(value: unknown): string {
-  return typeof value === 'string' ? value.trim() : ''
-}
-
-function normalizeApprovalGuidanceLines(
-  value: string | string[] | null | undefined,
-): string[] {
-  if (typeof value === 'string') {
-    const trimmed = value.trim()
-    return trimmed ? [trimmed] : []
-  }
-  if (!Array.isArray(value)) return []
-  return value
-    .map((line) => (typeof line === 'string' ? line.trim() : ''))
-    .filter(Boolean)
-}
-
-function dedupeApprovalGuidanceLines(lines: string[]): string[] {
-  return Array.from(new Set(lines.map((line) => line.trim()).filter(Boolean)))
-}
-
-function formatApprovalToolLabel(toolNames: string[]): string {
-  const uniqueNames = Array.from(new Set(toolNames.map((name) => name.trim()).filter(Boolean)))
-  if (uniqueNames.length === 0) return 'its tools'
-  if (uniqueNames.length === 1) return `\`${uniqueNames[0]}\``
-  if (uniqueNames.length === 2) return `\`${uniqueNames[0]}\` and \`${uniqueNames[1]}\``
-  return `${uniqueNames.slice(0, -1).map((name) => `\`${name}\``).join(', ')}, and \`${uniqueNames.at(-1)}\``
-}
-
-function buildDefaultPluginApprovalGuidance(params: {
-  pluginId: string
-  pluginName: string
-  tools: PluginToolDef[]
-}): ApprovalGuidanceHook {
-  const toolNames = params.tools
-    .map((tool) => (typeof tool?.name === 'string' ? tool.name.trim() : ''))
-    .filter(Boolean)
-  const toolLabel = formatApprovalToolLabel(toolNames)
-  const matchIds = new Set(
-    dedupeApprovalGuidanceLines([
-      params.pluginId,
-      ...toolNames,
-      ...expandPluginIds([params.pluginId]),
-      ...toolNames.flatMap((toolName) => expandPluginIds([toolName])),
-    ]).map((value) => canonicalizePluginId(value) || value.toLowerCase()),
-  )
-
-  return ({ approval, phase, approved }) => {
-    if (approval.category !== 'tool_access') return null
-    const requestedIds = [
-      trimString(approval.data.pluginId),
-      trimString(approval.data.toolId),
-      trimString(approval.data.toolName),
-    ].filter(Boolean)
-    const matchesPlugin = requestedIds.some((value) => {
-      const candidates = [value, ...expandPluginIds([value])]
-      return candidates.some((candidate) => matchIds.has(canonicalizePluginId(candidate) || candidate.toLowerCase()))
-    })
-    if (!matchesPlugin) return null
-
-    if (phase === 'connector_reminder') {
-      return `Approving this lets the agent use ${toolLabel} from ${params.pluginName}.`
-    }
-    if (approved === true) {
-      return [
-        `Access to ${params.pluginName} is approved. Continue with ${toolLabel} on the next turn.`,
-        'Do not request the same access again in prose once it has been approved.',
-      ]
-    }
-    if (approved === false) {
-      return `Do not request access to ${params.pluginName} again unless the task or required capability materially changes.`
-    }
-    return [
-      `If access to ${params.pluginName} is granted, continue with ${toolLabel} on the next turn.`,
-      'Do not ask for the same access again in prose while this approval is pending.',
-    ]
-  }
-}
-
-function composeApprovalGuidance(
-  defaultHook: ApprovalGuidanceHook,
-  customHook?: PluginHooks['getApprovalGuidance'],
-): ApprovalGuidanceHook {
-  return (ctx) => {
-    const combined = dedupeApprovalGuidanceLines([
-      ...normalizeApprovalGuidanceLines(defaultHook(ctx)),
-      ...normalizeApprovalGuidanceLines(customHook?.(ctx)),
-    ])
-    return combined.length > 0 ? combined : null
-  }
-}
-
-function buildPluginHooks(
-  pluginId: string,
-  pluginName: string,
-  hooks: PluginHooks | undefined,
-  tools: PluginToolDef[] | undefined,
-): PluginHooks {
-  const nextHooks: PluginHooks = { ...(hooks || {}) }
-  nextHooks.getApprovalGuidance = composeApprovalGuidance(
-    buildDefaultPluginApprovalGuidance({
-      pluginId,
-      pluginName,
-      tools: tools || [],
-    }),
-    hooks?.getApprovalGuidance,
-  )
-  return nextHooks
-}
-
 /**
  * Real OpenClaw plugin format: function export `(api) => {}` or object with `register(api)`.
  * Supports api.registerHook(), api.registerTool(), api.registerCommand(), api.registerService().
@@ -569,7 +459,7 @@ function normalizePlugin(mod: unknown): Plugin | null {
     } catch (err: unknown) {
       log.error('plugins', 'OpenClaw register() failed', {
         pluginName,
-        error: err instanceof Error ? err.message : String(err),
+        error: errorMessage(err),
       })
       return null
     }
@@ -610,7 +500,7 @@ function normalizePlugin(mod: unknown): Plugin | null {
     } catch (err: unknown) {
       log.error('plugins', 'OpenClaw activate() failed', {
         pluginName: oc.name,
-        error: err instanceof Error ? err.message : String(err),
+        error: errorMessage(err),
       })
       return null
     }
@@ -643,7 +533,7 @@ function createPluginRequire(): NodeRequire | null {
     return createRequire(path.join(process.cwd(), 'package.json'))
   } catch (err: unknown) {
     log.warn('plugins', 'createRequire failed; external plugins disabled', {
-      error: err instanceof Error ? err.message : String(err),
+      error: errorMessage(err),
     })
     return null
   }
@@ -679,7 +569,7 @@ class PluginManager {
       })
       watcher.on('error', (err: unknown) => {
         log.warn('plugins', 'Plugin watcher disabled after runtime watch failure', {
-          error: err instanceof Error ? err.message : String(err),
+          error: errorMessage(err),
         })
         if (this.watcher === watcher) {
           try { watcher.close() } catch { /* ignore */ }
@@ -690,7 +580,7 @@ class PluginManager {
       this.watcher = watcher
     } catch (err: unknown) {
       log.warn('plugins', 'Failed to watch plugins directory', {
-        error: err instanceof Error ? err.message : String(err),
+        error: errorMessage(err),
       })
     }
   }
@@ -879,7 +769,7 @@ class PluginManager {
     try {
       fs.writeFileSync(PLUGIN_FAILURES, JSON.stringify(state, null, 2))
     } catch (err: unknown) {
-      log.warn('plugins', 'Failed to persist plugin failure state', { error: err instanceof Error ? err.message : String(err) })
+      log.warn('plugins', 'Failed to persist plugin failure state', { error: errorMessage(err) })
     }
   }
 
@@ -903,7 +793,7 @@ class PluginManager {
     } catch (err: unknown) {
       log.error('plugins', 'Failed to write plugins config while auto-disabling plugin', {
         pluginId: id,
-        error: err instanceof Error ? err.message : String(err),
+        error: errorMessage(err),
       })
       return
     }
@@ -932,7 +822,7 @@ class PluginManager {
   }
 
   private markPluginFailure(id: string, stage: string, err: unknown, disableEligible: boolean): void {
-    const errorText = err instanceof Error ? err.message : String(err)
+    const errorText = errorMessage(err)
     const state = this.readFailureState()
     const failureKey = this.canonicalPluginId(id)
     const nextCount = (state[failureKey]?.count || 0) + 1
@@ -966,7 +856,7 @@ class PluginManager {
     try {
       this.clearFailureState(id)
     } catch (err: unknown) {
-      log.warn('plugins', 'markPluginSuccess failed', { error: err instanceof Error ? err.message : String(err), pluginId: id })
+      log.warn('plugins', 'markPluginSuccess failed', { error: errorMessage(err), pluginId: id })
     }
   }
 
@@ -1053,7 +943,7 @@ class PluginManager {
           } catch (err: unknown) {
             log.error('plugins', 'Failed to load external plugin', {
               pluginId: file,
-              error: err instanceof Error ? err.message : String(err),
+              error: errorMessage(err),
             })
             this.markPluginFailure(file, 'load.require', err, true)
           }
@@ -1150,7 +1040,7 @@ class PluginManager {
             pluginId: id,
             pluginName: p.meta.name,
             hookName: String(hookName),
-            error: err instanceof Error ? err.message : String(err),
+            error: errorMessage(err),
           })
           this.markPluginFailure(id, `hook.${String(hookName)}`, err, true)
         }
@@ -1181,7 +1071,7 @@ class PluginManager {
           pluginId: id,
           pluginName: p.meta.name,
           toolName: params.toolName,
-          error: err instanceof Error ? err.message : String(err),
+          error: errorMessage(err),
         })
         this.markPluginFailure(id, 'hook.beforeToolExec', err, true)
       }
@@ -1212,7 +1102,7 @@ class PluginManager {
             pluginId: id,
             pluginName: p.meta.name,
             hookName,
-            error: err instanceof Error ? err.message : String(err),
+            error: errorMessage(err),
           })
           this.markPluginFailure(id, `hook.${String(hookName)}`, err, true)
         }
@@ -1240,7 +1130,7 @@ class PluginManager {
         log.error('plugins', 'getAgentContext hook failed', {
           pluginId: id,
           pluginName: p.meta.name,
-          error: err instanceof Error ? err.message : String(err),
+          error: errorMessage(err),
         })
         this.markPluginFailure(id, 'hook.getAgentContext', err, true)
       }
@@ -1265,7 +1155,7 @@ class PluginManager {
           lines.push(`- ${result}`)
         }
       } catch (err: unknown) {
-        log.error('plugins', 'getCapabilityDescription hook failed', { pluginId: id, error: err instanceof Error ? err.message : String(err) })
+        log.error('plugins', 'getCapabilityDescription hook failed', { pluginId: id, error: errorMessage(err) })
       }
     }
 
@@ -1293,7 +1183,7 @@ class PluginManager {
           }
         }
       } catch (err: unknown) {
-        log.error('plugins', 'getOperatingGuidance hook failed', { pluginId: id, error: err instanceof Error ? err.message : String(err) })
+        log.error('plugins', 'getOperatingGuidance hook failed', { pluginId: id, error: errorMessage(err) })
       }
     }
 
@@ -1330,7 +1220,7 @@ class PluginManager {
       } catch (err: unknown) {
         log.error('plugins', 'getApprovalGuidance hook failed', {
           pluginId: id,
-          error: err instanceof Error ? err.message : String(err),
+          error: errorMessage(err),
         })
       }
     }
@@ -1617,7 +1507,7 @@ class PluginManager {
 
       return metas
     } catch (err: unknown) {
-      log.error('plugins', 'listPlugins failed', { error: err instanceof Error ? err.message : String(err) })
+      log.error('plugins', 'listPlugins failed', { error: errorMessage(err) })
       return []
     }
   }
@@ -1714,7 +1604,7 @@ class PluginManager {
         dependencyInstalledAt: Date.now(),
       })
     } catch (err: unknown) {
-      const message = err instanceof Error ? err.message : String(err)
+      const message = errorMessage(err)
       this.setMeta(sanitizedFilename, {
         packageManager,
         dependencyInstallStatus: 'error',
@@ -1832,7 +1722,7 @@ export function getPluginManager(): PluginManager {
     }
     return _manager
   } catch (err: unknown) {
-    log.error('plugins', 'getPluginManager critical failure', { error: err instanceof Error ? err.message : String(err) })
+    log.error('plugins', 'getPluginManager critical failure', { error: errorMessage(err) })
     throw err
   }
 }

package/src/lib/server/process-manager.ts

@@ -1,4 +1,5 @@
 import { genId } from '@/lib/id'
+import { hmrSingleton, sleep } from '@/lib/shared-utils'
 import { spawn, type ChildProcessWithoutNullStreams } from 'child_process'
 
 const MAX_LOG_CHARS = 200_000
@@ -52,12 +53,11 @@ interface RuntimeState {
   exitWaiters: Map<string, Promise<ProcessRecord>>
 }
 
-const globalKey = '__swarmclaw_process_manager__' as const
-const state: RuntimeState = (globalThis as any)[globalKey] ?? ((globalThis as any)[globalKey] = {
+const state: RuntimeState = hmrSingleton<RuntimeState>('__swarmclaw_process_manager__', () => ({
   records: new Map<string, ProcessRecord>(),
   children: new Map<string, ChildProcessWithoutNullStreams>(),
   exitWaiters: new Map<string, Promise<ProcessRecord>>(),
-})
+}))
 
 function now() {
   return Date.now()
@@ -91,9 +91,6 @@ function normalizeLines(text: string): string[] {
   return text.split('\n')
 }
 
-async function wait(ms: number): Promise<void> {
-  await new Promise((resolve) => setTimeout(resolve, ms))
-}
 
 function getShellCommand(command: string): { shell: string; args: string[] } {
   return { shell: '/bin/zsh', args: ['-lc', command] }
@@ -177,7 +174,7 @@ export async function startManagedProcess(opts: StartProcessOptions): Promise<St
       Math.max(100, BACKGROUND_STARTUP_GRACE_MS),
       Math.max(200, timeoutMs),
     )
-    await wait(startupWaitMs)
+    await sleep(startupWaitMs)
     const rec = state.records.get(id)
     if (rec && rec.status !== 'running') {
       return {
@@ -197,7 +194,7 @@ export async function startManagedProcess(opts: StartProcessOptions): Promise<St
 
   const completed = await Promise.race([
     exitPromise.then((r) => ({ type: 'exit' as const, record: r })),
-    wait(yieldMs).then(() => ({ type: 'yield' as const })),
+    sleep(yieldMs).then(() => ({ type: 'yield' as const })),
   ])
 
   if (completed.type === 'yield') {