Yichen Jiang
0caceb2ced
`ProfileRuntime.recompose({ reloadBundles: true })` replaced its profile
before the Loader had accepted the update, so a rejected recomposition left
`current`, `layers`, and `originOf` describing a stack that never mounted.
The user patch watchers took a second path through the launcher's
`composeLive`, which wrote the new conflicts into the failure registry
before the update and kept composing from the runtime's stale profile.
Conflict records shared the registry with row failures under a fabricated
entry id and a group id that meant three different things, so the plugin
inventory attributed a conflict to the layer that won the id, and a bundle
disabled after failing kept its import and apply records forever.
The runtime now holds one committed composition — profile, stack ownership,
conflicts — and publishes a candidate only after `entry.update` resolves;
`originOf` reads the committed owners instead of recomputing them. The
watchers call `recompose` through a `reapply` callback, so every live change
goes through the one entry point. Conflicts live on the runtime with their
messages and never enter `pluginFailures`, whose records name rows that
reached the Loader; the inventory lists them under the layer that lost. A
contained group clears its rows' records when it unmounts.
138 lines
7.7 KiB
TypeScript
138 lines
7.7 KiB
TypeScript
/**
|
|
* Tree-wide row-id ownership across the profile stack: built-in layers claim
|
|
* first and fail loud on a duplicate, an external bundle that collides is left
|
|
* out and recorded, a bundle that repeats one of its own ids is left out the
|
|
* same way, a user insert of a taken id is dropped, and every conflict
|
|
* carries its message.
|
|
*/
|
|
|
|
import { describe, expect, it } from 'vitest'
|
|
import type { EntryOptions } from '@deepseek-ai/cordis-plugin-loader'
|
|
import type { PatchOptions } from '@deepseek-ai/cordis-plugin-include'
|
|
import { claimLayerIds, composeProfileStack, CONTAINED_GROUP_MODULE, formatRowConflict, type ProfileLayer } from '../src/index.ts'
|
|
|
|
const NAME = 'dsh-test-bin'
|
|
|
|
function layer(
|
|
packageName: string, trust: ProfileLayer['trust'], patches: PatchOptions[], stage: ProfileLayer['stage'] = 'runtime',
|
|
): ProfileLayer {
|
|
return { packageName, version: '1.0.0', packageDir: '/nowhere', patchPath: '/nowhere/cordis.patch.yml', trust, stage, patches }
|
|
}
|
|
|
|
const base = layer('@deepseek-ai/dsh-base', 'builtin', [{ insert: [
|
|
{ id: 'settings', name: 'settings' },
|
|
{ id: 'tools', name: 'cordis:group', group: true, config: [{ id: 'tool-bash', name: 'bash' }] },
|
|
] }])
|
|
|
|
describe('claimLayerIds', () => {
|
|
it('lets built-in layers own their ids, including group children, before any external layer', () => {
|
|
const ext = layer('ext', 'external', [{ insert: [{ id: 'tool-bash', name: 'ext' }] }])
|
|
const { owners, skipped } = claimLayerIds([ext, base])
|
|
expect(owners.get('tool-bash')?.packageName).toBe('@deepseek-ai/dsh-base')
|
|
expect(owners.get('tools')?.packageName).toBe('@deepseek-ai/dsh-base')
|
|
expect(skipped.get('ext')).toEqual([
|
|
{
|
|
rowId: 'tool-bash', moduleName: 'ext', layer: 'ext', packageName: 'ext', declaredBy: '@deepseek-ai/dsh-base',
|
|
message: 'row "tool-bash" is already declared by @deepseek-ai/dsh-base',
|
|
},
|
|
])
|
|
})
|
|
|
|
it('throws when two built-in or boot-staged layers declare one id, or one declares it twice', () => {
|
|
const twin = layer('twin', 'external', [{ insert: [{ id: 'settings', name: 'twin' }] }], 'boot')
|
|
expect(() => claimLayerIds([base, twin])).toThrow(/row "settings" is declared by both @deepseek-ai\/dsh-base and twin/)
|
|
const stutter = layer('stutter', 'builtin', [{ insert: [{ id: 'x', name: 'a' }] }, { insert: [{ id: 'x', name: 'b' }] }])
|
|
expect(() => claimLayerIds([stutter])).toThrow(/row "x" is declared twice by stutter/)
|
|
})
|
|
|
|
it('leaves out a bundle that declares one of its own ids twice and composes each mounted bundle once', () => {
|
|
const stutter = layer('stutter', 'external', [{ insert: [{ id: 'x', name: 'stutter/a' }, { id: 'x', name: 'stutter/b' }] }])
|
|
const clean = layer('clean', 'external', [{ insert: [{ id: 'y', name: 'clean' }] }])
|
|
const { owners, skipped, composed } = claimLayerIds([base, stutter, clean])
|
|
expect(skipped.get('stutter')).toEqual([
|
|
{ rowId: 'x', moduleName: 'stutter/b', layer: 'stutter', packageName: 'stutter', declaredBy: 'stutter', message: 'row "x" is declared twice by stutter' },
|
|
])
|
|
expect(owners.has('x')).toBe(false)
|
|
expect(owners.get('y')?.packageName).toBe('clean')
|
|
expect([...composed.keys()]).toEqual(['clean'])
|
|
expect(composed.get('clean')?.patches[1]).toEqual({ id: 'bundle/clean', insert: [{ id: 'y', name: 'clean' }] })
|
|
})
|
|
|
|
it('gives the earlier external bundle the id and leaves the later one out whole', () => {
|
|
const first = layer('first', 'external', [{ insert: [{ id: 'hello', name: 'first' }, { id: 'only-first', name: 'first/x' }] }])
|
|
const second = layer('second', 'external', [{ insert: [{ id: 'hello', name: 'second' }, { id: 'only-second', name: 'second/x' }] }])
|
|
const { owners, skipped } = claimLayerIds([base, first, second])
|
|
expect(owners.get('hello')?.packageName).toBe('first')
|
|
expect(owners.get('bundle/first')?.packageName).toBe('first')
|
|
expect(owners.has('only-second')).toBe(false)
|
|
expect(skipped.get('second')?.map(conflict => conflict.rowId)).toEqual(['hello'])
|
|
})
|
|
})
|
|
|
|
describe('composeProfileStack', () => {
|
|
it('mounts owning layers in manifest order and drops a user insert of a taken id', () => {
|
|
const ext = layer('ext', 'external', [{ insert: [{ id: 'ext-tool', name: 'ext' }] }])
|
|
const stack = composeProfileStack(NAME, [base, ext], [
|
|
{ label: '/p/cordis.patch.yml', patches: [
|
|
{ id: 'settings', config: { path: '/x' } },
|
|
{ insert: [{ id: 'mine', name: 'mine' }, { id: 'ext-tool', name: 'clash' }] },
|
|
{ insert: [{ id: 'g', name: 'cordis:group', group: true, config: [{ id: 'tool-bash', name: 'nested-clash' }] }] },
|
|
] },
|
|
{ label: '/home/cordis.patch.yml', patches: [
|
|
{ insert: [{ id: 'mine', name: 'twice' }] },
|
|
{ insert: [{ id: 'clean', name: 'clean' }, { name: 'anonymous' } as EntryOptions] },
|
|
] },
|
|
])
|
|
expect(stack.layers.map(current => current.label)).toEqual(['@deepseek-ai/dsh-base', 'ext', '/p/cordis.patch.yml', '/home/cordis.patch.yml'])
|
|
expect(stack.layers[1]?.patches[0]?.insert?.[0]).toMatchObject({ id: 'bundle/ext', name: CONTAINED_GROUP_MODULE })
|
|
expect([...stack.owners.keys()]).toEqual(['settings', 'tools', 'tool-bash', 'ext-tool', 'bundle/ext'])
|
|
expect(stack.layers[2]?.patches).toEqual([
|
|
{ id: 'settings', config: { path: '/x' } },
|
|
{ insert: [{ id: 'mine', name: 'mine' }] },
|
|
])
|
|
// An insert with no conflict passes through as the same object; an anonymous row claims nothing.
|
|
expect(stack.layers[3]?.patches).toEqual([{ insert: [{ id: 'clean', name: 'clean' }, { name: 'anonymous' }] }])
|
|
expect(stack.patches).toEqual(stack.layers.flatMap(current => current.patches))
|
|
expect(stack.skippedBundles).toEqual([])
|
|
expect(stack.conflicts).toEqual([
|
|
{ rowId: 'ext-tool', moduleName: 'clash', layer: '/p/cordis.patch.yml', declaredBy: 'ext', message: 'row "ext-tool" is already declared by ext' },
|
|
{
|
|
rowId: 'tool-bash', moduleName: 'cordis:group', layer: '/p/cordis.patch.yml', declaredBy: '@deepseek-ai/dsh-base',
|
|
message: 'row "tool-bash" is already declared by @deepseek-ai/dsh-base',
|
|
},
|
|
{
|
|
rowId: 'mine', moduleName: 'twice', layer: '/home/cordis.patch.yml', declaredBy: '/p/cordis.patch.yml',
|
|
message: 'row "mine" is already declared by /p/cordis.patch.yml',
|
|
},
|
|
])
|
|
})
|
|
|
|
it('leaves a colliding external bundle out of the stack and reports it', () => {
|
|
const clash = layer('clash', 'external', [{ insert: [{ id: 'settings', name: 'clash' }] }])
|
|
const stack = composeProfileStack(NAME, [base, clash], [])
|
|
expect(stack.layers.map(current => current.label)).toEqual(['@deepseek-ai/dsh-base'])
|
|
expect(stack.skippedBundles).toEqual(['clash'])
|
|
expect(stack.conflicts).toEqual([
|
|
{
|
|
rowId: 'settings', moduleName: 'clash', layer: 'clash', packageName: 'clash', declaredBy: '@deepseek-ai/dsh-base',
|
|
message: 'row "settings" is already declared by @deepseek-ai/dsh-base',
|
|
},
|
|
])
|
|
})
|
|
|
|
it('prefixes a built-in duplicate with the binary name', () => {
|
|
const twin = layer('twin', 'builtin', [{ insert: [{ id: 'settings', name: 'twin' }] }])
|
|
expect(() => composeProfileStack(NAME, [base, twin], [])).toThrow(/^dsh-test-bin: row "settings" is declared by both/)
|
|
})
|
|
})
|
|
|
|
describe('formatRowConflict', () => {
|
|
it('names the bundle left out, or the user layer whose insert was skipped', () => {
|
|
const message = 'row "x" is already declared by base'
|
|
expect(formatRowConflict({ rowId: 'x', moduleName: 'm', layer: 'pkg', packageName: 'pkg', declaredBy: 'base', message }))
|
|
.toBe('bundle pkg left out — row "x" is already declared by base')
|
|
expect(formatRowConflict({ rowId: 'x', moduleName: 'm', layer: '/p/cordis.patch.yml', declaredBy: 'base', message }))
|
|
.toBe('/p/cordis.patch.yml: insert of m skipped — row "x" is already declared by base')
|
|
})
|
|
})
|