import { test, expect, afterAll, chai } from 'vitest';
const trace = []; let taskA, taskB, localA, localB, aliasA, aliasB, publicB, receiver, phase = 'collection';
const transfer = chai.util.transferFlags; const exact = new Error('transfer-exact-copy-failure');
expect.extend({ toObserveTransfer(actual, expected) {
 trace.push({ phase, kind: 'matcher', sameAssertion: this.assertion === receiver, taskA: this.task === taskA, taskB: this.task === taskB, noTask: this.task === undefined, actual, expected });
 return { pass: actual === expected, message: () => 'transferred value differs' };
} });
const alias = assertion => { Object.defineProperty(assertion, 'not', { configurable: true, get() { return this; } }); return assertion.not; };
const call = (label, assertion, value) => { phase = label; receiver = assertion; assertion.toObserveTransfer(value); };
const caught = (label, source, destination, ...rest) => { try { const result = transfer.call({ label }, source, destination, ...rest); trace.push({ phase: label, kind: 'return', undefined: result === undefined }); } catch (error) { trace.push({ phase: label, kind: 'throw', sameError: error === exact, name: error.name, message: error.message }); } };
test('transfer actual task A', context => { taskA = context.task; localA = context.expect; aliasA = alias(localA('A')); call('initial-A', aliasA, 'A'); });
test('transfer ownership and exact partial copies', context => {
 taskB = context.task; localB = context.expect; publicB = localB('B'); aliasB = alias(publicB); call('initial-B', aliasB, 'B'); const taskFlagB = chai.util.flag(aliasB, 'vitest-test');
 caught('known-to-known', aliasA, aliasB); call('known-raw-B', aliasB, 'A'); call('known-public-B', publicB, 'A');
 const unknown = new chai.Assertion('unknown'); caught('unknown-preserves-task', unknown, aliasB); call('unknown-source', aliasB, 'unknown');
 chai.util.flag(unknown, 'vitest-test', undefined); caught('explicit-undefined-task', unknown, aliasB); call('undefined-source', aliasB, 'unknown');
 caught('restore-A', aliasA, aliasB); call('restored-source', aliasB, 'A');
 const taskFlag = chai.util.flag(aliasA, 'vitest-test');
 const partial = { __flags: { object: 'partial', 'vitest-test': taskFlag, get finalFailure() { trace.push({ phase: 'partial-getter', kind: 'read' }); throw exact; } } };
 caught('partial-after-task', partial, aliasB); call('partial-task-applied', aliasB, 'partial');
 const failedFirst = { __flags: { get 'vitest-test'() { trace.push({ phase: 'failed-task-getter', kind: 'read' }); throw exact; }, object: 'not-copied' } };
 caught('failed-task-read', failedFirst, aliasB); call('failed-task-stays', aliasB, 'partial');
 const filtered = { __flags: { object: 'filtered-out', 'vitest-test': taskFlagB, message: 'filtered message' } };
 caught('filtered-base-values', filtered, aliasB, false); call('filtered-object-stays', aliasB, 'partial');
 const payload = { __flags: { object: 17, tag: 'payload' } }, destination = {};
 caught('ordinary-payload', payload, destination); trace.push({ phase: 'payload-result', flags: destination.__flags });
});
afterAll(() => { caught('hook-transfer', aliasA, aliasB); call('afterAll-raw-B', aliasB, 'A'); call('afterAll-public-B', publicB, 'A'); console.log('DECLARATION_FN:' + JSON.stringify({ kind: 'transfer-effects', trace, countA: localA.getState().assertionCalls, countB: localB.getState().assertionCalls, stateA: taskA.result?.state ?? null, stateB: taskB.result?.state ?? null })); });
