@linxin666/dsh-pet 0.3.5 → 0.3.9

package/src/client/settings-form.ts

@@ -8,8 +8,9 @@
  * card-store pattern.
  */
 
-import type { SettingsScope, SettingsScopeSnapshot, SnapshotStore } from '@deepseek-ai/dsh-client-runtime/client'
-import { createSnapshotStore } from '@deepseek-ai/dsh-client-runtime/client'
+import type { SettingsScope, SettingsScopeSnapshot } from '@deepseek-ai/dsh-client-ui-settings/client'
+import type { SnapshotStore } from '@deepseek-ai/dsh-client-store'
+import { createSnapshotStore } from '@deepseek-ai/dsh-client-store'
 
 /** The write one field's staged text performs when the card is saved. */
 export type FieldWrite =
@@ -23,9 +24,11 @@ export interface FieldSpec {
   /**
    * Whether the Host treats this field as a secret and redacts its value from
    * the read-back (role('secret') in the section schema). Redacted secrets are
-   * never compared against the draft on save; the field lands when the scope
-   * reports the write succeeded (its secret-set marker under the bridge), so
-   * a successful secret save is not misreported as failed.
+   * never compared against the draft on save: the Host strips them from every
+   * wire view layer, so the settled snapshot carries nothing to read back. A
+   * staged secret set is judged by the mutation settling; the rest of its
+   * batch, when one exists, is still judged by read-back, and the atomic
+   * mutation lands every write or none.
    */
   secret?: boolean
   /** Render a stored value as draft text; the empty string when the section carries none. */
@@ -53,8 +56,8 @@ export interface CardShell {
   available: boolean
   /**
    * Whether the namespace is actually served to this client. False when the
-   * Host deployment does not expose it (e.g. the official apiproxy settings
-   * allowlist omits third-party namespaces): the card renders an explanation
+   * Host deployment does not expose it (e.g. the owning plugin's settings
+   * domain is not mounted): the card renders an explanation
    * instead of its form, so a missing namespace never looks like a missing
    * plugin.
    */
@@ -101,13 +104,17 @@ interface StagedEdit {
 interface PlannedWrite {
   /** Field this entry writes. */
   field: string
-  /** The durable write this entry performs, described for a batched scope. */
+  /** The durable write this entry performs, inside the save's one atomic mutation. */
   op: BatchedWrite
-  /** Perform the write and report whether the Host holds the staged value afterwards. */
-  run: (() => Promise<boolean>) | undefined
+  /**
+   * Read the settled snapshot back and report whether the Host holds this
+   * write's effect. Undefined when the draft is not a value the field
+   * accepts: there is nothing to write, and the entry blocks the save.
+   */
+  judge: (() => boolean) | undefined
 }
 
-/** One durable write a batched settings scope performs. */
+/** One durable write inside the save's atomic scope mutation. */
 export interface BatchedWrite {
   /** Field this entry writes. */
   field: string
@@ -117,36 +124,6 @@ export interface BatchedWrite {
   value?: unknown
 }
 
-/** Per-field outcome of one batched scope write. */
-export interface BatchedFieldResult {
-  /** Field this entry writes. */
-  field: string
-  /** Whether the Host accepted this field's write (per the read-back view). */
-  landed: boolean
-}
-
-/**
- * Result of a batched scope write. The bridge scope posts every planned write
- * in one /mutate so the Host validate hook judges baseURL+model together; a
- * batched refusal fails the whole save rather than per-field.
- */
-export interface BatchResult {
-  /** Whether the whole mutate was accepted. */
-  ok: boolean
-  /** Per-field success, in the request order (always present when ok). */
-  fields: BatchedFieldResult[]
-  /** Host rejection code (mutate refused). */
-  code?: string
-  /** Host rejection message (mutate refused). */
-  message?: string
-}
-
-/** The optional batch surface the bridge scope adds over the SettingsScope contract. */
-interface BatchedSettingsScope {
-  /** Write every operation in one scope mutation, reporting per-field success. */
-  mutate: (writes: BatchedWrite[]) => Promise<BatchResult>
-}
-
 /** Constraints a numeric field's accepted drafts must satisfy, mirroring the host schema. */
 export interface NumberConstraints {
   /** The accepted value must be a whole number. */
@@ -188,8 +165,8 @@ export function textField(field: string): FieldSpec {
 /**
  * A free-text field the Host treats as a secret and redacts from the read-back
  * (role('secret') in the section schema). The card still edits it like text,
- * but a save never compares the redacted value back and relies on the scope
- * reporting the write landed.
+ * but a save never compares the redacted value back: the staged set is judged
+ * by the mutation settling (see {@link FieldSpec.secret}).
  */
 export function secretField(field: string): FieldSpec {
   return { ...textField(field), secret: true }
@@ -277,7 +254,7 @@ export class CardForm<T> {
       exposed: snapshot.status === 'ready',
       writable: snapshot.writable,
       dirty: plan.length > 0,
-      invalid: plan.some(item => item.run === undefined),
+      invalid: plan.some(item => item.judge === undefined),
       saving: this.saving,
       failed: this.failed,
       ...this.failedReason === undefined ? {} : { failedReason: this.failedReason },
@@ -318,21 +295,25 @@ export class CardForm<T> {
   }
 
   /**
-   * Write every staged edit, then re-seed from what the Host accepted.
+   * Write every staged edit in one atomic scope mutation, then re-seed from
+   * what the Host accepted.
    *
-   * When the scope carries the optional batch surface (the dsh-web
-   * bridge scope), every planned write rides one mutation so cross-field
-   * validate hooks (baseURL+model) judge the batch as a unit instead of
-   * deadlocking on per-field writes. Otherwise the per-field loop runs.
-   * A field lands only when the Host reports it held the staged value; a
-   * landed field's draft is dropped, a failed one stays staged for the user.
-   * @returns settlement after every write and the read-back.
+   * The whole batch rides one mutate, so cross-field validate hooks
+   * (baseURL+model) judge it as a unit: the Host either applies every write
+   * or refuses the batch. The 0.1.2 scope contract never rejects a refused
+   * mutation — the scope recovers with a fresh Host view and resolves — so
+   * resolution alone proves nothing: the outcome is judged by reading the
+   * settled snapshot back, one planned write at a time, and one missed write
+   * fails the whole save. A scope that still rejects on refusal (the dsh-web
+   * bridge scope) reports through the same failure path with its rejection
+   * message. A save that did not land keeps its drafts, so the user can
+   * correct them instead of retyping.
+   * @returns settlement after the mutation and the read-back.
    */
   async save(): Promise<void> {
     const plan = this.plan()
-    const valid = plan.filter(item => item.run !== undefined)
+    const valid = plan.filter((item): item is PlannedWrite & { judge: () => boolean } => item.judge !== undefined)
     if (plan.length === 0 || this.saving || valid.length !== plan.length) return
-    const plannedWrites = valid.map(item => item.op)
     // Snapshot the staged entries this save writes, so an edit staged while it
     // is in flight (which replaces the same key) survives: only delete the key
     // when the entry is still the one this save started from.
@@ -342,36 +323,34 @@ export class CardForm<T> {
     this.failed = false
     this.failedReason = undefined
     this.publish()
-    const landed = new Set<string>()
-    const batch = this.batchedScope()
-    if (batch !== undefined) {
-      const result = await batch.mutate(plannedWrites)
-      if (result.ok) {
-        for (const field of result.fields) {
-          if (field.landed) landed.add(field.field)
-        }
-      } else {
-        this.failedReason = result.message
-      }
-    } else {
-      for (const item of valid) {
-        if (await item.run!()) landed.add(item.field)
-      }
+    // One atomic namespace mutation: the 0.1.2 scope contract takes ordered
+    // path operations, so the whole staged batch is validated, persisted, and
+    // recovered together — either every write lands or none does.
+    const ops: Array<{ op: 'set'; path: string[]; value: string | number | boolean } | { op: 'unset'; path: string[] }> = valid.map(item => item.op.op === 'set'
+      ? { op: 'set', path: [item.field], value: (item.op as { value: string | number | boolean }).value }
+      : { op: 'unset', path: [item.field] })
+    let failedReason: string | undefined
+    try {
+      await this.scope.mutate(ops)
+    } catch (error) {
+      failedReason = error instanceof Error ? error.message : String(error)
     }
+    // The 0.1.2 scope resolves even a refused mutation (it recovers with a
+    // fresh view instead of throwing), so resolution alone proves nothing:
+    // judge every planned write against the settled snapshot. The mutation is
+    // atomic, so one missed write fails the whole save and keeps the drafts.
+    const landed = failedReason === undefined && valid.every(item => item.judge())
     for (const [field, before] of pending) {
-      if (landed.has(field) && this.staged.get(field) === before) this.staged.delete(field)
+      if (landed && this.staged.get(field) === before) this.staged.delete(field)
     }
     this.saving = false
-    this.failed = landed.size !== pending.size
+    this.failed = !landed
+    // A read-back failure carries no server reason: the card surfaces its
+    // generic failure copy; a rejecting scope (the bridge) adds its message.
+    this.failedReason = failedReason
     this.publish()
   }
 
-  /** The scope's batch surface when it supports one; undefined conservatively otherwise. */
-  private batchedScope(): BatchedSettingsScope | undefined {
-    const candidate = this.scope as unknown as BatchedSettingsScope | undefined
-    return typeof candidate?.mutate === 'function' ? candidate : undefined
-  }
-
   /**
    * Every staged edit a save would write. An entry whose draft is not a value
    * its field accepts carries no write: the form is still dirty, and the save
@@ -384,33 +363,40 @@ export class CardForm<T> {
     for (const [field, staged] of this.staged) {
       const spec = this.specOf(field)
       if (staged.clear) {
-        if (this.stored(field)) plan.push({ field, op: { field, op: 'unset' }, run: () => this.clear(field) })
+        if (this.stored(field)) plan.push({ field, op: { field, op: 'unset' }, judge: () => this.landedUnset(field) })
         continue
       }
       if (staged.text === spec.format(this.sectionValue(field))) continue
       const write = spec.parse(staged.text)
-      if (write === undefined) plan.push({ field, op: { field, op: 'unset' }, run: undefined })
-      else if (write.kind === 'clear') plan.push({ field, op: { field, op: 'unset' }, run: () => this.clear(field) })
-      else plan.push({ field, op: { field, op: 'set', value: write.value }, run: () => this.store(field, write.value) })
+      if (write === undefined) plan.push({ field, op: { field, op: 'unset' }, judge: undefined })
+      else if (write.kind === 'clear') plan.push({ field, op: { field, op: 'unset' }, judge: () => this.landedUnset(field) })
+      else plan.push({ field, op: { field, op: 'set', value: write.value }, judge: () => this.landedSet(field, write.value) })
     }
     return plan
   }
 
-  private async clear(field: string): Promise<boolean> {
-    await this.scope.unset(field)
-    return !this.stored(field)
-  }
-
-  private async store(field: string, value: unknown): Promise<boolean> {
-    await this.scope.set(field, value)
-    // A redacted secret never appears in the user layer read-back; judging it
-    // by value would misreport a successful secret save as failed. The bridge
-    // reports secret writes through its secret-set markers (batch path); on
-    // the per-field path the scope resolved, so the write is landed.
+  /**
+   * Read-back judgment for a planned set: the user layer must hold the
+   * intended value once the mutation has settled.
+   */
+  private landedSet(field: string, value: unknown): boolean {
+    // A redacted secret never appears in any wire view layer: the Host strips
+    // role('secret') fields and reports them through a sidecar the scope
+    // snapshot does not expose, so there is nothing to compare the draft
+    // against. Settling is the only signal the form has; the rest of the
+    // batch, when one exists, still carries the atomic verdict by read-back.
     if (this.specOf(field).secret) return true
     return this.userLayer()?.[field] === value
   }
 
+  /**
+   * Read-back judgment for a planned unset: the field must be gone from the
+   * user layer once the mutation has settled.
+   */
+  private landedUnset(field: string): boolean {
+    return !this.stored(field)
+  }
+
   private stage(field: string, edit: StagedEdit): void {
     this.staged.set(field, edit)
     this.failed = false

package/src/dsh-home.ts

@@ -39,4 +39,4 @@ export function resolveDshHome(env: NodeJS.ProcessEnv = process.env, home: strin
 /** Resolve the DSH home directory from the live environment. */
 export function dshHome(): string {
   return resolveDshHome()
-}
+}

package/src/index.ts

@@ -12,7 +12,7 @@
  */
 
 import { Context } from '@deepseek-ai/cordis'
-import { installSettingsSection, settingsNamespace } from '@deepseek-ai/dsh-settings'
+import type { SettingsNamespace } from '@deepseek-ai/dsh-settings'
 import type {} from '@deepseek-ai/dsh-host-webserver'
 import z from 'schemastery'
 import { PetService, PET_SETTINGS_NAMESPACE, type PetConfig, type PetSettingsSection } from './service.ts'
@@ -189,20 +189,22 @@ function applyImpl(ctx: Context, config: PetConfig = {}): void {
       disposeRoutes = undefined
     }
   }
-  installSettingsSection(
-    ctx,
-    settingsNamespace(PET_SETTINGS_NAMESPACE),
-    makePetSettingsSchema(service.selectedPetId()),
-    base,
-    {
-      setSource: (source) => { current = source },
-      onChange: () => {
-        const section = current()
-        service.applySettingsSection(section)
-        service.setEnabled(section.enabled ?? true)
-        syncRoutes()
+  ctx.inject(['settings'], (settingsCtx) => {
+    settingsCtx.settings.installSection(
+      ctx,
+      PET_SETTINGS_NAMESPACE as SettingsNamespace,
+      makePetSettingsSchema(service.selectedPetId()),
+      base,
+      {
+        setSource: (source) => { current = source },
+        onChange: () => {
+          const section = current()
+          service.applySettingsSection(section)
+          service.setEnabled(section.enabled ?? true)
+          syncRoutes()
+        },
       },
-    },
-  )
+    )
+  })
   syncRoutes()
 }

package/src/ledger.ts

@@ -32,6 +32,8 @@ export interface LedgerConfig {
   treats?: Partial<TreatConfig>
   /** Per-pet remark pools for the selected pet (custom slots override built-ins). */
   remarks?: PetRemarks
+  /** Voice-pack fallback remark pools (global or pet voice pack). */
+  voiceRemarks?: PetRemarks
 }
 
 /** Result of one ledger interaction (the shape the pet RPC returns). */
@@ -63,7 +65,7 @@ export class PetLedger {
   constructor(persist: PetPersist, config: LedgerConfig = {}) {
     this.affinityConfig = { ...defaultAffinityConfig, ...(config.affinity ?? {}) }
     this.treatConfig = { ...defaultTreatConfig, ...(config.treats ?? {}) }
-    this.picker = new RemarkPicker(config.remarks)
+    this.picker = new RemarkPicker(config.remarks, config.voiceRemarks)
     this.current = persist
   }
 
@@ -124,10 +126,10 @@ export class PetLedger {
 
   /**
    * Swap the reaction pools to another pet's custom remarks (called on pet
-   * selection). Slots the pet does not declare fall back to built-ins.
+   * selection). Slots the pet does not declare fall back to voice packs or built-ins.
    */
-  setRemarks(remarks?: PetRemarks): void {
-    this.picker = new RemarkPicker(remarks)
+  setRemarks(remarks?: PetRemarks, voiceRemarks?: PetRemarks): void {
+    this.picker = new RemarkPicker(remarks, voiceRemarks)
   }
 
   /**

package/src/pair-access.ts

@@ -0,0 +1,49 @@
+// Generated by scripts/sync-shared.mjs from shared/host/pair-access.ts. Do not edit this copy; edit the shared source and run "node scripts/sync-shared.mjs".
+/**
+ * Pairing trust fence shared by plugins that expose host routes: loopback
+ * (the desktop) always passes; a live paired-device cookie is an additional
+ * allow path when remote-web-ui is loaded. The consuming plugin never
+ * depends on that plugin — without the service the fence stays
+ * loopback-only.
+ *
+ * Per-package wrappers (access.ts) call this with their own name so each
+ * plugin keeps a self-describing export; the security decision lives only
+ * here.
+ */
+import type { IncomingMessage } from 'node:http'
+import { isLoopbackRequest } from './loopback.ts'
+
+/** Structural pairing lookup (no package dependency on remote-web-ui). */
+interface PairingAccess {
+  isPairedDevice(request: IncomingMessage): boolean
+}
+
+/**
+ * Structural host-context shape: shared sources carry no @deepseek-ai
+ * dependency (the shared package must typecheck standalone), so the fence
+ * reads only the two members it needs; cordis Context satisfies this.
+ * ctx.get is optional on the test harness; production Context always has it.
+ */
+interface LookupCtx {
+  get?(name: string, strict?: boolean): unknown
+  remoteWebUiPairing?: PairingAccess
+}
+
+/**
+ * Whether this request may enter the plugin's host routes.
+ * @param ctx - host context; may expose remoteWebUiPairing.
+ * @param request - the incoming HTTP request.
+ * @returns true for loopback, or a live paired-device cookie.
+ */
+export function isPairedOrLoopbackAllowed(ctx: LookupCtx, request: IncomingMessage): boolean {
+  if (isLoopbackRequest(request)) return true
+  const fromGet = typeof ctx.get === 'function' ? ctx.get('remoteWebUiPairing', false) : undefined
+  const pairing = (isPairingAccess(fromGet) ? fromGet : ctx.remoteWebUiPairing)
+  return pairing?.isPairedDevice(request) === true
+}
+
+function isPairingAccess(value: unknown): value is PairingAccess {
+  return value !== undefined
+    && value !== null
+    && typeof (value as PairingAccess).isPairedDevice === 'function'
+}

package/src/remarks.test.ts

@@ -54,6 +54,16 @@ describe('RemarkPicker', () => {
     expect(picker.pick('pet')).toBe('专属摸头台词')
     expect(picker.pick('feed')).toBe(BUILTIN_REMARKS.feed[0])
   })
+
+  it('layers pet custom lines over voice pack lines, falling back to built-ins (#1226)', () => {
+    const picker = new RemarkPicker(
+      { pet: ['Pet-level line'] },
+      { pet: ['Voice-level pet line'], feed: ['Voice-level feed line'] },
+    )
+    expect(picker.pick('pet')).toBe('Pet-level line')
+    expect(picker.pick('feed')).toBe('Voice-level feed line')
+    expect(picker.pick('noTreats')).toBe(BUILTIN_REMARKS.noTreats[0])
+  })
 })
 
 describe('normalizePetRemarks', () => {

package/src/remarks.ts

@@ -184,11 +184,18 @@ export class RemarkPicker {
   private readonly counters = new Map<RemarkKind, number>()
   private readonly pools: Record<RemarkKind, readonly string[]>
 
-  constructor(overrides?: PetRemarks) {
+  constructor(overrides?: PetRemarks, voiceOverrides?: PetRemarks) {
     this.pools = {} as Record<RemarkKind, readonly string[]>
     for (const kind of REMARK_KINDS) {
       const custom = overrides?.[kind]
-      this.pools[kind] = custom !== undefined && custom.length > 0 ? custom : BUILTIN_REMARKS[kind]
+      const voice = voiceOverrides?.[kind]
+      if (custom !== undefined && custom.length > 0) {
+        this.pools[kind] = custom
+      } else if (voice !== undefined && voice.length > 0) {
+        this.pools[kind] = voice
+      } else {
+        this.pools[kind] = BUILTIN_REMARKS[kind]
+      }
     }
   }
 

package/src/service.ts

@@ -15,6 +15,7 @@
 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 { announcementFresh, parseAnnouncement, type PetAnnouncement } from './announce.ts'
 import type { TreatConfig } from './treats.ts'
 import {
   emptyProjectionRuntime,
@@ -191,6 +192,12 @@ export interface PetStateView {
    * settles the view in memory but never writes pet.json.
    */
   gameplay?: PetGameplayStateView
+  /**
+   * The freshest plugin-authored announcement (dsh-usage linkage), within
+   * its TTL; absent when none is fresh. Rendered as a dedicated styled
+   * bubble above the session stack.
+   */
+  announcement?: PetAnnouncement
 }
 
 /** Result of `pet.interact`. */
@@ -224,7 +231,6 @@ declare module '@deepseek-ai/cordis' {
     pet: PetService
   }
 }
-
 /** Per-session pet activity: projection runtime plus the session's own machine. */
 interface SessionActivity {
   runtime: ProjectionRuntime
@@ -257,6 +263,8 @@ export class PetService extends Service {
   private enabled: boolean
   /** Status-decoration master switch (M5, #567); mirrored from settings. */
   private decorationEnabled: boolean
+  /** The freshest plugin-authored announcement (dsh-usage linkage). */
+  private announcement: PetAnnouncement | undefined
   private disposeActivity: (() => void) | undefined
   /** Session whose most recent meaningful event currently drives the global pet. */
   private displaySession: Session | undefined
@@ -297,10 +305,12 @@ export class PetService extends Service {
       persist = { ...persist, petId: this.registry.defaultEntry().id }
     }
     const selected = this.registry.byId(persist.petId) ?? this.registry.defaultEntry()
+    const voiceRemarks = mergeVoicePacks(this.registry.globalVoice, selected.voice)?.remarks
     const ledgerConfig: LedgerConfig = {
       affinity: config.affinity,
       treats: config.treats,
       remarks: selected.remarks,
+      voiceRemarks,
     }
     this.ledger = new PetLedger(persist, ledgerConfig)
     this.stateConfig = { ...defaultPetStateConfig, ...(config.state ?? {}) }
@@ -338,6 +348,19 @@ export class PetService extends Service {
     return this.view(currentSessionId)
   }
 
+  /**
+   * RPC: one plugin-authored announcement bubble (dsh-usage linkage). The
+   * payload is validated into a bounded PetAnnouncement; a malformed one is
+   * dropped silently — a sibling plugin's bug must never surface as pet
+   * breakage. The announcement is in-memory only.
+   */
+  announce(input: unknown): { ok: boolean } {
+    const parsed = parseAnnouncement(input, Date.now())
+    if (parsed === undefined) return { ok: false }
+    this.announcement = parsed
+    return { ok: true }
+  }
+
   /** Current persisted display config (read-only view). */
   display(): PetDisplayConfig {
     return { ...this.ledger.snapshot.display }
@@ -390,7 +413,8 @@ export class PetService extends Service {
     const entry = this.registry.byId(petId)
     if (entry === undefined) return { ok: false, error: 'unknown-pet' }
     this.ledger.setPetId(entry.id)
-    this.ledger.setRemarks(entry.remarks)
+    const voiceRemarks = mergeVoicePacks(this.registry.globalVoice, entry.voice)?.remarks
+    this.ledger.setRemarks(entry.remarks, voiceRemarks)
     this.flush()
     this.syncSettingsFromPet()
     return { ok: true, petId: entry.id }
@@ -810,6 +834,11 @@ export class PetService extends Service {
     }
     // Read-only: the ledger settles on economic events only, never on a read,
     // so polling the state cannot trigger pet.json writes.
+    // An expired announcement simply stops appearing (the client's 2 s poll
+    // drops it); no timer owns its removal.
+    const announcement = this.announcement !== undefined && announcementFresh(this.announcement, Date.now())
+      ? this.announcement
+      : undefined
     return {
       animation: snapshot.animation,
       ...(snapshot.bubble === undefined ? {} : { bubble: snapshot.bubble }),
@@ -817,6 +846,7 @@ export class PetService extends Service {
       sessionActive: snapshot.sessionActive,
       sessions,
       ...(decoration === undefined ? {} : { decoration }),
+      ...(announcement === undefined ? {} : { announcement }),
       affinity: this.ledger.affinityView(Date.now()),
       display: { ...this.ledger.snapshot.display },
       pet: {

package/src/voice-pack.test.ts

@@ -53,6 +53,45 @@ describe('normalizeVoicePack structure', () => {
     expect(warnings.join('\n')).toContain('mystery')
     expect(warnings.join('\n')).toContain('voicePackVersion')
   })
+
+  it('normalizes top-level remarks and ranks (#1226)', () => {
+    const { pack, warnings } = collectWarnings({
+      remarks: {
+        pet: ['Purr~ So comfortable!'],
+        feed: 'Yummy fish!',
+      },
+      ranks: {
+        '0': 'Baby Whale',
+        '幼鲸': 'Little Whale',
+      },
+    })
+    expect(pack).toBeDefined()
+    expect(pack?.remarks?.pet).toEqual(['Purr~ So comfortable!'])
+    expect(pack?.remarks?.feed).toEqual(['Yummy fish!'])
+    expect(pack?.ranks).toEqual({
+      '0': 'Baby Whale',
+      '幼鲸': 'Little Whale',
+    })
+    expect(warnings).toHaveLength(0)
+  })
+
+  it('merges remarks and ranks across layers (#1226)', () => {
+    const base = normalizeVoicePack({
+      remarks: { pet: ['Base pet'], feed: ['Base feed'] },
+      ranks: { '0': 'Base 0', '25': 'Base 25' },
+    })
+    const layer = normalizeVoicePack({
+      remarks: { pet: ['Layer pet'] },
+      ranks: { '0': 'Layer 0' },
+    })
+    const merged = mergeVoicePacks(base, layer)
+    expect(merged?.remarks?.pet).toEqual(['Layer pet'])
+    expect(merged?.remarks?.feed).toEqual(['Base feed'])
+    expect(merged?.ranks).toEqual({
+      '0': 'Layer 0',
+      '25': 'Base 25',
+    })
+  })
 })
 
 describe('normalizePool', () => {