@linxin666/dsh-pet 0.1.14 → 0.1.16

package/src/service.ts

@@ -1,40 +1,45 @@
 /**
- * Pet host service — the `pet.*` RPC domain. Owns the state machine wiring
- * (projects official session events and accepts legacy `activity/status`), the
- * affinity ledger, and the persisted display config. The API gateway maps
- * this service's methods onto `pet.state` / `pet.interact` /
- * `pet.setVisible` / `pet.setConfig` for browser consumers.
+ * Pet host service — the `pet.*` RPC domain. A composition facade: it wires
+ * the pure event projection (`event-projection`) onto the state machine,
+ * delegates the affinity economy to the ledger (`ledger`), and routes
+ * persistence through `persist`. The API gateway maps these methods onto
+ * `pet.state` / `pet.pets` / `pet.interact` / `pet.setVisible` /
+ * `pet.setConfig` / `pet.setName` / `pet.setPet` for browser consumers.
  * @module @linxin666/dsh-pet/service
  */
 
 import { Context, Service } from '@deepseek-ai/cordis'
 import type { Session, SessionEvent } from '@deepseek-ai/dsh-session'
+import type { AffinityConfig, PetAffinityView, PetInteraction } from './affinity.ts'
+import type { TreatConfig } from './treats.ts'
 import {
-  applyInteraction,
-  applyTurnReward,
-  defaultAffinityConfig,
-  rankOf,
-  type AffinityConfig,
-  type AffinityState,
-  type PetInteraction,
-} from './affinity.ts'
+  emptyProjectionRuntime,
+  isActivityPhase,
+  projectOfficialEvent,
+  type ActivityStatusEventLike,
+  type ProjectionRuntime,
+} from './event-projection.ts'
+import { PetLedger, type LedgerConfig, type LedgerInteractionResult } from './ledger.ts'
 import {
-  loadPetPersist,
-  petHomeDir,
-  savePetPersist,
+  DEFAULT_PET_NAME,
+  DISPLAY_INSET_MAX,
   DISPLAY_SIZE_MAX,
   DISPLAY_SIZE_MIN,
-  DISPLAY_INSET_MAX,
   PET_NAME_MAX_LENGTH,
+  loadPetPersist,
+  petHomeDir,
+  savePetPersist,
   type PetDisplayConfig,
   type PetPersist,
 } from './persist.ts'
 import {
-  defaultTreatConfig,
-  settleTreatGrants,
-  consumeTreat,
-  type TreatConfig,
-} from './treats.ts'
+  loadPetRegistry,
+  petEntryView,
+  petPackageRoot,
+  type PetDefinition,
+  type PetManifest,
+  type PetRegistry,
+} from './registry.ts'
 import {
   defaultPetStateConfig,
   PetStateMachine,
@@ -55,14 +60,22 @@ export interface PetConfig {
   persistDir?: string
   /** Master switch for the plugin (browser half + host routes). */
   enabled?: boolean
+  /** Prebuilt registry (tests); defaults to scanning the package + user dirs. */
+  registry?: PetRegistry
+  /** Extra manifest entries composed by the embedding application. */
+  pets?: readonly PetManifest[]
 }
 
 /**
- * The pet's settings-namespace section: the display fields and name the web
- * settings surface edits. `right`/`bottom` are also updated by drag
+ * The pet's settings-namespace section: the pet selection and display fields
+ * the web settings surface edits. `right`/`bottom` are also updated by drag
  * interactions, which keep the settings document in sync through the service.
+ * Naming is per pet and lives outside the settings document (the hover-panel
+ * rename targets the selected pet).
  */
 export interface PetSettingsSection {
+  /** Selected pet id (a registry entry; the service clamps stale values). */
+  petId?: string
   /** Master switch. */
   visible: boolean
   /** Scale of the rendered pet in px (sprite cell height). */
@@ -71,8 +84,6 @@ export interface PetSettingsSection {
   right: number
   /** Vertical inset from the viewport bottom edge, px. */
   bottom: number
-  /** User-customizable pet display name. */
-  name: string
   /** Master switch for the plugin (browser half + host routes). */
   enabled?: boolean
 }
@@ -87,21 +98,19 @@ export interface PetStateView {
   phase: PetStateSnapshot['phase']
   sessionActive: boolean
   /** Affinity ledger snapshot. */
-  affinity: {
-    points: number
-    rank: string
-    rankEmoji: string
-    pets: number
-    feeds: number
-    turns: number
-    /** True while the pet interaction is inside its cooldown. */
-    petCooldown: boolean
-    /** True while the feed is inside its cooldown. */
-    feedCooldown: boolean
-  }
+  affinity: PetAffinityView
   /** Display configuration. */
   display: PetDisplayConfig
-  /** User-customizable pet display name. */
+  /** The selected pet's registry identity. */
+  pet: {
+    /** Registry id. */
+    id: string
+    /** Manifest display name (unrenamed default). */
+    displayName: string
+    /** Manifest description. */
+    description: string
+  }
+  /** The selected pet's display name (user rename or manifest default). */
   name: string
   /** Treat (小鱼干) stock snapshot. */
   treats: {
@@ -113,14 +122,7 @@ export interface PetStateView {
 }
 
 /** Result of `pet.interact`. */
-export interface PetInteractResult {
-  /** Reaction copy bubble. */
-  reaction: string
-  /** Points gained (0 when inside the cooldown). */
-  delta: number
-  /** Full affinity snapshot (same shape as state view). */
-  affinity: PetStateView['affinity']
-}
+export type PetInteractResult = LedgerInteractionResult
 
 declare module '@deepseek-ai/cordis' {
   interface Context {
@@ -128,152 +130,48 @@ declare module '@deepseek-ai/cordis' {
   }
 }
 
-/** Runtime shape of the optional legacy activity event. */
-interface ActivityStatusEventLike {
-  phase?: string
-  line?: string
-  phrase?: string
-}
-
-/** Per-session facts needed to project the official event stream. */
-interface SessionActivityRuntime {
-  activeTools: Set<string>
-  officialEventsSeen: boolean
-  stepHadFailure: boolean
-}
-
-/** One official event projection, optionally carrying a completed turn reward. */
-interface PetActivityTransition {
-  input: PetStateInput
-  completedTurn?: number
-}
-
-/** Keep tool names readable inside the compact status bubble. */
-function displayToolName(name: string): string {
-  const compact = name.replace(/\s+/g, ' ').trim() || '工具'
-  return compact.length <= 24 ? compact : `${compact.slice(0, 21)}...`
-}
-
-/** Whether a legacy phase is part of the pet's supported vocabulary. */
-function isActivityPhase(phase: string): phase is PetStateInput['phase'] {
-  return ['idle', 'waiting', 'thinking', 'tool', 'review', 'done', 'failed'].includes(phase)
-}
-
-/**
- * Project the durable DSH session vocabulary into the pet's visual phases.
- * Unknown and log-only events do not disturb the last meaningful activity.
- */
-function projectOfficialEvent(
-  event: SessionEvent,
-  runtime: SessionActivityRuntime,
-): PetActivityTransition | undefined {
-  switch (event.type) {
-    case 'turn/start':
-      runtime.activeTools.clear()
-      runtime.stepHadFailure = false
-      return { input: { phase: 'waiting', line: '准备开始' } }
-    case 'step/start':
-      runtime.activeTools.clear()
-      runtime.stepHadFailure = false
-      return { input: { phase: 'waiting', line: '等待模型响应' } }
-    case 'assistant/chunk': {
-      const { chunk } = event.data
-      if (chunk.type === 'reasoning-delta' && chunk.text.length > 0) {
-        return { input: { phase: 'thinking', line: '正在思考' } }
-      }
-      if (chunk.type === 'text-delta' && chunk.text.length > 0) {
-        return { input: { phase: 'review', line: '整理回复中' } }
-      }
-      return undefined
-    }
-    case 'assistant/message':
-      return { input: { phase: 'review', line: '整理回复中' } }
-    case 'tool/call':
-      runtime.activeTools.add(String(event.data.callId))
-      return {
-        input: {
-          phase: 'tool',
-          line: `正在使用 ${displayToolName(event.data.name)}`,
-        },
-      }
-    case 'tool/result': {
-      const block = event.data.message.content[0]
-      runtime.activeTools.delete(String(event.data.message.source.callId))
-      runtime.stepHadFailure ||= event.data.error !== undefined || block.isError === true
-      if (runtime.activeTools.size > 0) {
-        return {
-          input: {
-            phase: 'tool',
-            line: `还有 ${runtime.activeTools.size} 个工具运行中`,
-          },
-        }
-      }
-      return runtime.stepHadFailure
-        ? { input: { phase: 'failed', line: '工具执行失败' } }
-        : { input: { phase: 'thinking', line: '处理工具结果' } }
-    }
-    case 'turn/end': {
-      runtime.activeTools.clear()
-      switch (event.data.reason.kind) {
-        case 'completed':
-          return {
-            input: { phase: 'done', line: '完成啦' },
-            completedTurn: event.data.turn,
-          }
-        case 'error':
-          return { input: { phase: 'failed', line: '执行失败' } }
-        case 'max-tokens':
-          return { input: { phase: 'failed', line: '达到输出上限' } }
-        case 'interrupted':
-          return { input: { phase: 'failed', line: '执行意外中断' } }
-        case 'blocked':
-          return { input: { phase: 'waiting', line: '等待继续' } }
-        case 'aborted':
-          return { input: { phase: 'idle', line: '已停止' } }
-        default:
-          // TurnEndReasonMap is merge-extensible; a newer ending must not
-          // leave the pet showing stale in-progress work.
-          return { input: { phase: 'idle' } }
-      }
-    }
-    default:
-      return undefined
-  }
-}
-
 /**
  * Cordis service exposing the pet RPC domain. Lazy: nothing is scanned or
- * written until a query or interaction arrives; event listeners update only
- * in-memory state, and persistence happens on interaction/config changes
- * plus every completed turn.
+ * written until an economic event or interaction arrives; event listeners
+ * update only in-memory state, and persistence happens on economic changes
+ * (turn rewards, feeds, config/name changes) — never on a read.
  */
 export class PetService extends Service {
   static inject: string[] = []
 
   private readonly machine: PetStateMachine
-  private readonly affinityConfig: AffinityConfig
-  private readonly treatConfig: TreatConfig
+  private readonly ledger: PetLedger
+  private readonly registry: PetRegistry
   private readonly persistDir: string
-  private persist: PetPersist
-  /** Completed turns already rewarded, per session (turn numbers are per-session). */
-  private rewardedTurns = new Map<string, number>()
   private enabled: boolean
   private disposeActivity: (() => void) | undefined
   /** Session whose most recent meaningful event currently drives the global pet. */
   private displaySession: Session | undefined
-  private readonly sessionActivity = new WeakMap<Session, SessionActivityRuntime>()
-  private lastLegacyTurnRewardAt = 0
+  private readonly sessionActivity = new WeakMap<Session, ProjectionRuntime>()
 
   constructor(ctx: Context, config: PetConfig = {}) {
     super(ctx, 'pet')
     this.persistDir = config.persistDir ?? petHomeDir()
-    this.affinityConfig = { ...defaultAffinityConfig, ...(config.affinity ?? {}) }
-    this.treatConfig = { ...defaultTreatConfig, ...(config.treats ?? {}) }
+    this.registry = config.registry
+      ?? loadPetRegistry({
+        packageRoot: petPackageRoot(import.meta.url),
+        ...(config.pets === undefined ? {} : { extra: config.pets }),
+      })
+    if (this.registry.entries.length === 0) {
+      throw new Error('[dsh-pet] no valid pet manifests found; nothing to render')
+    }
+    let persist = loadPetPersist(this.persistDir)
+    if (this.registry.byId(persist.petId) === undefined) {
+      // The selected pet no longer exists (removed or a fresh install with a
+      // copied pet.json): fall back to the registry default.
+      persist = { ...persist, petId: this.registry.defaultEntry().id }
+    }
+    const ledgerConfig: LedgerConfig = { affinity: config.affinity, treats: config.treats }
+    this.ledger = new PetLedger(persist, ledgerConfig)
     this.machine = new PetStateMachine({
       ...defaultPetStateConfig,
       ...(config.state ?? {}),
     })
-    this.persist = loadPetPersist(this.persistDir)
     this.enabled = config.enabled ?? true
 
     this.syncActivity()
@@ -291,12 +189,44 @@ export class PetService extends Service {
 
   /** Current persisted display config (read-only view). */
   display(): PetDisplayConfig {
-    return { ...this.persist.display }
+    return { ...this.ledger.snapshot.display }
   }
 
-  /** Current persisted pet name (read-only view). */
-  petName(): string {
-    return this.persist.name
+  /** RPC: the registry entries the browser half renders and selects from. */
+  async pets(): Promise<PetDefinition[]> {
+    return this.registry.entries.map(petEntryView)
+  }
+
+  /** The loaded registry (the asset routes serve its entries). */
+  registrySnapshot(): PetRegistry {
+    return this.registry
+  }
+
+  /** The selected pet's registry entry. */
+  activeEntry(): NonNullable<PetRegistry['entries'][number]> {
+    return this.registry.byId(this.selectedPetId()) ?? this.registry.defaultEntry()
+  }
+
+  /** Currently selected pet id (persisted). */
+  selectedPetId(): string {
+    return this.ledger.snapshot.petId
+  }
+
+  /** The display name of one pet (user rename or manifest displayName). */
+  petName(petId: string = this.selectedPetId()): string {
+    const stored = this.ledger.snapshot.names[petId]
+    if (stored !== undefined && stored.trim() !== '') return stored
+    return this.registry.byId(petId)?.displayName ?? DEFAULT_PET_NAME
+  }
+
+  /** RPC: switch the selected pet (persisted, settings document mirrored). */
+  async setPetId(petId: string): Promise<{ ok: true; petId: string } | { ok: false; error: string }> {
+    const entry = this.registry.byId(petId)
+    if (entry === undefined) return { ok: false, error: 'unknown-pet' }
+    this.ledger.setPetId(entry.id)
+    this.flush()
+    this.syncSettingsFromPet()
+    return { ok: true, petId: entry.id }
   }
 
   /** Start or stop the session-activity listeners that drive the pet. */
@@ -354,14 +284,10 @@ export class PetService extends Service {
   }
 
   /** Return the projection state associated with one live session. */
-  private activityRuntime(session: Session): SessionActivityRuntime {
+  private activityRuntime(session: Session): ProjectionRuntime {
     let runtime = this.sessionActivity.get(session)
     if (runtime === undefined) {
-      runtime = {
-        activeTools: new Set(),
-        officialEventsSeen: false,
-        stepHadFailure: false,
-      }
+      runtime = emptyProjectionRuntime()
       this.sessionActivity.set(session, runtime)
     }
     return runtime
@@ -377,79 +303,61 @@ export class PetService extends Service {
   /** RPC: pet or feed the pet. */
   async interact(kind: PetInteraction): Promise<PetInteractResult> {
     const nowMs = Date.now()
-    // Feeding consumes a treat: settle the economy first (work + time
-    // output since the last settlement), then gate on the feed cooldown
-    // BEFORE spending stock — a feed inside the cooldown must not burn a
-    // treat for nothing.
-    if (kind === 'feed') this.settleTreats(nowMs)
-    const outcome = applyInteraction(this.persist.affinity, kind, nowMs, this.affinityConfig)
-    if (kind === 'feed' && !outcome.accepted) {
-      return { reaction: outcome.reaction, delta: 0, affinity: this.affinityView(this.persist.affinity) }
-    }
-    if (kind === 'feed') {
-      const consume = consumeTreat(this.persist.treats)
-      if (!consume.ok) {
-        const affinity = this.affinityView(this.persist.affinity)
-        return {
-          reaction: '没有小鱼干了，多陪鲸鱼娘工作一会儿吧～',
-          delta: 0,
-          affinity,
-        }
-      }
-      this.persist = { ...this.persist, treats: consume.ledger }
-    }
-    if (outcome.accepted) {
-      this.persist = { ...this.persist, affinity: outcome.affinity }
-      this.flush()
-    }
-    const affinity = this.affinityView(outcome.affinity)
-    return { reaction: outcome.reaction, delta: outcome.delta, affinity }
+    const result = this.ledger.interact(kind, nowMs)
+    if (this.ledger.takeDirty()) this.flush()
+    return result
   }
 
   /** RPC: show or hide the pet. */
   async setVisible(visible: boolean): Promise<{ ok: true; display: PetDisplayConfig }> {
-    this.persist = { ...this.persist, display: { ...this.persist.display, visible } }
+    this.ledger.setDisplay({ ...this.ledger.snapshot.display, visible })
     this.flush()
     this.syncSettingsFromPet()
-    return { ok: true, display: this.persist.display }
+    return { ok: true, display: this.ledger.snapshot.display }
   }
 
   /** RPC: update display config (size / position). Values are clamped to whole pixels. */
   async setConfig(patch: Partial<PetDisplayConfig>): Promise<{ ok: true; display: PetDisplayConfig }> {
-    const next = { ...this.persist.display, ...patch }
+    const next = { ...this.ledger.snapshot.display, ...patch }
     next.size = Math.round(Math.min(DISPLAY_SIZE_MAX, Math.max(DISPLAY_SIZE_MIN, next.size)))
     next.right = Math.round(Math.min(DISPLAY_INSET_MAX, Math.max(0, next.right)))
     next.bottom = Math.round(Math.min(DISPLAY_INSET_MAX, Math.max(0, next.bottom)))
-    this.persist = { ...this.persist, display: next }
+    this.ledger.setDisplay(next)
     this.flush()
     this.syncSettingsFromPet()
-    return { ok: true, display: this.persist.display }
+    return { ok: true, display: this.ledger.snapshot.display }
   }
 
-  /** RPC: rename the pet (trimmed, 1–20 chars). */
+  /** RPC: rename the selected pet (trimmed, 1–20 chars, per-pet storage). */
   async setName(name: string): Promise<{ ok: true; name: string } | { ok: false; error: string }> {
     const trimmed = name.trim()
     if (trimmed === '') return { ok: false, error: 'name-empty' }
     if (trimmed.length > PET_NAME_MAX_LENGTH) return { ok: false, error: 'name-too-long' }
-    this.persist = { ...this.persist, name: trimmed }
+    this.ledger.setPetName(this.selectedPetId(), trimmed)
     this.flush()
-    this.syncSettingsFromPet()
     return { ok: true, name: trimmed }
   }
 
   /**
-   * Apply a committed settings section to the persisted display config. Called
-   * by the settings surface on every change; values are clamped exactly like
-   * the setConfig RPC so both write paths converge.
+   * Apply a committed settings section to the persisted selection and display
+   * config. Called by the settings surface on every change; values are
+   * clamped exactly like the setConfig RPC so both write paths converge.
    * @param section - the resolved settings section.
    */
   applySettingsSection(section: PetSettingsSection): void {
-    const next = { ...this.persist.display }
+    if (typeof section.petId === 'string' && this.registry.byId(section.petId) !== undefined) {
+      this.ledger.setPetId(section.petId)
+    } else if (section.petId !== undefined) {
+      // The stored selection names a pet the registry no longer has: keep the
+      // current selection and repair the settings document.
+      this.syncSettingsFromPet()
+    }
+    const next = { ...this.ledger.snapshot.display }
     next.visible = section.visible && (section.enabled ?? true)
     next.size = Math.round(Math.min(DISPLAY_SIZE_MAX, Math.max(DISPLAY_SIZE_MIN, section.size)))
     next.right = Math.round(Math.min(DISPLAY_INSET_MAX, Math.max(0, section.right)))
     next.bottom = Math.round(Math.min(DISPLAY_INSET_MAX, Math.max(0, section.bottom)))
-    this.persist = { ...this.persist, display: next, name: section.name.trim() }
+    this.ledger.setDisplay(next)
     this.flush()
   }
 
@@ -457,12 +365,13 @@ export class PetService extends Service {
   private syncSettingsFromPet(): void {
     const settings = this.ctx.get('settings', false) as { update(ns: string, patch: object): Promise<void> } | undefined
     if (settings === undefined) return
+    const snapshot = this.ledger.snapshot
     void settings.update(PET_SETTINGS_NAMESPACE, {
-      visible: this.persist.display.visible,
-      size: this.persist.display.size,
-      right: this.persist.display.right,
-      bottom: this.persist.display.bottom,
-      name: this.persist.name,
+      visible: snapshot.display.visible,
+      size: snapshot.display.size,
+      right: snapshot.display.right,
+      bottom: snapshot.display.bottom,
+      petId: snapshot.petId,
     }).catch(() => {
       // A settings write failure must not break the pet's own persistence.
     })
@@ -470,83 +379,42 @@ export class PetService extends Service {
 
   /** Award the turn reward once per completed turn (idempotent per session + turn). */
   private rewardTurn(sessionId: string, turn: number): void {
-    const last = this.rewardedTurns.get(sessionId) ?? 0
-    if (turn <= last) return
-    this.rewardedTurns.set(sessionId, turn)
-    this.applyTurnReward()
+    if (this.ledger.rewardTurn(sessionId, turn, Date.now())) this.flush()
   }
 
   /** Preserve turn rewards for installations that only emit legacy activity. */
   private rewardLegacyTurn(): void {
-    const nowMs = Date.now()
-    // A legacy `done` snapshot may repeat during the celebration window.
-    if (nowMs - this.lastLegacyTurnRewardAt < 5_000) return
-    this.lastLegacyTurnRewardAt = nowMs
-    this.applyTurnReward()
-  }
-
-  /** Persist one accepted completed-turn reward. */
-  private applyTurnReward(): void {
-    this.persist = { ...this.persist, affinity: applyTurnReward(this.persist.affinity, this.affinityConfig) }
-    this.flush()
-  }
-
-  /**
-   * Settle the treat economy (work + time output since the last settlement)
-   * and persist whenever the ledger changed. A zero-gain first settlement
-   * still starts the time clock (anchor write), which is what lets the
-   * 30-minute time output ever accrue.
-   */
-  private settleTreats(nowMs: number): void {
-    const settlement = settleTreatGrants(
-      this.persist.treats,
-      this.persist.affinity.turns,
-      nowMs,
-      this.treatConfig,
-    )
-    if (settlement.ledger !== this.persist.treats) {
-      this.persist = { ...this.persist, treats: settlement.ledger }
-      this.flush()
-    }
+    if (this.ledger.rewardLegacyTurn(Date.now())) this.flush()
   }
 
   private view(): PetStateView {
     const snapshot = this.machine.render()
-    // Time-output treats accrue while the host is idle too; settle on read.
-    this.settleTreats(Date.now())
+    const entry = this.activeEntry()
+    // Read-only: the ledger settles on economic events only, never on a read,
+    // so polling the state cannot trigger pet.json writes.
     return {
       animation: snapshot.animation,
       ...(snapshot.bubble === undefined ? {} : { bubble: snapshot.bubble }),
       phase: snapshot.phase,
       sessionActive: snapshot.sessionActive,
-      affinity: this.affinityView(this.persist.affinity),
-      display: { ...this.persist.display },
-      name: this.persist.name,
+      affinity: this.ledger.affinityView(Date.now()),
+      display: { ...this.ledger.snapshot.display },
+      pet: {
+        id: entry.id,
+        displayName: entry.displayName,
+        description: entry.description,
+      },
+      name: this.petName(),
       treats: {
-        stocked: this.persist.treats.treats,
-        max: this.treatConfig.maxTreats,
+        stocked: this.ledger.snapshot.treats.treats,
+        max: this.ledger.treatMax,
       },
     }
   }
 
-  private affinityView(affinity: AffinityState): PetStateView['affinity'] {
-    const nowMs = Date.now()
-    const rank = rankOf(affinity.points)
-    return {
-      points: affinity.points,
-      rank: rank.name,
-      rankEmoji: rank.emoji,
-      pets: affinity.pets,
-      feeds: affinity.feeds,
-      turns: affinity.turns,
-      petCooldown: nowMs - affinity.lastPetAt < this.affinityConfig.petCooldownMs,
-      feedCooldown: nowMs - affinity.lastFeedAt < this.affinityConfig.feedCooldownMs,
-    }
-  }
-
   private flush(): void {
     try {
-      savePetPersist(this.persist, this.persistDir)
+      savePetPersist(this.ledger.snapshot, this.persistDir)
     } catch {
       // Persistence is best-effort; the in-memory ledger keeps working.
     }

package/lib/types/client/WhalePet.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"WhalePet.d.ts","sourceRoot":"","sources":["../../../src/client/WhalePet.tsx"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAqC,WAAW,EAAE,MAAM,OAAO,CAAA;AAE3E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAA;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAGjD,OAAO,EAAE,EAAE,EAAE,MAAM,cAAc,CAAA;AAGjC,iFAAiF;AACjF,eAAO,MAAM,mBAAmB,gCAAgC,CAAA;AAEhE,mFAAmF;AACnF,eAAO,MAAM,gBAAgB,wBAAwB,CAAA;AAErD,wEAAwE;AACxE,MAAM,WAAW,aAAa;IAC5B,gDAAgD;IAChD,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAA;IAC7B,qDAAqD;IACrD,OAAO,EAAE,gBAAgB,CAAA;IACzB,sCAAsC;IACtC,QAAQ,EAAE,WAAW,GAAG,IAAI,CAAA;IAC5B,kCAAkC;IAClC,KAAK,EAAE,MAAM,IAAI,CAAA;IACjB,0CAA0C;IAC1C,MAAM,EAAE,MAAM,IAAI,CAAA;IAClB,0CAA0C;IAC1C,MAAM,EAAE,MAAM,IAAI,CAAA;IAClB,+BAA+B;IAC/B,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IAClD,8CAA8C;IAC9C,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IAChC,2DAA2D;IAC3D,cAAc,EAAE,MAAM,IAAI,CAAA;IAC1B,+CAA+C;IAC/C,CAAC,EAAE,WAAW,CAAC,OAAO,EAAE,CAAC,CAAA;CAC1B;AAOD;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,aAAa,GAAG,WAAW,CAyT1D"}