Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS
JavaScript ai-agentsdashboarddeveloper-toolsdigital-twinquantified-selfsecond-brainself-hostedtailscale
import { describe, expect, it } from 'vitest';
import {
asFableLoomRenderPreferences,
asFableLoomRenderSettings,
buildEpisodeProductionPlan,
computeTopologicalNodeOrder,
inspectEpisodeProductionOrder,
verifyExactInputProvenance,
} from './fableLoomProduction.js';
describe('fableLoomProduction', () => {
const sampleEpisode = {
id: 'ep-1',
startNodeId: 'node-1',
nodes: [
{
id: 'node-1',
title: 'Opening Scene',
prose: 'Opening scene prose.',
imagePrompt: 'A wide vista at sunset.',
videoPrompt: 'Camera slowly pans left.',
transitions: [
{ id: 'tr-1', targetNodeId: 'node-2', intent: 'Go north' },
{ id: 'tr-2', targetNodeId: 'node-3', intent: 'Go south' },
],
},
{
id: 'node-2',
title: 'North Forest',
prose: 'Dark misty woods.',
imagePrompt: 'Misty forest path.',
videoPrompt: 'Tracking shot through trees.',
transitions: [
{ id: 'tr-3', targetNodeId: 'node-4', intent: 'Enter cave' },
],
},
{
id: 'node-3',
title: 'South Bridge',
prose: 'Old stone bridge over river.',
imagePrompt: 'Ancient stone bridge.',
videoPrompt: 'Aerial shot over water.',
transitions: [
{ id: 'tr-4', targetNodeId: 'node-4', intent: 'Cross into cave' },
],
},
{
id: 'node-4',
title: 'Convergence Cave',
prose: 'Deep subterranean cavern.',
imagePrompt: 'Crystal cave interior.',
videoPrompt: 'Dolly forward into cavern.',
isEnding: true,
transitions: [],
},
{
id: 'node-unreachable',
title: 'Floating Island',
prose: 'An unreachable island in the clouds.',
transitions: [],
},
],
};
it('defaults every loom to an explicit 16:9 landscape render format', () => {
expect(asFableLoomRenderSettings()).toEqual({
formatId: 'landscape-16-9',
aspectRatio: '16:9',
width: 1024,
height: 576,
});
expect(asFableLoomRenderSettings({ formatId: 'portrait-9-16' })).toMatchObject({
aspectRatio: '9:16', width: 576, height: 1024,
});
expect(asFableLoomRenderSettings({ formatId: 'unknown' })).toMatchObject({
aspectRatio: '16:9', width: 1024, height: 576,
});
});
it('normalizes persisted image and video rendering preferences', () => {
expect(asFableLoomRenderPreferences({
imageMode: 'local',
imageModel: ' image-model ',
videoMode: 'grok',
videoModel: 'stale-local-model',
effort: 'high',
})).toEqual({
imageMode: 'local',
imageModel: 'image-model',
videoMode: 'grok',
videoModel: null,
effort: 'high',
});
});
it('computes topological node ordering and detects convergence', () => {
const topo = computeTopologicalNodeOrder(sampleEpisode);
expect(topo.orderedNodes.map((n) => n.id)).toEqual(['node-1', 'node-2', 'node-3', 'node-4']);
expect(topo.depthById.get('node-1')).toBe(0);
expect(topo.depthById.get('node-2')).toBe(1);
expect(topo.depthById.get('node-3')).toBe(1);
expect(topo.depthById.get('node-4')).toBe(2);
expect(topo.convergenceNodeIds.has('node-4')).toBe(true);
expect(topo.unreachableNodeIds.has('node-unreachable')).toBe(true);
});
it('requires prior episodes to have reachable storyboard images before production', () => {
const firstEpisode = {
id: 'ep-1', number: 1, startNodeId: 'first-node', nodes: [
{ id: 'first-node', title: 'First image', image: 'first.png', isEnding: true, transitions: [] },
],
};
const secondEpisode = {
id: 'ep-2', number: 2, startNodeId: 'second-node', nodes: [
{ id: 'second-node', title: 'Second image', transitions: [] },
],
};
const loom = { episodes: [firstEpisode, secondEpisode] };
expect(inspectEpisodeProductionOrder(loom, firstEpisode)).toMatchObject({
ready: true, previousEpisodeCount: 0,
});
expect(inspectEpisodeProductionOrder(loom, secondEpisode)).toMatchObject({
ready: true, previousEpisodeCount: 1,
});
firstEpisode.nodes[0].image = '';
const blocked = inspectEpisodeProductionOrder(loom, secondEpisode);
expect(blocked.ready).toBe(false);
expect(blocked.reason).toContain('Episode 1');
expect(blocked.missingScenes).toEqual([
expect.objectContaining({ episodeId: 'ep-1', nodeId: 'first-node' }),
]);
});
it('builds comprehensive episode production plan with assets and dependencies', () => {
const plan = buildEpisodeProductionPlan({
episode: sampleEpisode,
loom: { id: 'loom-1' },
mode: 'current_canon',
});
expect(plan.mode).toBe('current_canon');
expect(plan.totalNodes).toBe(5);
expect(plan.reachableNodeCount).toBe(4);
expect(plan.unreachableNodeCount).toBe(1);
expect(plan.assetsByType.image).toBe(4);
expect(plan.assetsByType.video).toBeGreaterThanOrEqual(4);
// Node-1 (opening) should have no image dependencies
const node1Image = plan.plannedAssets.find((a) => a.id === 'asset-node-1-still');
expect(node1Image.dependencies).toEqual([]);
// Node-2 (child of node-1) should depend on node-1 still
const node2Image = plan.plannedAssets.find((a) => a.id === 'asset-node-2-still');
expect(node2Image.dependencies).toEqual(['asset-node-1-still']);
// Video should depend on own still
const node1Video = plan.plannedAssets.find((a) => a.id === 'asset-node-1-video-entry');
expect(node1Video.dependencies).toEqual(['asset-node-1-still']);
// Convergence note for node-4
expect(plan.convergenceIssues.length).toBe(1);
expect(plan.convergenceIssues[0].nodeId).toBe('node-4');
expect(plan.convergenceIssues[0].selectedPredecessorId).toBeNull();
expect(plan.plannedAssets.find((a) => a.id === 'asset-node-4-still').temporalSourceNodeId).toBeNull();
const stillStage = plan.executionStages.find((stage) => stage.assetIds.includes('asset-node-1-still'));
const videoStage = plan.executionStages.find((stage) => stage.assetIds.includes('asset-node-1-video-entry'));
expect(videoStage.stageIndex).toBeGreaterThan(stillStage.stageIndex);
});
describe('media asset status policy', () => {
const NO_APPROVAL = 'Locked canon video requires an author-approved storyboard image.';
const NO_VIDEO_PROMPT = 'Scene has neither videoPrompt nor prose for video.';
const NO_EXIT_PROMPT = 'Transition has no description or scene video prompt.';
const protagonistReason = 'Canonical protagonist "char-x" is not present in the linked Universe.';
// One scene with a still, an entry clip, a hold loop and a transition exit.
const sceneEpisode = ({ node = {}, assets = {}, transition = {} } = {}) => ({
id: 'ep-status',
startNodeId: 'scene',
nodes: [
{
id: 'scene',
title: 'Scene',
imagePrompt: 'A still.',
videoPrompt: 'A clip.',
image: 'still.png',
playbackAssets: {
entryVideoHistoryId: 'entry-1',
holdLoopVideoHistoryIds: ['hold-1'],
exitByTransition: { 'tr-exit': 'exit-1' },
...assets,
},
transitions: [{ id: 'tr-exit', targetNodeId: 'end', description: 'Leave.', ...transition }],
...node,
},
{ id: 'end', title: 'End', prose: 'The end.', isEnding: true, transitions: [] },
],
});
const noExisting = {
entryVideoHistoryId: null, holdLoopVideoHistoryIds: [], exitByTransition: {},
};
const plan = (episode, options = {}) => buildEpisodeProductionPlan({
loom: { id: 'loom-1' }, mode: 'current_canon', episode, ...options,
});
const sceneStatuses = (result) => Object.fromEntries(result.plannedAssets
.filter((asset) => asset.nodeId === 'scene')
.map((asset) => [asset.role, [asset.status, asset.readiness.ready, asset.readiness.reasons]]));
it('reuses every existing asset in current canon and counts them as already rendered', () => {
const result = plan(sceneEpisode());
expect(sceneStatuses(result)).toEqual({
image: ['already_rendered', true, []],
entry: ['already_rendered', true, []],
hold: ['already_rendered', true, []],
exit: ['already_rendered', true, []],
});
expect(result.plannedAssets.filter((asset) => asset.status === 'already_rendered')).toHaveLength(4);
expect(result.isFullyReady).toBe(true);
});
it('regenerates existing assets in exact_inputs mode instead of reusing them', () => {
const result = plan(sceneEpisode(), { mode: 'exact_inputs' });
expect(sceneStatuses(result)).toEqual({
image: ['ready', true, []],
entry: ['ready', true, []],
hold: ['ready', true, []],
exit: ['ready', true, []],
});
expect(result.plannedAssets.some((asset) => asset.status === 'already_rendered')).toBe(false);
});
it('keeps an existing still, entry and hold reusable without prompts but not an exit', () => {
const result = plan(sceneEpisode({
node: { imagePrompt: '', videoPrompt: '' },
transition: { description: '' },
}));
expect(sceneStatuses(result)).toEqual({
image: ['already_rendered', false, ['Scene has neither imagePrompt nor prose.']],
entry: ['already_rendered', false, [NO_VIDEO_PROMPT]],
hold: ['already_rendered', false, [NO_VIDEO_PROMPT]],
exit: ['blocked', false, [NO_EXIT_PROMPT]],
});
});
it('blocks every existing asset on a blocker common to the scene', () => {
const result = plan(sceneEpisode(), {
loom: { id: 'loom-1', protagonistCharacterId: 'char-x' },
universe: { id: 'universe-1', characters: [] },
});
expect(sceneStatuses(result)).toEqual({
image: ['blocked', false, [protagonistReason]],
entry: ['blocked', false, [protagonistReason]],
hold: ['blocked', false, [protagonistReason]],
exit: ['blocked', false, [protagonistReason]],
});
});
it('reports an unsafe hold loop once while preserving live voice blocking', () => {
const interactionNode = {
interactionWindow: { enabled: true, protagonistCharacterId: 'char-1' },
};
const options = {
loom: { id: 'loom-1', protagonistCharacterId: 'char-1' },
universe: { id: 'universe-1', characters: [{ id: 'char-1', voiceId: 'voice-1' }] },
};
const unsafe = plan(sceneEpisode({
node: interactionNode,
assets: {
audioOccupancy: {
'hold-1': {
durationMs: 5000,
characterDialogue: [{ startMs: 0, endMs: 2000, characterId: 'char-1' }],
},
},
},
}), options);
const unsafeAssets = unsafe.plannedAssets.filter((asset) => asset.nodeId === 'scene');
const warning = 'Hold loop "hold-1" is not safe for live voice.';
for (const asset of unsafeAssets) {
expect(asset.readiness.reasons.filter((reason) => reason === warning)).toHaveLength(1);
expect(asset.status).toBe('blocked');
}
expect(unsafeAssets.find((asset) => asset.type === 'video_hold').existingAssetId).toBe('hold-1');
const safe = plan(sceneEpisode({
node: interactionNode,
assets: {
audioOccupancy: {
'hold-1': { durationMs: 5000, music: [{ startMs: 0, endMs: 5000 }] },
},
},
}), options);
const safeAssets = safe.plannedAssets.filter((asset) => asset.nodeId === 'scene');
expect(safeAssets.find((asset) => asset.type === 'video_hold')).toMatchObject({
status: 'already_rendered',
readiness: { ready: true, reasons: [] },
});
expect(safeAssets.some((asset) => asset.readiness.reasons.includes(warning))).toBe(false);
});
it('requires an approved storyboard for new locked-canon video but not for existing clips', () => {
const universe = { id: 'universe-1', characters: [] };
const lockedNode = { visualCanon: { mode: 'locked' } };
const unapproved = plan(sceneEpisode({ node: { ...lockedNode, image: null }, assets: noExisting }), { universe });
expect(sceneStatuses(unapproved)).toEqual({
image: ['ready', true, []],
entry: ['blocked', false, [NO_APPROVAL]],
hold: ['blocked', false, [NO_APPROVAL]],
exit: ['blocked', false, [NO_APPROVAL]],
});
const approved = plan(sceneEpisode({
node: { visualCanon: { mode: 'locked', storyboardImageApproved: true }, image: null },
assets: noExisting,
}), { universe });
expect(Object.values(sceneStatuses(approved)).map(([status]) => status)).toEqual(['ready', 'ready', 'ready', 'ready']);
const existing = plan(sceneEpisode({ node: lockedNode }), { universe });
expect(Object.values(sceneStatuses(existing)).map(([status]) => status))
.toEqual(['already_rendered', 'already_rendered', 'already_rendered', 'already_rendered']);
});
});
it('blocks production when the canonical protagonist cannot resolve in the linked Universe', () => {
const plan = buildEpisodeProductionPlan({
episode: sampleEpisode,
loom: { id: 'loom-1', protagonistCharacterId: 'char-elena' },
universe: { id: 'universe-1', characters: [] },
});
expect(plan.isFullyReady).toBe(false);
expect(plan.plannedAssets
.filter((asset) => asset.status === 'blocked')
.some((asset) => asset.readiness.reasons.some((reason) => /canonical protagonist/i.test(reason))))
.toBe(true);
});
it('requires the interactive route before an approved studio voice satisfies live casting', () => {
const episode = { ...sampleEpisode, nodes: [{ ...sampleEpisode.nodes[0], transitions: [],
interactionWindow: { enabled: true, protagonistCharacterId: 'char-1' } }] };
const profile = { id: 'voice-1', binding: { universeId: 'u1', characterId: 'char-1' },
approval: { status: 'approved' }, routes: { studio: { enabled: true }, interactive: { enabled: false } } };
const options = { episode, universe: { id: 'u1', characters: [{ id: 'char-1', name: 'Example' }] },
loom: { id: 'loom-1', protagonistCharacterId: 'char-1' }, localVoiceProfiles: [profile] };
const reasons = () => buildEpisodeProductionPlan(options).plannedAssets.find(asset => asset.type === 'dialogue').readiness.reasons;
expect(reasons().some(reason => /no approved voice binding/i.test(reason))).toBe(true);
profile.routes.interactive.enabled = true;
expect(reasons().some(reason => /no approved voice binding/i.test(reason))).toBe(false);
});
it('reports each missing protagonist and voice-binding blocker once on the dialogue asset', () => {
const episode = { ...sampleEpisode, nodes: [{ ...sampleEpisode.nodes[0], transitions: [],
interactionWindow: { enabled: true, protagonistCharacterId: 'char-1' } }] };
const plan = buildEpisodeProductionPlan({ episode, universe: { id: 'u1', characters: [] },
loom: { id: 'loom-1' }, localVoiceProfiles: [] });
const reasons = plan.plannedAssets.find(asset => asset.type === 'dialogue').readiness.reasons;
expect(reasons.filter(reason => /not present in the linked Universe/i.test(reason))).toHaveLength(1);
expect(reasons.filter(reason => /no approved voice binding/i.test(reason))).toHaveLength(1);
expect(reasons.some(reason => /not found in Universe|No approved voice binding for/.test(reason))).toBe(false);
expect(new Set(reasons).size).toBe(reasons.length);
});
it('refuses exact-input planning when a node has no recorded provenance', () => {
const plan = buildEpisodeProductionPlan({
episode: sampleEpisode,
mode: 'exact_inputs',
});
expect(plan.isFullyReady).toBe(false);
expect(plan.exactInputIssues.length).toBe(4);
expect(plan.exactInputIssues[0].errors[0]).toContain('No recorded provenance');
});
it('verifies exact input provenance matching without silent substitution', () => {
const validProvenance = {
version: 1,
characters: [
{
characterId: 'char-1',
lora: { filename: 'char-1-flux.safetensors', sha256: 'abc123sha' },
voice: {
profileId: 'vp-1', profileVersion: 2, engine: 'kokoro', modelRevision: 'rev-1',
},
},
],
};
const universe = { characters: [{ id: 'char-1', name: 'Hero' }] };
const localVoiceProfiles = [{ id: 'vp-1', version: 2, engine: 'kokoro', modelRevision: 'rev-1' }];
const localLoras = [{ filename: 'char-1-flux.safetensors', sha256: 'abc123sha' }];
const result = verifyExactInputProvenance(validProvenance, {
universe,
localVoiceProfiles,
localLoras,
});
expect(result.valid).toBe(true);
expect(result.errors).toHaveLength(0);
// Mismatched LoRA hash
const mismatchedLora = verifyExactInputProvenance(validProvenance, {
universe,
localVoiceProfiles,
localLoras: [{ filename: 'char-1-flux.safetensors', sha256: 'different-hash' }],
});
expect(mismatchedLora.valid).toBe(false);
expect(mismatchedLora.errors[0]).toContain('checksum mismatch');
// Mismatched Voice Profile version
const mismatchedVoice = verifyExactInputProvenance(validProvenance, {
universe,
localVoiceProfiles: [{ id: 'vp-1', version: 3, engine: 'kokoro', modelRevision: 'rev-1' }],
localLoras,
});
expect(mismatchedVoice.valid).toBe(false);
expect(mismatchedVoice.errors[0]).toContain('version mismatch');
const missingModelRevision = verifyExactInputProvenance(validProvenance, {
universe,
localVoiceProfiles: [{ id: 'vp-1', version: 2, engine: 'kokoro' }],
localLoras,
});
expect(missingModelRevision.valid).toBe(false);
expect(missingModelRevision.errors.some((error) => error.includes('model revision mismatch'))).toBe(true);
});
it('reports checksum defects consistently for both recorded file envelopes', () => {
const envelopes = [
{
label: 'adapter',
provenance: (file) => ({
version: 1,
compilerVersion: 'visual-v1',
status: 'locked',
capability: { kind: 'image', backend: 'cloud', modelId: 'model-v1' },
bindings: {}, assets: [], adapters: [file], omitted: [], warnings: [],
}),
},
{
label: 'LoRA',
provenance: (file) => ({ version: 1, characters: [{ characterId: 'char-1', lora: file }] }),
},
];
const defectCases = [
{ recorded: { filename: 'adapter.safetensors' }, installed: [], message: 'has no checksum to verify exact inputs' },
{ recorded: { filename: 'adapter.safetensors', sha256: 'expected' }, installed: [], message: 'is not installed locally' },
{ recorded: { filename: 'adapter.safetensors', sha256: 'expected' }, installed: [{ filename: 'adapter.safetensors' }], message: 'has no checksum to verify exact inputs' },
{ recorded: { filename: 'adapter.safetensors', sha256: 'expected' }, installed: [{ filename: 'adapter.safetensors', sha256: 'found' }], message: 'checksum mismatch (expected expected, found found)' },
];
for (const envelope of envelopes) {
for (const defect of defectCases) {
const result = verifyExactInputProvenance(envelope.provenance(defect.recorded), {
localLoras: defect.installed,
});
expect(result.errors.some((error) => error.includes(defect.message)),
`${envelope.label}: ${defect.message}`).toBe(true);
}
}
});
it('refuses exact visual reproduction when local inputs are empty, missing, or revised', () => {
const visualProvenance = {
version: 1,
compilerVersion: 'visual-v1',
status: 'locked',
universeId: 'univ-1',
capability: {
kind: 'image',
backend: 'local',
modelId: 'image-model',
modelRevision: 'revision-1',
},
bindings: { inferred: false, characterAppearances: [], objectIds: [] },
assets: [{ role: 'environment', required: true, filename: 'environment.png' }],
adapters: [],
omitted: [],
warnings: [],
render: {
parameters: {
width: 1024,
height: 576,
aspectRatio: '16:9',
steps: 28,
guidance: 3.5,
quantize: '8',
seed: 42,
},
},
};
const baseOptions = {
universe: { id: 'univ-1', characters: [], places: [], objects: [] },
availableImageModels: [{ id: 'image-model', revision: 'revision-1' }],
resolveAsset: () => '/safe/environment.png',
};
expect(verifyExactInputProvenance(visualProvenance, baseOptions).valid).toBe(true);
const missingRenderTuple = structuredClone(visualProvenance);
delete missingRenderTuple.render.parameters.seed;
expect(verifyExactInputProvenance(missingRenderTuple, baseOptions).errors)
.toContain('Recorded image render parameter "seed" is missing or invalid.');
expect(verifyExactInputProvenance(visualProvenance, {
...baseOptions,
availableImageModels: [],
}).errors).toContain('Recorded image model "image-model" is not available locally.');
expect(verifyExactInputProvenance(visualProvenance, {
...baseOptions,
availableImageModels: [{ id: 'image-model', revision: 'revision-2' }],
}).errors.some((error) => error.includes('revision mismatch'))).toBe(true);
const unpinned = structuredClone(visualProvenance);
delete unpinned.capability.modelRevision;
expect(verifyExactInputProvenance(unpinned, baseOptions).errors.some((error) => error.includes('immutable model revision'))).toBe(true);
expect(verifyExactInputProvenance(visualProvenance, {
...baseOptions,
resolveAsset: () => null,
}).errors).toContain('Recorded visual conditioning asset "environment.png" is unavailable locally.');
});
describe('episode-wide blockers and convergence', () => {
const lockedCanon = (extra = {}) => ({ mode: 'locked', storyboardImageApproved: false, ...extra });
const convergentEpisode = {
id: 'ep-conv',
startNodeId: 'a',
nodes: [
{ id: 'a', title: 'A', prose: 'A.', transitions: [{ id: 't1', targetNodeId: 'b' }, { id: 't2', targetNodeId: 'c' }] },
{ id: 'b', title: 'B', prose: 'B.', transitions: [{ id: 't3', targetNodeId: 'd' }] },
{
id: 'c',
title: 'C',
prose: 'C.',
visualCanon: lockedCanon({ continuitySourceNodeId: 'a-not-a-predecessor' }),
transitions: [{ id: 't4', targetNodeId: 'd' }],
},
{ id: 'd', title: 'D', prose: 'D.', isEnding: true, visualCanon: lockedCanon(), transitions: [] },
],
};
it('repeats the canonical protagonist blocker identically on every reachable node, ahead of per-node blockers', () => {
const plan = buildEpisodeProductionPlan({
episode: convergentEpisode,
loom: { id: 'loom-1', protagonistCharacterId: 'char-hero', protagonistWardrobeId: 'wardrobe-x' },
universe: { id: 'u-1', characters: [{ id: 'char-hero', wardrobes: [{ id: 'wardrobe-y' }] }], places: [], objects: [] },
});
const wardrobe = 'Canonical wardrobe \"wardrobe-x\" is not present on protagonist \"char-hero\".';
const stills = plan.plannedAssets.filter((asset) => asset.type === 'image');
expect(stills.map((asset) => asset.nodeId)).toEqual(['a', 'b', 'c', 'd']);
for (const still of stills) expect(still.readiness.reasons).toContain(wardrobe);
expect(stills.find((asset) => asset.nodeId === 'c').readiness.reasons).toEqual([
wardrobe,
'Locked visual canon names a predecessor that does not lead into this scene.',
]);
expect(stills.find((asset) => asset.nodeId === 'd').readiness.reasons).toEqual([
wardrobe,
'Locked convergent scene needs an explicit temporal continuity source.',
]);
expect(stills.find((asset) => asset.nodeId === 'a').readiness.reasons).toEqual([wardrobe]);
});
it('reports missing protagonists and an unavailable Universe on every node', () => {
const missing = buildEpisodeProductionPlan({
episode: convergentEpisode,
loom: { id: 'loom-1', protagonistCharacterId: 'char-hero' },
universe: { id: 'u-1', characters: [] },
});
const noUniverse = buildEpisodeProductionPlan({
episode: convergentEpisode,
loom: { id: 'loom-1', protagonistCharacterId: 'char-hero' },
});
const reasonsFor = (plan, nodeId) => plan.plannedAssets.find((asset) => asset.id === `asset-${nodeId}-still`).readiness.reasons;
expect(reasonsFor(missing, 'a')).toEqual(['Canonical protagonist \"char-hero\" is not present in the linked Universe.']);
expect(reasonsFor(missing, 'b')).toEqual(reasonsFor(missing, 'a'));
expect(reasonsFor(noUniverse, 'd')).toEqual([
'Locked visual canon cannot be resolved because its Universe is unavailable.',
'The canonical protagonist cannot be resolved because the linked Universe is unavailable.',
'Locked convergent scene needs an explicit temporal continuity source.',
]);
});
it('records convergence issues without inheritance for invalid explicit and missing sources', () => {
const plan = buildEpisodeProductionPlan({ episode: convergentEpisode });
expect(plan.convergenceIssues).toEqual([
{
nodeId: 'c',
nodeTitle: 'C',
predecessorCount: 1,
selectedPredecessorId: null,
policy: 'no-inheritance',
reason: 'invalid-explicit-source',
remediation: 'Set visualCanon.continuitySourceNodeId to an incoming predecessor of this scene.',
},
{
nodeId: 'd',
nodeTitle: 'D',
predecessorCount: 2,
selectedPredecessorId: null,
policy: 'no-inheritance',
remediation: 'Set visualCanon.continuitySourceNodeId on this scene to explicitly select temporal continuity source.',
},
]);
const stills = Object.fromEntries(plan.plannedAssets.filter((asset) => asset.type === 'image').map((asset) => [asset.nodeId, asset]));
expect(stills.b.temporalSourceNodeId).toBe('a');
expect(stills.c.temporalSourceNodeId).toBeNull();
expect(stills.d.temporalSourceNodeId).toBeNull();
});
it('requires an approved storyboard for each locked video role unless that asset already exists', () => {
const message = 'Locked canon video requires an author-approved storyboard image.';
const episode = {
id: 'ep-roles',
startNodeId: 'n',
nodes: [
{ id: 'n', prose: 'N.', visualCanon: lockedCanon(), transitions: [{ id: 't1', targetNodeId: 'm' }, { id: 't2', targetNodeId: 'm' }] },
{ id: 'm', prose: 'M.', isEnding: true, transitions: [] },
],
};
const withVideos = structuredClone(episode);
withVideos.nodes[0].videoHistoryId = 'entry-1';
withVideos.nodes[0].playbackAssets = { holdLoopVideoHistoryIds: ['hold-1'], exitByTransition: { t1: 'exit-1' } };
const reasons = (plan, type) => plan.plannedAssets.filter((asset) => asset.nodeId === 'n' && asset.type === type).map((asset) => asset.readiness.reasons);
const universe = { id: 'u-1', characters: [], places: [], objects: [] };
const bare = buildEpisodeProductionPlan({ episode, universe });
expect(reasons(bare, 'video_entry')).toEqual([[message]]);
expect(reasons(bare, 'video_hold')).toEqual([[message]]);
expect(reasons(bare, 'video_exit')).toEqual([[message], [message]]);
const existing = buildEpisodeProductionPlan({ episode: withVideos, universe });
expect(reasons(existing, 'video_entry')).toEqual([[]]);
expect(reasons(existing, 'video_hold')).toEqual([[]]);
expect(reasons(existing, 'video_exit')).toEqual([[], [message]]);
withVideos.nodes[0].visualCanon.storyboardImageApproved = true;
expect(reasons(buildEpisodeProductionPlan({ episode: withVideos, universe }), 'video_exit')).toEqual([[], []]);
});
it('deduplicates identical exact-input manifests across a node and its per-asset conditioning', () => {
const manifest = { assetId: 'asset-n-still', version: 1, status: 'locked' };
const episode = {
id: 'ep-dedupe',
startNodeId: 'n',
nodes: [{
id: 'n',
prose: 'N.',
isEnding: true,
visualConditioning: manifest,
playbackAssets: { visualConditioningByAsset: { one: { ...manifest }, two: { assetId: 'asset-n-video', version: 1 } } },
transitions: [],
}],
};
const plan = buildEpisodeProductionPlan({ episode, mode: 'exact_inputs' });
expect(plan.exactInputIssues.map((issue) => issue.nodeId)).toEqual(['n', 'n']);
expect(plan.isFullyReady).toBe(false);
});
});
it('reports each stale visual binding reference once in recorded provenance', () => {
const manifest = {
version: 1,
compilerVersion: '1',
status: 'locked',
universeId: 'u-1',
capability: { backend: 'cloud', modelId: 'm', kind: 'image' },
bindings: {
characterAppearances: [
{ characterId: 'ghost' },
{ characterId: 'hero', wardrobeId: 'cloak' },
{ characterId: 'hero', wardrobeId: 'gone' },
],
placeId: 'nowhere',
objectIds: ['lamp', 'missing-object'],
},
assets: [],
adapters: [],
omitted: [],
warnings: [],
render: { kind: 'image', backend: 'cloud', parameters: {} },
};
const universe = {
id: 'u-1',
characters: [{ id: 'hero', wardrobes: [{ id: 'cloak' }] }],
places: [{ id: 'home' }],
objects: [{ id: 'lamp' }],
};
const errors = verifyExactInputProvenance(manifest, { universe }).errors
.filter((error) => error.includes('recorded visual bindings'));
expect(errors).toEqual([
'Character \"ghost\" in recorded visual bindings no longer exists in Universe.',
'Wardrobe \"gone\" in recorded visual bindings is not present on character \"hero\".',
'Place \"nowhere\" in recorded visual bindings no longer exists in Universe.',
'Object \"missing-object\" in recorded visual bindings no longer exists in Universe.',
]);
const noBindings = { ...manifest, bindings: null };
expect(verifyExactInputProvenance(noBindings, { universe }).errors)
.toContain('Recorded visual conditioning has no scene bindings.');
});
});