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
afterEach(() => { vi.useRealTimers(); });
const socketHandlers = vi.hoisted(() => new Map());
vi.mock('../services/socket', () => ({ default: {
on: (event, fn) => { if (!socketHandlers.has(event)) socketHandlers.set(event, new Set()); socketHandlers.get(event).add(fn); },
off: (event, fn) => socketHandlers.get(event)?.delete(fn),
} }));
const emitModel = async (event, payload) => act(async () => {
for (const fn of socketHandlers.get(event) || []) fn(payload);
});
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import { useEffect, useRef } from 'react';
import { act, render, screen, fireEvent, waitFor, within } from '@testing-library/react';
import { MemoryRouter, Routes, Route, useNavigate } from 'react-router';
import Media3DDetail from './Media3DDetail';
const getImageTo3dModel = vi.fn();
const generateImageTo3dModel = vi.fn();
const deleteImageTo3dModel = vi.fn();
vi.mock('../services/api', () => ({
getImageTo3dModel: (...a) => getImageTo3dModel(...a),
generateImageTo3dModel: (...a) => generateImageTo3dModel(...a),
deleteImageTo3dModel: (...a) => deleteImageTo3dModel(...a),
imageTo3dAssetUrl: (id) => `/api/image-to-3d/models/${id}/asset`,
imageTo3dFullMeshUrl: (id) => `/api/image-to-3d/models/${id}/full-mesh`,
imageTo3dUsdzUrl: (id) => `/api/image-to-3d/models/${id}/usdz`,
}));
// GlbViewer wraps a WebGL canvas jsdom can't render — stub to a marker echoing
// src. It also hands the loaded three.js graph up via `onSceneLoaded`, so the
// stub fires that with a marker: the AR export button is disabled until it
// arrives, and dropping that prop is an invisible regression otherwise.
vi.mock('../components/media/GlbViewer', () => ({
default: ({ src, forceOpaque, onSceneLoaded }) => {
useEffect(() => { onSceneLoaded?.({ marker: 'loaded-scene' }); }, [onSceneLoaded]);
return <div data-testid="glb-viewer" data-force-opaque={String(forceOpaque)}>{src}</div>;
},
}));
// The AR panel owns its own export/upload flow (covered by ArExportPanel.test.jsx);
// stubbing it keeps this suite about the page — but it echoes whether the scene
// reached it, which is the page's half of the contract.
vi.mock('../components/media/ArExportPanel', () => ({
default: ({ scene, onRecordChange }) => {
const initialOnRecordChange = useRef(onRecordChange);
return (
<>
<div data-testid="ar-export-panel" data-has-scene={String(Boolean(scene))} />
<button type="button" onClick={() => initialOnRecordChange.current?.({ id: 'image3d-1', name: 'Stale AR update' })}>
Simulate stale AR update
</button>
</>
);
},
}));
vi.mock('../components/MediaImage', () => ({ default: ({ alt, src }) => <img alt={alt} src={src} /> }));
// The rig panel owns its own readiness fetch + feature gate (covered by
// RigPanel.test.jsx); stubbing it keeps this suite about the page.
vi.mock('../components/media/RigPanel', () => ({ default: () => <div data-testid="rig-panel" /> }));
vi.mock('../components/ui/Toast', () => ({ default: { error: vi.fn(), success: vi.fn() } }));
const record = (over = {}) => ({
id: 'image3d-1',
name: 'Example Beacon',
status: 'ready',
assetPath: '/data/image-to-3d/image3d-1/model.glb',
error: null,
runs: [],
sourceImage: { filename: 'beacon.png', path: '/data/images/beacon.png' },
updatedAt: new Date(0).toISOString(),
...over,
});
function renderAt(id = 'image3d-1') {
return render(
<MemoryRouter initialEntries={[`/3d/${id}`]}>
<Routes>
<Route path="/3d" element={<div>3D index</div>} />
<Route path="/3d/:id" element={<Media3DDetail />} />
</Routes>
</MemoryRouter>,
);
}
function RouteSwitcher() {
const navigate = useNavigate();
return (
<>
<button type="button" onClick={() => navigate('/3d/image3d-2')}>Switch model</button>
<Media3DDetail />
</>
);
}
function renderWithSwitcher(id = 'image3d-1') {
return render(
<MemoryRouter initialEntries={[`/3d/${id}`]}>
<Routes>
<Route path="/3d" element={<div>3D index</div>} />
<Route path="/3d/:id" element={<RouteSwitcher />} />
</Routes>
</MemoryRouter>,
);
}
function deferred() {
let resolve;
let reject;
const promise = new Promise((res, rej) => {
resolve = res;
reject = rej;
});
return { promise, resolve, reject };
}
describe('Media3DDetail', () => {
beforeEach(() => vi.clearAllMocks());
it('renders lifecycle progress and terminal updates without polling, with reconnect and visibility recovery', async () => {
getImageTo3dModel.mockResolvedValue(record({ status: 'generating', runs: [{ percent: 10 }] }));
renderAt();
await screen.findByText('Example Beacon');
vi.useFakeTimers();
await act(async () => { vi.advanceTimersByTime(60_000); });
await emitModel('image-to-3d:changed', { id: 'other' });
expect(getImageTo3dModel).toHaveBeenCalledTimes(1);
getImageTo3dModel.mockResolvedValue(record({ status: 'failed', error: 'Example render failure' }));
await emitModel('image-to-3d:changed', { id: 'image3d-1' });
expect(screen.getByText('Example render failure')).toBeInTheDocument();
await emitModel('connect');
expect(getImageTo3dModel).toHaveBeenCalledTimes(3);
Object.defineProperty(document, 'visibilityState', { configurable: true, value: 'hidden' });
await act(async () => { document.dispatchEvent(new Event('visibilitychange')); });
Object.defineProperty(document, 'visibilityState', { configurable: true, value: 'visible' });
getImageTo3dModel.mockResolvedValue(record());
await act(async () => { document.dispatchEvent(new Event('visibilitychange')); });
expect(screen.getByTestId('glb-viewer')).toBeInTheDocument();
expect(getImageTo3dModel).toHaveBeenCalledTimes(4);
vi.useRealTimers();
});
it('renders the mesh viewer and source image for a ready record', async () => {
getImageTo3dModel.mockResolvedValue(record({ generatedAt: '2026-07-25T12:34:56.000Z' }));
renderAt();
expect(await screen.findByText('Example Beacon')).toBeInTheDocument();
expect(screen.getByTestId('glb-viewer')).toHaveTextContent(
'/data/image-to-3d/image3d-1/model.glb?v=2026-07-25T12%3A34%3A56.000Z',
);
expect(screen.getByTestId('glb-viewer')).toHaveAttribute('data-force-opaque', 'true');
expect(screen.getByAltText('Source image')).toBeInTheDocument();
// The viewer's loaded scene has to reach the AR panel or its export button
// stays permanently disabled — a prop chain no other assertion touches.
// The panel mounts before the scene reaches it, so wait on the ATTRIBUTE:
// findByTestId resolves on the node and leaves the prop still in flight.
await waitFor(() =>
expect(screen.getByTestId('ar-export-panel')).toHaveAttribute('data-has-scene', 'true'),
);
});
it('surfaces the render error for a failed record', async () => {
getImageTo3dModel.mockResolvedValue(record({ status: 'failed', assetPath: null, error: 'Accept the Hugging Face terms first.' }));
renderAt();
expect(await screen.findByText(/Accept the Hugging Face terms first/i)).toBeInTheDocument();
expect(screen.queryByTestId('glb-viewer')).toBeNull();
});
it('shows a not-found fallback for a stale id', async () => {
getImageTo3dModel.mockRejectedValue(Object.assign(new Error('nope'), { status: 404 }));
renderAt('gone');
expect(await screen.findByText(/no longer exists/i)).toBeInTheDocument();
});
it('ignores a slower response from the previous routed model', async () => {
const first = deferred();
const second = deferred();
getImageTo3dModel.mockImplementation((id) => (id === 'image3d-1' ? first.promise : second.promise));
renderWithSwitcher();
await waitFor(() => expect(getImageTo3dModel).toHaveBeenCalledWith('image3d-1', expect.objectContaining({ silent: true })));
fireEvent.click(screen.getByRole('button', { name: /switch model/i }));
await waitFor(() => expect(getImageTo3dModel).toHaveBeenCalledWith('image3d-2', expect.objectContaining({ silent: true })));
second.resolve(record({ id: 'image3d-2', name: 'Second Beacon' }));
expect(await screen.findByText('Second Beacon')).toBeInTheDocument();
first.resolve(record({ id: 'image3d-1', name: 'First Beacon' }));
await waitFor(() => expect(screen.getByText('Second Beacon')).toBeInTheDocument());
expect(screen.queryByText('First Beacon')).toBeNull();
});
it('does not let a previous route 404 the newly selected model', async () => {
const first = deferred();
const second = deferred();
getImageTo3dModel.mockImplementation((id) => (id === 'image3d-1' ? first.promise : second.promise));
renderWithSwitcher();
await waitFor(() => expect(getImageTo3dModel).toHaveBeenCalledWith('image3d-1', expect.objectContaining({ silent: true })));
fireEvent.click(screen.getByRole('button', { name: /switch model/i }));
await waitFor(() => expect(getImageTo3dModel).toHaveBeenCalledWith('image3d-2', expect.objectContaining({ silent: true })));
second.resolve(record({ id: 'image3d-2', name: 'Second Beacon' }));
expect(await screen.findByText('Second Beacon')).toBeInTheDocument();
first.reject(Object.assign(new Error('gone'), { status: 404 }));
await waitFor(() => expect(screen.getByText('Second Beacon')).toBeInTheDocument());
expect(screen.queryByText(/no longer exists/i)).toBeNull();
});
it('ignores async panel updates started for the previous routed model', async () => {
getImageTo3dModel.mockImplementation((id) => Promise.resolve(record({
id,
name: id === 'image3d-1' ? 'First Beacon' : 'Second Beacon',
})));
renderWithSwitcher();
expect(await screen.findByText('First Beacon')).toBeInTheDocument();
fireEvent.click(screen.getByRole('button', { name: /switch model/i }));
expect(await screen.findByText('Second Beacon')).toBeInTheDocument();
fireEvent.click(screen.getByRole('button', { name: /simulate stale ar update/i }));
expect(screen.getByText('Second Beacon')).toBeInTheDocument();
expect(screen.queryByText('Stale AR update')).toBeNull();
});
it('clears and reseeds render options for the active routed model', async () => {
getImageTo3dModel.mockImplementation((id) => Promise.resolve(record({
id,
name: id === 'image3d-1' ? 'First Beacon' : 'Second Beacon',
runs: [{ steps: id === 'image3d-1' ? 48 : 24 }],
})));
renderWithSwitcher();
expect(await screen.findByText('First Beacon')).toBeInTheDocument();
await waitFor(() => expect(screen.getByLabelText(/quality/i)).toHaveValue('48'));
fireEvent.click(screen.getByRole('button', { name: /switch model/i }));
expect(await screen.findByText('Second Beacon')).toBeInTheDocument();
await waitFor(() => expect(screen.getByLabelText(/quality/i)).toHaveValue('24'));
});
it('deletes and navigates back to the index', async () => {
getImageTo3dModel.mockResolvedValue(record());
deleteImageTo3dModel.mockResolvedValue({ ok: true });
renderAt();
fireEvent.click(await screen.findByRole('button', { name: /delete/i }));
// The inline confirm row appears; click its Confirm button.
const confirmRow = await screen.findByText(/Delete "Example Beacon"\?/i);
fireEvent.click(within(confirmRow.parentElement).getByRole('button', { name: /^delete$/i }));
await waitFor(() => expect(deleteImageTo3dModel).toHaveBeenCalledWith('image3d-1', { silent: true }));
expect(await screen.findByText('3D index')).toBeInTheDocument();
});
it('re-render sends the chosen per-run options (blank seed omitted → server rolls fresh)', async () => {
getImageTo3dModel.mockResolvedValue(record());
generateImageTo3dModel.mockResolvedValue(record({ status: 'generating' }));
renderAt();
await screen.findByText('Example Beacon');
// `findByText` resolves on the DOM mutation, not on effects settling, and the
// page seeds its option fields from the record in an effect that has NOT run
// at that point — probed directly: a run carrying `steps: 48` still reads back
// an empty quality field there, which is why the seeding tests below wait for
// the value explicitly. A field changed inside that window is overwritten when
// the seed lands. Sub-paint, so no user can hit it; it is a test-ordering
// hazard only (#7448). A record with no runs seeds to the values the form
// already holds, so there is nothing in the DOM to wait for.
await act(async () => {});
fireEvent.change(screen.getByLabelText(/quality/i), { target: { value: '24' } });
fireEvent.click(screen.getByRole('button', { name: /re-render/i }));
await waitFor(() => expect(generateImageTo3dModel).toHaveBeenCalledWith(
'image3d-1',
// normalMap is sent explicitly rather than omitted. It defaults OFF (the bake
// can lose a render outright), and stating it keeps the body honest about what
// the run asked for even if that default ever moves.
{ steps: 24, keyBackground: false, normalMap: false, subjectScale: 1 },
{ silent: true },
));
});
it('seeds steps/keying from the latest run but leaves the seed blank (stays random)', async () => {
getImageTo3dModel.mockResolvedValue(record({
runs: [{ operationId: 'op-1', status: 'completed', percent: 100, steps: 48, seed: 1234, keyBackground: false }],
}));
generateImageTo3dModel.mockResolvedValue(record({ status: 'generating' }));
renderAt();
await screen.findByText('Example Beacon');
// The seeding effect commits one render after the record lands — wait for it.
await waitFor(() => expect(screen.getByLabelText(/quality/i)).toHaveValue('48'));
// Blank by design — echoing the run's concrete seed back would silently pin
// it, reintroducing the deterministic-re-render trap.
expect(screen.getByLabelText(/seed/i)).toHaveValue(null);
expect(screen.getByLabelText(/key out flat backdrop/i)).not.toBeChecked();
fireEvent.click(screen.getByRole('button', { name: /re-render/i }));
await waitFor(() => expect(generateImageTo3dModel).toHaveBeenCalledWith(
'image3d-1',
{ steps: 48, keyBackground: false, normalMap: false, subjectScale: 1 },
{ silent: true },
));
});
it('carries the detail tier and normal-map choice over from the latest run', async () => {
// Deliberate quality choices, so they inherit like steps does — unlike seed,
// which must stay blank.
getImageTo3dModel.mockResolvedValue(record({
runs: [{
operationId: 'op-1', status: 'completed', percent: 100,
detail: 'fast', alphaMode: 'auto', normalMap: false,
}],
}));
generateImageTo3dModel.mockResolvedValue(record({ status: 'generating' }));
renderAt();
await screen.findByText('Example Beacon');
await waitFor(() => expect(screen.getByLabelText(/detail/i)).toHaveValue('fast'));
expect(screen.getByLabelText(/transparency/i)).toHaveValue('auto');
expect(screen.getByLabelText(/bake normal map/i)).not.toBeChecked();
fireEvent.click(screen.getByRole('button', { name: /re-render/i }));
await waitFor(() => expect(generateImageTo3dModel).toHaveBeenCalledWith(
'image3d-1',
{ keyBackground: false, detail: 'fast', alphaMode: 'auto', normalMap: false, subjectScale: 1 },
{ silent: true },
));
});
it('carries the subject framing over and reports it on the finished run', async () => {
// A framing that produced a good mesh is exactly what a re-render wants to keep;
// and the meta line has to say the render was reframed, or the user cannot tell
// whether the last result came from the source's own framing or this knob.
getImageTo3dModel.mockResolvedValue(record({
runs: [{
operationId: 'op-1', status: 'completed', percent: 100,
subjectScale: 0.65, sourceFramed: true,
}],
}));
generateImageTo3dModel.mockResolvedValue(record({ status: 'generating' }));
renderAt();
await screen.findByText('Example Beacon');
await waitFor(() => expect(screen.getByLabelText(/subject framing — 65%/i)).toHaveValue('0.65'));
expect(screen.getByText(/framed at 65%/i)).toBeInTheDocument();
fireEvent.click(screen.getByRole('button', { name: /re-render/i }));
await waitFor(() => expect(generateImageTo3dModel).toHaveBeenCalledWith(
'image3d-1',
{ keyBackground: false, normalMap: false, subjectScale: 0.65 },
{ silent: true },
));
});
it('offers the full-resolution mesh download, labelled as geometry only', async () => {
// ~1 GB of untextured v/f OBJ. The label has to say so, or someone downloads it
// expecting a textured model.
getImageTo3dModel.mockResolvedValue(record());
renderAt();
await screen.findByText('Example Beacon');
const link = screen.getByRole('link', { name: /full-resolution mesh/i });
expect(link).toHaveAttribute('href', '/api/image-to-3d/models/image3d-1/full-mesh');
expect(link.textContent).toMatch(/geometry only/i);
});
describe('viewer transparency', () => {
// The viewer is the third layer able to flatten alpha, after the exporter's
// alpha_mode and PortOS's GLB rewrite. If it keeps forcing opaque, a mesh
// exported as BLEND still renders solid and reads as a broken exporter.
it('forces opaque when the run asked for no transparency', async () => {
getImageTo3dModel.mockResolvedValue(record({
runs: [{ operationId: 'op-1', status: 'completed', percent: 100 }],
}));
renderAt();
await screen.findByText('Example Beacon');
expect(screen.getByTestId('glb-viewer')).toHaveAttribute('data-force-opaque', 'true');
});
it('stops forcing opaque when the run requested a transparent material', async () => {
getImageTo3dModel.mockResolvedValue(record({
runs: [{ operationId: 'op-1', status: 'completed', percent: 100, alphaMode: 'BLEND' }],
}));
renderAt();
await screen.findByText('Example Beacon');
expect(screen.getByTestId('glb-viewer')).toHaveAttribute('data-force-opaque', 'false');
});
it('still forces opaque when the run explicitly asked for OPAQUE', async () => {
getImageTo3dModel.mockResolvedValue(record({
runs: [{ operationId: 'op-1', status: 'completed', percent: 100, alphaMode: 'OPAQUE' }],
}));
renderAt();
await screen.findByText('Example Beacon');
expect(screen.getByTestId('glb-viewer')).toHaveAttribute('data-force-opaque', 'true');
});
});
it('shows the latest run’s seed, steps, and keyed-background badge in the meta line', async () => {
getImageTo3dModel.mockResolvedValue(record({
runs: [{ operationId: 'op-1', status: 'completed', percent: 100, seed: 777, steps: 24, sourceKeyed: true }],
}));
renderAt();
await screen.findByText('Example Beacon');
// Scope to the meta paragraph — the quality <select> also mentions "24 steps".
const meta = screen.getByText(/seed 777/);
expect(meta.textContent).toContain('24 steps');
expect(meta.textContent).toContain('background keyed');
});
});