@mindot/will 0.1.0

package/src/cognition/faculties/theory.of.mind.ts

@@ -0,0 +1,333 @@
+// ─────────────────────────────────────────────────────────────
+// src/cognition/faculties/theory.of.mind.ts
+// ─────────────────────────────────────────────────────────────
+
+/**
+ * TheoryOfMind — models what other agents know, believe, and intend.
+ *
+ * Maintains a mental model for each observed agent:
+ *   - Knowledge state (what they've observed)
+ *   - Belief state (what they think is true, may differ from reality)
+ *   - Intention state (what they're trying to achieve)
+ *   - Emotional state (what they're likely feeling)
+ *
+ * Updates models based on:
+ *   - Observed actions (what the other agent did)
+ *   - Shared observations (what the other agent could have seen)
+ *   - Communication (what the other agent explicitly shared)
+ *
+ * Part of Shard 1 (Social Layer) — runs every tick, synchronous.
+ */
+
+import type {
+  Duration,
+  Tick,
+  SimulationContext,
+  ReadonlySimulationState,
+  StateCommands,
+  SimulationEvent,
+} from '#core/types'
+import type { SimulationEngine, EngineResult, CognitiveEngine } from '#cognition/types'
+import type { CognitiveEventSchema } from '#cognition/schema.registry'
+import type { CognitiveEvent, CognitiveBus } from '#cognition/bus'
+import { GenerativeModel } from '#cognition/generative.model'
+
+export interface TheoryOfMindConfig {
+  /** Maximum agents to model simultaneously */
+  maxModeledAgents?: number
+  /** How quickly belief confidence decays without observation */
+  beliefDecayRate?: number
+  /** Minimum confidence to consider a belief reliable */
+  confidenceThreshold?: number
+  bus?: CognitiveBus
+}
+
+export interface AgentMentalModel {
+  keid: string
+  /** What this agent is known to have observed */
+  knownObservations: Array<{ entityId: string; tick: Tick; confidence: number }>
+  /** What this agent is believed to believe */
+  beliefs: Array<{ statement: string; confidence: number; lastUpdated: Tick }>
+  /** What this agent is believed to intend */
+  intentions: Array<{ goal: string; confidence: number; lastUpdated: Tick }>
+  /** What this agent is likely feeling */
+  emotionalState: { valence: number; arousal: number; dominantEmotion: string }
+  /** Last tick this model was updated */
+  lastUpdated: Tick
+  /** Overall model confidence */
+  modelConfidence: number
+}
+
+export class TheoryOfMind implements SimulationEngine, CognitiveEngine {
+  readonly name     = 'theory-of-mind'
+  
+  private _maxModeledAgents: number
+  private _beliefDecayRate: number
+  private _confidenceThreshold: number
+
+  private _models = new Map<string, AgentMentalModel>()
+  private _restored = false
+  private _pendingInteractions: Array<{
+    keid: string; valence: number; intensity: number
+    directedAtSelf: boolean; interactionType: string
+  }> = []
+
+  private _bus: CognitiveBus | null = null
+
+  private readonly _model    = new GenerativeModel()
+
+
+  constructor( config: TheoryOfMindConfig = {} ){
+    this._bus = config.bus ?? null
+    this._maxModeledAgents   = config.maxModeledAgents   ?? 10
+    this._beliefDecayRate    = config.beliefDecayRate    ?? 0.002
+    this._confidenceThreshold = config.confidenceThreshold ?? 0.3
+  }
+  attachBus( bus: CognitiveBus ): void { this._bus = bus }
+
+  // ── Engine interface ─────────────────────────────────────
+
+  subscribes(): string[] {
+    return [
+      'executive.prediction.formed',
+      'interaction.occurred',
+    ]
+  }
+
+  publishes(): CognitiveEventSchema[] { return [] }
+
+  onCognitiveEvent( e: CognitiveEvent ): StateCommands | void {
+    this._model.observe( e.type, e.salience )
+    if( e.type === 'executive.prediction.formed' ){
+      const p = e.payload as { predictedDomains: string[]; confidence: number }
+      if( p.predictedDomains.includes('social') )
+        this._model.setPrecision( 'tom.models', 1.0 + p.confidence * 0.5 )
+    }
+    if( e.type === 'interaction.occurred' ){
+      const p = e.payload as {
+        keid: string; valence: number; intensity: number
+        directedAtSelf: boolean; interactionType: string
+      }
+      if( p.keid && p.keid !== 'agent-self' )
+        this._pendingInteractions.push( p )
+    }
+  }
+
+  snapshot(): Record<string, unknown> { return {} }
+
+  async react(
+    _delta: Duration,
+    tick: Tick,
+    state: ReadonlySimulationState,
+    _context: SimulationContext
+  ): Promise<EngineResult> {
+    const
+    events:   Array<Omit<SimulationEvent, 'id' | 'timestamp' | 'tick'>> = [],
+    commands: StateCommands = { set: [], delete: [], metrics: [] }
+
+    // On the first tick after construction (including snapshot/PMA restores), rehydrate
+    // _models from the persisted tom-<id> gist — parity with attachment/reputation, which
+    // already restore. Without this a restored Will keeps its bonds + trust but loses the
+    // effector to *model* those same minds (empathy.getModel returns nothing; maintenance
+    // stalls). The entity only ever stored a gist, so the restore is gist-level by design.
+    if( !this._restored ){
+      this._restoreFromState( state )
+      this._restored = true
+    }
+
+    // Drain pending interactions buffered from interaction.occurred events
+    const interactions = this._pendingInteractions.splice( 0 )
+    for( const interaction of interactions ){
+      const model = this._getOrCreateModel( interaction.keid, tick )
+      const action = interaction.interactionType
+
+      model.knownObservations.push({
+        entityId: `action-${action}-${tick}`,
+        tick,
+        confidence: 0.8,
+      })
+
+      this._inferIntention( model, action, tick )
+
+      model.emotionalState = {
+        valence: interaction.valence > 0.3 ? 0.5 : interaction.valence < -0.3 ? -0.5 : 0,
+        arousal: Math.abs( interaction.valence ) > 0.5 ? 0.7 : 0.3,
+        dominantEmotion: interaction.valence > 0.3 ? 'satisfaction' : interaction.valence < -0.3 ? 'frustration' : 'neutral',
+      }
+
+      model.lastUpdated = tick
+    }
+
+    // 3. Decay old beliefs
+    this._decayBeliefs( tick )
+
+    // 4. Prune models with low confidence
+    this._pruneModels()
+
+    // 5. Persist models
+    for( const [ keid, model ] of this._models ){
+      commands.set!.push({
+        id: `tom-${keid}`,
+        type: 'theory_of_mind',
+        createdAt: model.lastUpdated,
+        updatedAt: tick,
+        metadata: {
+          keid,
+          beliefCount: model.beliefs.filter( b => b.confidence > this._confidenceThreshold ).length,
+          intentionCount: model.intentions.filter( i => i.confidence > this._confidenceThreshold ).length,
+          modelConfidence: model.modelConfidence,
+          dominantIntention: model.intentions
+            .sort( ( a, b ) => b.confidence - a.confidence )[0]?.goal ?? null,
+          estimatedEmotion: model.emotionalState.dominantEmotion,
+        },
+      })
+    }
+
+    commands.metrics!.push(
+      [ 'theory_of_mind.models_active', this._models.size ],
+    )
+
+
+    // Phase C + F: publish cognitive event — gated by prediction error
+    const _bus = this._bus
+    if( _bus && this._models.size > 0 ){
+      const predErr = this._model.observe( 'tom.models', this._models.size )
+      if( !predErr.gated )
+        _bus.publish({ type: 'theory_of_mind.model.updated', version: 1, sourceEngine: this.name, salience: Math.max( 0.2, predErr.salience ), payload: { modelsActive: this._models.size } })
+    }
+    return { events: events.length > 0 ? events : undefined, commands }
+  }
+
+  // ── Public API ───────────────────────────────────────────
+
+  /**
+   * Query what another agent is likely to know/believe/intend.
+   */
+  getModel( keid: string ): AgentMentalModel | undefined {
+    return this._models.get( keid )
+  }
+
+  /**
+   * Check if another agent is likely aware of something.
+   */
+  isLikelyAwareOf( keid: string, entityId: string ): boolean {
+    const model = this._models.get( keid )
+    if( !model ) return false
+
+    return model.knownObservations.some(
+      o => o.entityId === entityId && o.confidence > this._confidenceThreshold
+    )
+  }
+
+  // ── Internal ─────────────────────────────────────────────
+
+  /**
+   * Rehydrate _models from persisted tom-<id> entities on the first tick after a
+   * snapshot/PMA restore — mirrors AttachmentEvaluator/ReputationTracker._restoreFromState.
+   * The entity stores a gist (modelConfidence + the dominant intention + estimated emotion),
+   * not the full belief/observation arrays, so the restored model is a coherent gist that
+   * subsequent interactions grow from — the soul-true level: you recover your *sense* of a
+   * mind, not every belief you once inferred about it.
+   */
+  private _restoreFromState( state: ReadonlySimulationState ): void {
+    for( const entity of state.entities.values() ){
+      if( entity.type !== 'theory_of_mind' ) continue
+      const m       = entity.metadata ?? {}
+      const keid = m['keid'] as string | undefined
+      if( !keid ) continue
+      if( this._models.has( keid ) ) continue   // prefer a live model if already present
+
+      const dominantIntention = ( m['dominantIntention'] as string | null ) ?? null
+      const modelConfidence   = ( m['modelConfidence']   as number ) ?? 0.3
+      const estimatedEmotion  = ( m['estimatedEmotion']  as string ) ?? 'neutral'
+
+      this._models.set( keid, {
+        keid,
+        knownObservations: [],
+        beliefs:           [],
+        intentions: dominantIntention
+          ? [ { goal: dominantIntention, confidence: modelConfidence, lastUpdated: 0 as unknown as Tick } ]
+          : [],
+        emotionalState: { valence: 0, arousal: 0, dominantEmotion: estimatedEmotion },
+        lastUpdated:     0 as unknown as Tick,
+        modelConfidence,
+      })
+    }
+  }
+
+  private _getOrCreateModel( keid: string, tick: Tick ): AgentMentalModel {
+    const existing = this._models.get( keid )
+    if( existing ) return existing
+
+    const model: AgentMentalModel = {
+      keid,
+      knownObservations: [],
+      beliefs: [],
+      intentions: [],
+      emotionalState: { valence: 0, arousal: 0.3, dominantEmotion: 'neutral' },
+      lastUpdated: tick,
+      modelConfidence: 0.3,
+    }
+
+    this._models.set( keid, model )
+    return model
+  }
+
+  private _inferIntention(
+    model: AgentMentalModel,
+    action: string,
+    tick: Tick
+  ): void {
+    const existingIntention = model.intentions.find( i => i.goal === action )
+
+    if( existingIntention ){
+      existingIntention.confidence = Math.min( 1, existingIntention.confidence + 0.1 )
+      existingIntention.lastUpdated = tick
+    }
+    else model.intentions.push({
+          goal: action,
+          confidence: 0.4,
+          lastUpdated: tick,
+        })
+
+    // Boost overall model confidence
+    model.modelConfidence = Math.min( 1, model.modelConfidence + 0.02 )
+  }
+
+  private _decayBeliefs( currentTick: Tick ): void {
+    for( const model of this._models.values() ){
+      const ticksSinceUpdate = currentTick - model.lastUpdated
+
+      if( ticksSinceUpdate > 100 ){
+        model.modelConfidence = Math.max( 0.05, model.modelConfidence - this._beliefDecayRate * ticksSinceUpdate )
+
+        for( const belief of model.beliefs )
+          belief.confidence = Math.max( 0.05, belief.confidence - this._beliefDecayRate * 2 )
+
+        for( const intention of model.intentions )
+          intention.confidence = Math.max( 0.05, intention.confidence - this._beliefDecayRate * 2 )
+      }
+    }
+  }
+
+  private _pruneModels(): void {
+    const toPrune: string[] = []
+
+    for( const [ id, model ] of this._models ){
+      if( model.modelConfidence < 0.05 )
+        toPrune.push( id )
+    }
+
+    for( const id of toPrune )
+      this._models.delete( id )
+
+    // Also prune if over capacity — keep highest confidence
+    if( this._models.size > this._maxModeledAgents ){
+      const sorted = Array.from( this._models.entries() )
+        .sort( ( a, b ) => b[1].modelConfidence - a[1].modelConfidence )
+
+      for( const [ id ] of sorted.slice( this._maxModeledAgents ) )
+        this._models.delete( id )
+    }
+  }
+}

package/src/cognition/faculties/threat.evaluator.ts

@@ -0,0 +1,312 @@
+// ─────────────────────────────────────────────────────────────
+// src/cognition/faculties/threat.evaluator.ts
+// ─────────────────────────────────────────────────────────────
+
+/**
+ * ThreatEvaluator — assesses danger across multiple dimensions.
+ *
+ * Evaluates:
+ *   - Hostile entities (entities marked as threatening)
+ *   - Resource scarcity (low energy, time pressure)
+ *   - Uncertainty (high novelty, low predictability)
+ *   - Social rejection risk (negative social signals directed at self)
+ *
+ * Produces: fear, anxiety, vigilance
+ *
+ * Fear = immediate, identifiable threat
+ * Anxiety = diffuse, uncertain threat
+ * Vigilance = heightened alertness in response to elevated threat level
+ *
+ * Part of Shard 1 (Affective Layer) — runs every tick, synchronous.
+ */
+
+import type {
+  StateCommands,
+  Duration,
+  Tick,
+  ReadonlySimulationState,
+  SimulationContext,
+} from '#core/types'
+import type { EngineResult } from '#core/orchestrator'
+import type { SimulationEngine, CognitiveEngine } from '#cognition/types'
+import type { CognitiveEventSchema } from '#cognition/schema.registry'
+import type { CognitiveEvent, CognitiveBus } from '#cognition/bus'
+import { GenerativeModel } from '#cognition/generative.model'
+import { readEffectiveParams } from '#cognition/persona.prior'
+
+export interface ThreatEvaluatorConfig {
+  /** Weight for hostile entity threats */
+  hostileWeight?: number
+  /** Weight for resource scarcity threats */
+  scarcityWeight?: number
+  /** Weight for uncertainty threats */
+  uncertaintyWeight?: number
+  /** Weight for social rejection threats */
+  socialWeight?: number
+  /** Threshold above which fear triggers a significant event */
+  fearEventThreshold?: number
+  bus?: CognitiveBus
+}
+
+export class ThreatEvaluator implements SimulationEngine, CognitiveEngine {
+  readonly name     = 'threat-evaluator'
+  
+  private _hostileWeight: number
+  private _scarcityWeight: number
+  private _uncertaintyWeight: number
+  private _socialWeight: number
+  private _fearEventThreshold: number
+
+  // Domain state — updated per-event
+  private _energyLevel: number = 100
+  private _sleepPressure: number = 0
+  private _stressLoad: number = 0
+  private _deadlineUrgency: number = 0
+  private _cognitiveLoad: number = 0
+  private _cachedNovelty: number = 0
+  private _cachedMetacognitionConfidence: number = 0.7
+  private _socialEvaluationThreat: number = 0
+  private _activeAgents: number = 0
+
+  // Cached component threats — accumulated across events
+  private _threatFromHostile: number = 0      // updated only if entity events are added
+  private _threatFromScarcity: number = 0
+  private _threatFromUncertainty: number = 0
+  private _threatFromSocial: number = 0
+
+  private _bus: CognitiveBus | null = null
+
+  private readonly _model = new GenerativeModel()
+
+
+  constructor( config: ThreatEvaluatorConfig = {} ){
+    this._bus = config.bus ?? null
+    this._hostileWeight      = config.hostileWeight      ?? 0.35
+    this._scarcityWeight     = config.scarcityWeight     ?? 0.25
+    this._uncertaintyWeight  = config.uncertaintyWeight  ?? 0.20
+    this._socialWeight       = config.socialWeight       ?? 0.20
+    this._fearEventThreshold = config.fearEventThreshold ?? 0.6
+  }
+  attachBus( bus: CognitiveBus ): void { this._bus = bus }
+
+  // ── Engine interface ─────────────────────────────────────
+
+  subscribes(): string[] { return ["energy.state.changed","sleep.state.changed","stress.state.changed","novelty.state.changed","metacognition.state.changed","executive.prediction.formed"] }
+  publishes(): CognitiveEventSchema[] { return [] }
+
+  onCognitiveEvent( e: CognitiveEvent ): StateCommands | void {
+    this._model.observe( e.type, e.salience )
+
+    switch( e.type ){
+
+      case 'energy.state.changed': {
+        const p = e.payload as { level: number }
+        this._energyLevel = p.level ?? this._energyLevel
+        this._threatFromScarcity = this._computeScarcityThreat()
+        break
+      }
+
+      case 'sleep.state.changed': {
+        const p = e.payload as { pressure: number }
+        this._sleepPressure = p.pressure ?? this._sleepPressure
+        this._threatFromScarcity = this._computeScarcityThreat()
+        break
+      }
+
+      case 'stress.state.changed': {
+        const p = e.payload as { load: number; deadlineUrgency: number; cognitiveLoad: number }
+        this._stressLoad        = p.load            ?? this._stressLoad
+        this._deadlineUrgency   = p.deadlineUrgency ?? this._deadlineUrgency
+        this._cognitiveLoad     = p.cognitiveLoad   ?? this._cognitiveLoad
+        this._threatFromScarcity    = this._computeScarcityThreat()
+        this._threatFromUncertainty = this._computeUncertaintyThreat()
+        break
+      }
+
+      case 'novelty.state.changed': {
+        const p = e.payload as { novelty: number; socialEvaluationThreat: number; activeAgents: number; fearLevel: number }
+        this._cachedNovelty             = p.novelty              ?? this._cachedNovelty
+        this._socialEvaluationThreat    = p.socialEvaluationThreat ?? this._socialEvaluationThreat
+        this._activeAgents              = p.activeAgents          ?? this._activeAgents
+        this._threatFromUncertainty = this._computeUncertaintyThreat()
+        this._threatFromSocial      = this._computeSocialThreat()
+        break
+      }
+
+      case 'metacognition.state.changed': {
+        const p = e.payload as { confidence: number }
+        this._cachedMetacognitionConfidence = p.confidence ?? this._cachedMetacognitionConfidence
+        this._threatFromUncertainty = this._computeUncertaintyThreat()
+        break
+      }
+
+      case 'executive.prediction.formed': {
+        const p = e.payload as { predictedDomains: string[]; confidence: number }
+        if( p.predictedDomains.includes('social') )
+          this._model.setPrecision('threat.level', 1.0 + p.confidence * 0.4)
+        break
+      }
+
+      default:
+        return
+    }
+
+    return this._computeAndEmit()
+  }
+
+  snapshot(): Record<string, unknown> {
+    return {
+      energyLevel:   this._energyLevel,
+      sleepPressure: this._sleepPressure,
+      stressLoad:    this._stressLoad,
+    }
+  }
+
+  // ── React (state scan) ────────────────────────────────────
+
+  /**
+   * Scans state each tick for active hostile entities (type === 'threat',
+   * metadata.hostile === true). Updates _threatFromHostile and re-emits
+   * the full threat/emotion metrics so that downstream engines always see
+   * a current picture even when no bus event arrives.
+   */
+  async react(
+    _delta:   Duration,
+    _tick:    Tick,
+    state:    ReadonlySimulationState,
+    _context: SimulationContext,
+  ): Promise<EngineResult> {
+    // Channel A (emotional-stability): how much threat it takes to fire a significant-fear
+    // event is refreshed each tick as base ⊕ persona-prior, so a steadier Will develops a
+    // HIGHER threshold and is less easily alarmed. _computeAndEmit (no `state`) reads the
+    // cached field. (The seed entity existed but was ignored before.)
+    this._fearEventThreshold = readEffectiveParams( state, 'engine-config-threat' ).fearEventThreshold ?? this._fearEventThreshold
+
+    // Recompute hostile threat from state entities every tick
+    let maxHostile = 0
+    for( const entity of state.entities.values() ){
+      if( entity.type !== 'threat' ) continue
+      if( entity.metadata?.active === false )  continue
+      if( !entity.metadata?.hostile )          continue
+      const intensity = typeof entity.metadata?.intensity === 'number'
+        ? entity.metadata.intensity as number
+        : 0.5
+      if( intensity > maxHostile ) maxHostile = intensity
+    }
+    this._threatFromHostile = maxHostile
+
+    const commands = this._computeAndEmit()
+    return { commands }
+  }
+
+  // ── Private helpers ──────────────────────────────────────
+
+  private _computeScarcityThreat(): number {
+    const
+    energyThreat  = Math.max( 0, 1 - this._energyLevel / ( 100 * 0.3 ) ),
+    timeThreat    = this._deadlineUrgency,
+    sleepThreat   = this._sleepPressure > 70 ? ( this._sleepPressure - 70 ) / 30 : 0
+
+    return Math.min( 1,
+      energyThreat * 0.4
+      + timeThreat  * 0.35
+      + sleepThreat * 0.25
+    )
+  }
+
+  private _computeUncertaintyThreat(): number {
+    const
+    novelty          = this._cachedNovelty,
+    confidence       = this._cachedMetacognitionConfidence,
+    unpredictability = novelty * ( 1 - confidence ),
+    cognitiveLoad    = this._cognitiveLoad
+
+    return Math.min( 1,
+      unpredictability * 0.6
+      + ( cognitiveLoad > 0.8 ? 0.3 : 0 )
+      + ( novelty > 0.7 ? 0.1 : 0 )
+    )
+  }
+
+  private _computeSocialThreat(): number {
+    const
+    evaluationThreat = this._socialEvaluationThreat,
+    socialIsolation  = this._activeAgents < 1 ? 0.4 : 0
+
+    return Math.min( 1,
+      evaluationThreat * 0.5
+      + socialIsolation * 0.15
+    )
+  }
+
+  private _computeAndEmit(): StateCommands {
+    const
+    hostileThreat     = this._threatFromHostile,
+    scarcityThreat    = this._threatFromScarcity,
+    uncertaintyThreat = this._threatFromUncertainty,
+    socialThreat      = this._threatFromSocial
+
+    const threatLevel
+      = hostileThreat     * this._hostileWeight
+      + scarcityThreat    * this._scarcityWeight
+      + uncertaintyThreat * this._uncertaintyWeight
+      + socialThreat      * this._socialWeight
+
+    const
+    fear = Math.min( 1,
+      hostileThreat * 0.7
+      + socialThreat * 0.2
+      + ( scarcityThreat > 0.7 ? 0.1 : 0 )
+    ),
+
+    anxiety = Math.min( 1,
+      uncertaintyThreat * 0.5
+      + ( threatLevel - fear ) * 0.5
+      + ( socialThreat > 0.3 && hostileThreat < 0.4 ? 0.3 : 0 )
+    ),
+
+    vigilance = Math.min( 1, threatLevel * 1.2 )
+
+    const commands: StateCommands = { metrics: [] }
+
+    commands.metrics!.push(
+      [ 'emotion.fear',        fear ],
+      [ 'emotion.anxiety',     anxiety ],
+      [ 'emotion.vigilance',   vigilance ],
+      [ 'threat.level',        threatLevel ],
+      [ 'threat.hostile',      hostileThreat ],
+      [ 'threat.scarcity',     scarcityThreat ],
+      [ 'threat.uncertainty',  uncertaintyThreat ],
+      [ 'threat.social',       socialThreat ],
+    )
+
+    const _bus = this._bus
+    if( _bus ){
+      // Option B (predictive-processing): event salience is surprise × precision,
+      // not raw magnitude. A CHANGE in threat grabs the workspace; a steady threat
+      // habituates (its level still rides the executive's standing context — see
+      // worldState.threatLevel). observe() runs every tick so the baseline tracks
+      // and the executive's top-down precision (set on 'threat.level') applies;
+      // the one value is reused across the tiered events.
+      const threatSalience = this._model.observe( 'threat.level', threatLevel ).salience
+
+      if( fear > 0.4 )
+        _bus.publish({ type: 'emotion.fear.elevated', version: 1, sourceEngine: this.name, salience: threatSalience, payload: { fear } })
+      if( fear > this._fearEventThreshold )
+        _bus.publish({
+          type: 'emotion.fear.significant', version: 1, sourceEngine: this.name,
+          salience: threatSalience,
+          payload: {
+            fear, anxiety, vigilance, threatLevel,
+            dominantThreat: hostileThreat > scarcityThreat
+              ? ( hostileThreat > socialThreat ? 'hostile' : 'social')
+              : ( scarcityThreat > uncertaintyThreat ? 'scarcity' : 'uncertainty'),
+          },
+        })
+      if( anxiety > 0.7 )
+        _bus.publish({ type: 'emotion.anxiety.elevated', version: 1, sourceEngine: this.name, salience: threatSalience, payload: { anxiety, uncertaintyThreat } })
+    }
+
+    return commands
+  }
+}