'
+ '
';
});
@@ -3595,9 +3832,8 @@ async function _charAutoGenerateConceptArt(rec, provider) {
// scan can silently redirect this onto a different (alias-linked)
// character's record instead of this one, confirmed live as a real bug
// elsewhere this session (a voice update landing on the wrong character).
- await _libSaveCharacterVisual(rec, { concept_art_image: d.image });
- if (form) form.concept_art_image = d.image;
- else rec.sheet = Object.assign({}, rec.sheet || {}, { concept_art_image: d.image });
+ const hasProfile = form ? !!form.image : !!(rec.image || (rec.sheet || {}).image);
+ await _libSaveCharacterVisual(rec, hasProfile ? { concept_art_image: d.image, identity_consistent: false } : { concept_art_image: d.image });
return d.image;
}
@@ -3703,7 +3939,8 @@ window._openConceptArtLightbox = _openConceptArtLightbox;
window.libraryRenderCharacters = libraryRenderCharacters;
Object.assign(root, {
- _libStr, _charAutoGenerateConsistentImages,
+ _libStr, _charAutoGenerateConsistentImages, _libSetSheetPrompt, _libIdentityFingerprint,
+ _libAddForm, _libRenameForm, _libDeleteForm, _libFormPairState, _libSetFormField, _libGenerateFormImages,
});
root.TTVC = root.TTVC || {};
root.TTVC.characterLibrary = root.TTVC.characterLibrary || {};
diff --git a/static/style.css b/static/style.css
index 51c3e04..5f90995 100644
--- a/static/style.css
+++ b/static/style.css
@@ -5141,3 +5141,16 @@ input[list="lang-codes"] {
.mag-review-box.is-advertisement { border-color: var(--red); background: rgba(220,38,38,.08); }
.mag-review-box.is-advertisement .mag-review-box-num { background: var(--red); }
+
+/* Appearance forms: manage / rename / delete / per-form image generation */
+.lcd-forms-manage { margin: 10px 0 14px; padding: 8px 12px; border: 1px solid var(--border); border-radius: var(--radius, 8px); background: var(--surface); }
+.lcd-forms-manage > summary { cursor: pointer; font-weight: 600; }
+.lcd-forms-list { list-style: none; margin: 8px 0; padding: 0; display: grid; gap: 6px; }
+.lcd-forms-list li { display: flex; flex-wrap: wrap; align-items: center; gap: 8px; padding: 6px 8px; border: 1px solid var(--border); border-radius: 6px; }
+.lcd-forms-list li.is-active { border-color: var(--accent); box-shadow: 0 0 0 2px rgba(37,99,235,.14); }
+.lcd-form-name, .lcd-form-new-name { flex: 1 1 180px; min-width: 0; padding: 6px 8px; border: 1px solid var(--border); border-radius: 6px; background: var(--panel); color: var(--text); }
+.lcd-form-flag { font-size: 12px; color: var(--subtext); white-space: nowrap; }
+.lcd-form-flag.is-review { color: var(--warning, #d97706); font-weight: 600; }
+.lcd-form-flag.is-ok { color: var(--green, #16a34a); }
+.lcd-form-add { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; margin-top: 8px; }
+.lcd-forms-manage :focus-visible { outline: 2px solid var(--accent); outline-offset: 2px; }
diff --git a/tests/characters.spec.js b/tests/characters.spec.js
index 843bad3..3df2e30 100644
--- a/tests/characters.spec.js
+++ b/tests/characters.spec.js
@@ -162,3 +162,250 @@ test('profile completeness counter distinguishes empty, partial, and full sheets
expect(counts.partial.filled).toBe(3);
expect(counts.full.filled).toBe(counts.full.total);
});
+
+
+// ── Visual persistence (base appearance and forms) ───────────────────────────
+// A stateful stand-in for /api/characters/ so these tests can assert what was
+// actually written back, not just what the page shows.
+async function mockRecord(page, initial) {
+ const state = { rec: JSON.parse(JSON.stringify(initial)), puts: [] };
+ await page.route(`**/api/characters/${encodeURIComponent(initial.id)}`, route => {
+ if (route.request().method() === 'PUT') {
+ state.rec = route.request().postDataJSON();
+ state.puts.push(state.rec);
+ return route.fulfill({ json: state.rec });
+ }
+ return route.fulfill({ json: state.rec });
+ });
+ await page.route('**/api/characters', route => route.fulfill({ json: { characters: [state.rec] } }));
+ await page.route('**/api/voices*', route => route.fulfill({ json: [] }));
+ await page.route('**/api/settings*', route => route.fulfill({ json: {} }));
+ await page.route('**/api/book-profile*', route => route.fulfill({ json: { profile: {} } }));
+ return state;
+}
+
+async function openLibrary(page) {
+ await page.goto('/', { waitUntil: 'domcontentloaded' });
+ await page.waitForFunction(() => typeof window.navTo === 'function', null, { timeout: 15_000 });
+ await page.evaluate(() => window.navTo('s-library'));
+ await page.waitForFunction(() => typeof window._charAutoGenerateImage === 'function' && typeof window._libSetSheetPrompt === 'function', null, { timeout: 15_000 });
+}
+
+const PNG_A = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=';
+
+test('a matched image pair for the base appearance is fully persisted', async ({ page }) => {
+ const state = await mockRecord(page, { id: 'c-base', book: 'Smoke Book', name: 'Base', tags: '', sheet: { physical: 'tall', image_prompt: 'p', concept_art_prompt: 'r' } });
+ await page.route('**/api/character-generate-consistent-images', route => route.fulfill({ json: { job_id: 'job-ok' } }));
+ await page.route('**/api/character-generate-consistent-images/status/job-ok', route => route.fulfill({ json: {
+ stage: 'done', detail: 'Done', elapsed: 1, stale_seconds: 0, done: true, error: null,
+ result: { profile: PNG_A, reference: PNG_A + 'AA', prompt_version: 'v3', identity_fingerprint: 'abc123', profile_asset_digest: 'pd', reference_asset_digest: 'rd', identity_consistent: true },
+ } }));
+ await openLibrary(page);
+ await page.evaluate(() => window._charAutoGenerateConsistentImages({ id: 'c-base', book: 'Smoke Book', name: 'Base', sheet: { physical: 'tall', image_prompt: 'p', concept_art_prompt: 'r' } }, 'cinematic'));
+ const saved = state.puts[state.puts.length - 1];
+ expect(saved.image).toBe(PNG_A);
+ expect(saved.sheet.concept_art_image).toBe(PNG_A + 'AA');
+ expect(saved.sheet.consistent_identity_fingerprint).toBe('abc123');
+ expect(saved.sheet.consistent_prompt_version).toBe('v3');
+ expect(saved.sheet.profile_asset_digest).toBe('pd');
+ expect(saved.sheet.reference_asset_digest).toBe('rd');
+ expect(saved.sheet.identity_consistent).toBe(true);
+ expect(saved.concept_art_image).toBeUndefined();
+});
+
+test('regenerating only the avatar uses the deterministic prompt and flags an existing pair', async ({ page }) => {
+ const state = await mockRecord(page, { id: 'c-av', book: 'Smoke Book', name: 'Avatar', tags: '', image: PNG_A,
+ sheet: { physical: 'a tall woman with copper hair and green eyes', archetype: 'cartographer', image_prompt: 'LLM-AUTHORED', concept_art_image: PNG_A + 'AA', identity_consistent: true } });
+ let promptSent = '';
+ await page.route('**/api/character-generate-prompts', route => route.fulfill({ json: { image_prompt: 'DETERMINISTIC-PROMPT' } }));
+ await page.route('**/api/character-generate-image', route => { promptSent = route.request().postDataJSON().prompt; return route.fulfill({ json: { image: PNG_A + 'BB' } }); });
+ await openLibrary(page);
+ await page.evaluate(() => window._charAutoGenerateImage(JSON.parse(JSON.stringify({ id: 'c-av', book: 'Smoke Book', name: 'Avatar',
+ sheet: { physical: 'a tall woman with copper hair and green eyes', archetype: 'cartographer', image_prompt: 'LLM-AUTHORED', concept_art_image: 'x' } }))));
+ expect(promptSent).toBe('DETERMINISTIC-PROMPT');
+ const saved = state.puts[state.puts.length - 1];
+ expect(saved.image).toBe(PNG_A + 'BB');
+ expect(saved.sheet.identity_consistent).toBe(false);
+});
+
+test('a hand-edited portrait prompt is still honoured for avatar-only generation', async ({ page }) => {
+ await mockRecord(page, { id: 'c-ed', book: 'Smoke Book', name: 'Edited', tags: '', sheet: { physical: 'a tall woman with copper hair', image_prompt: 'MY-OWN-PROMPT', image_prompt_user_edited: true } });
+ let promptSent = '';
+ let generatedPrompts = 0;
+ await page.route('**/api/character-generate-prompts', route => { generatedPrompts += 1; return route.fulfill({ json: { image_prompt: 'DETERMINISTIC-PROMPT' } }); });
+ await page.route('**/api/character-generate-image', route => { promptSent = route.request().postDataJSON().prompt; return route.fulfill({ json: { image: PNG_A } }); });
+ await openLibrary(page);
+ await page.evaluate(() => window._charAutoGenerateImage({ id: 'c-ed', book: 'Smoke Book', name: 'Edited', sheet: { physical: 'a tall woman with copper hair', image_prompt: 'MY-OWN-PROMPT', image_prompt_user_edited: true } }));
+ expect(promptSent).toBe('MY-OWN-PROMPT');
+ expect(generatedPrompts).toBe(0);
+});
+
+test('appearance prompts are written to the active form, character-wide prompts to the base', async ({ page }) => {
+ await mockRecord(page, { id: 'c-form', book: 'b', name: 'Form', tags: '', sheet: {} });
+ await openLibrary(page);
+ const out = await page.evaluate(() => {
+ const rec = { id: 'c-form', sheet: { image_prompt: 'base-img', voice_design_prompt: 'base-voice', active_form_id: 'wolf',
+ forms: [{ id: 'wolf', name: 'Wolf', image_prompt: 'old-wolf' }, { id: 'bat', name: 'Bat', image_prompt: 'bat-img' }] } };
+ window._libSetSheetPrompt(rec, 'image_prompt', 'new-wolf', false);
+ window._libSetSheetPrompt(rec, 'voice_design_prompt', 'new-voice', true);
+ return rec.sheet;
+ });
+ expect(out.image_prompt).toBe('base-img');
+ expect(out.forms.find(f => f.id === 'wolf').image_prompt).toBe('new-wolf');
+ expect(out.forms.find(f => f.id === 'bat').image_prompt).toBe('bat-img');
+ expect(out.voice_design_prompt).toBe('new-voice');
+ expect(out.voice_design_prompt_user_edited).toBe(true);
+});
+
+// ── Appearance forms: management ─────────────────────────────────────────────
+test('form helpers add, rename, delete and judge image pairs', async ({ page }) => {
+ await mockRecord(page, { id: 'c-h', book: 'b', name: 'H', tags: '', sheet: {} });
+ await openLibrary(page);
+ const r = await page.evaluate(() => {
+ const out = {};
+ const sheet = { physical: 'human', clothing: 'coat', forms: [{ id: 'wolf', name: 'Wolf', physical: 'fur' }] };
+ const added = window._libAddForm(sheet, ' Bat form ');
+ out.added = { name: added.forms[1].name, id: added.forms[1].id, physical: added.forms[1].physical, clothing: added.forms[1].clothing, active: added.active_form_id, base: sheet.forms.length };
+ out.errors = [];
+ for (const bad of ['', ' ', 'wolf', 'x'.repeat(161)]) { try { window._libAddForm(sheet, bad); out.errors.push('no error for ' + JSON.stringify(bad.slice(0, 5))); } catch (e) { out.errors.push(e.message); } }
+ let full = { forms: [] };
+ for (let i = 0; i < 8; i++) full = window._libAddForm(full, 'form ' + i);
+ try { window._libAddForm(full, 'one too many'); out.errors.push('no error at 9'); } catch (e) { out.errors.push(e.message); }
+ out.ids = new Set(full.forms.map(f => f.id)).size;
+ out.renamed = window._libRenameForm(sheet, 'wolf', 'Werewolf').forms[0].name;
+ try { window._libRenameForm(added, 'wolf', 'bat form'); out.errors.push('no error on duplicate rename'); } catch (e) { out.errors.push(e.message); }
+ const deleted = window._libDeleteForm({ ...added, active_form_id: 'wolf' }, 'wolf');
+ out.deleted = { n: deleted.forms.length, active: deleted.active_form_id };
+ const keepActive = window._libDeleteForm(added, 'wolf');
+ out.keepActive = keepActive.active_form_id === added.active_form_id;
+ // pair state
+ const base = { physical: 'human' };
+ const fp = window._libIdentityFingerprint({ ...base, physical: 'fur' });
+ const okForm = { id: 'f', physical: 'fur', image: 'i', concept_art_image: 'c', consistent_prompt_version: 'v3', consistent_identity_fingerprint: fp, identity_consistent: true };
+ out.state = {
+ none: window._libFormPairState(base, { id: 'f', physical: 'fur' }),
+ ok: window._libFormPairState(base, okForm),
+ stale: window._libFormPairState(base, { ...okForm, consistent_identity_fingerprint: 'old' }),
+ broken: window._libFormPairState(base, { ...okForm, identity_consistent: false }),
+ legacy: window._libFormPairState(base, { ...okForm, consistent_prompt_version: 'v2' }),
+ };
+ return out;
+ });
+ expect(r.added).toEqual({ name: 'Bat form', id: 'bat-form', physical: 'human', clothing: 'coat', active: 'bat-form', base: 1 });
+ expect(r.errors).toEqual(['Give the form a name.', 'Give the form a name.', 'Another form already uses that name.', 'The form name is too long (max 160 characters).', 'A character can have at most 8 forms.', 'Another form already uses that name.']);
+ expect(r.ids).toBe(8);
+ expect(r.renamed).toBe('Werewolf');
+ expect(r.deleted).toEqual({ n: 1, active: '' });
+ expect(r.keepActive).toBe(true);
+ expect(r.state).toEqual({ none: 'none', ok: 'ok', stale: 'review', broken: 'review', legacy: 'review' });
+});
+
+test('editing Physical text while a form is active changes only that form', async ({ page }) => {
+ await mockRecord(page, { id: 'c-f', book: 'b', name: 'F', tags: '', sheet: {} });
+ await openLibrary(page);
+ const r = await page.evaluate(() => {
+ const rec = { id: 'c-f', sheet: { physical: 'human', active_form_id: 'wolf', forms: [{ id: 'wolf', name: 'Wolf', physical: 'fur' }, { id: 'bat', name: 'Bat', physical: 'wings' }] } };
+ window._libSetFormField(rec, 'physical', 'grey fur, yellow eyes');
+ const withForm = JSON.parse(JSON.stringify(rec.sheet));
+ const base = { id: 'c-f', sheet: { physical: 'human', forms: [{ id: 'wolf', name: 'Wolf' }] } };
+ window._libSetFormField(base, 'physical', 'tall');
+ return { withForm, base: base.sheet };
+ });
+ expect(r.withForm.physical).toBe('human');
+ expect(r.withForm.forms.find(f => f.id === 'wolf').physical).toBe('grey fur, yellow eyes');
+ expect(r.withForm.forms.find(f => f.id === 'bat').physical).toBe('wings');
+ expect(r.base.physical).toBe('tall');
+});
+
+test('generating images for several forms rebuilds each form\'s prompts, saves each on its own form and restores the active appearance', async ({ page }) => {
+ const state = await mockRecord(page, { id: 'c-g', book: 'Smoke Book', name: 'Gen', tags: '', sheet: {
+ physical: 'human', active_form_id: '', forms: [{ id: 'wolf', name: 'Wolf', physical: 'fur' }, { id: 'bat', name: 'Bat', physical: 'wings', concept_art_prompt: 'HAND-MADE', concept_art_prompt_user_edited: true }] } });
+ const consistentBodies = [];
+ let job = 0;
+ await page.route('**/api/character-generate-prompts', route => {
+ const b = route.request().postDataJSON();
+ return route.fulfill({ json: { image_prompt: 'PORTRAIT[' + b.sheet.active_form_id + ']', concept_art_prompt: 'SHEET[' + b.sheet.active_form_id + ']' } });
+ });
+ await page.route('**/api/character-generate-consistent-images', route => {
+ consistentBodies.push(route.request().postDataJSON());
+ job += 1;
+ return route.fulfill({ json: { job_id: 'job-' + job } });
+ });
+ await page.route('**/api/character-generate-consistent-images/status/*', route => {
+ const id = route.request().url().split('/').pop();
+ return route.fulfill({ json: { stage: 'done', detail: 'Done', elapsed: 1, stale_seconds: 0, done: true, error: null,
+ result: { profile: PNG_A + id, reference: PNG_A + id + 'R', prompt_version: 'v3', identity_fingerprint: 'fp-' + id, profile_asset_digest: 'p', reference_asset_digest: 'r', identity_consistent: true } } });
+ });
+ await openLibrary(page);
+ const progress = [];
+ await page.exposeFunction('__progress', (n, t, name) => progress.push(n + '/' + t + ' ' + name));
+ await page.evaluate(async () => {
+ const rec = await (await fetch('/api/characters/c-g')).json();
+ await window._libGenerateFormImages(rec, ['wolf', 'bat'], 'cinematic', (n, t, name) => window.__progress(n, t, name));
+ });
+ expect(progress).toEqual(['1/2 Wolf', '2/2 Bat']);
+ expect(consistentBodies.map(b => b.profile_prompt)).toEqual(['PORTRAIT[wolf]', 'PORTRAIT[bat]']);
+ // the hand-made reference prompt of the second form is kept, the first is rebuilt
+ expect(consistentBodies.map(b => b.reference_prompt)).toEqual(['SHEET[wolf]', 'HAND-MADE']);
+ const forms = state.rec.sheet.forms;
+ expect(forms.find(f => f.id === 'wolf').image).toBe(PNG_A + 'job-1');
+ expect(forms.find(f => f.id === 'bat').image).toBe(PNG_A + 'job-2');
+ expect(forms.find(f => f.id === 'wolf').consistent_identity_fingerprint).toBe('fp-job-1');
+ expect(state.rec.sheet.active_form_id).toBe('');
+ expect(state.rec.image).toBeFalsy(); // the base look was not touched
+});
+
+test('the forms panel adds, renames and deletes a form and saves each change', async ({ page }) => {
+ const state = await mockRecord(page, { id: 'c-ui', book: 'Smoke Book', name: 'Zerwas', tags: '', voice: 'de_bob', image: '/human.png', sheet: {
+ physical: 'human with dark hair', clothing: 'black coat',
+ forms: [{ id: 'wolf', name: 'Wolf form', physical: 'large black wolf', image: '/wolf.png', concept_art_image: '/wolf-sheet.png' }] } });
+ await page.goto('/', { waitUntil: 'domcontentloaded' });
+ await page.waitForSelector('#lib-chars-list', { state: 'attached', timeout: 15_000 });
+ await page.waitForFunction(() => typeof window.navTo === 'function', null, { timeout: 15_000 });
+ await page.evaluate(() => window.navTo('s-library'));
+ await page.waitForFunction(() => typeof window._charDetailPage === 'function' && typeof window.libraryRenderCharacters === 'function', null, { timeout: 15_000 });
+ await page.waitForSelector('#app-skeleton', { state: 'detached', timeout: 15_000 });
+ await page.locator('.lib-tab[data-library-view="characters"]').evaluate(el => el.click());
+ await page.waitForSelector('.lib-char-card[data-char-id="c-ui"]', { timeout: 15_000 });
+ await page.evaluate(async () => {
+ const rec = await (await fetch('/api/characters/c-ui')).json();
+ window._charDetailPage(rec, [], { container: document.querySelector('#lib-chars-list') });
+ });
+ const panel = page.locator('.lcd-forms-manage');
+ await expect(panel).toContainText('Appearance forms (1)');
+ // A form with images made before fingerprints existed is flagged for review.
+ await expect(panel.locator('li[data-form-id="wolf"] .lcd-form-flag')).toContainText('review');
+
+ // add
+ await panel.locator('.lcd-form-new-name').fill('Bat form');
+ await panel.locator('.lcd-form-add-btn').click();
+ await expect(page.locator('.lcd-forms-manage')).toContainText('Appearance forms (2)');
+ let saved = state.puts[state.puts.length - 1].sheet;
+ expect(saved.forms.map(f => f.name)).toEqual(['Wolf form', 'Bat form']);
+ expect(saved.active_form_id).toBe('bat-form');
+ expect(saved.forms[1].physical).toBe('human with dark hair'); // starts as a copy of the base look
+ expect(saved.physical).toBe('human with dark hair'); // base untouched
+
+ // adding a duplicate name is refused with a message and saves nothing
+ const putsBefore = state.puts.length;
+ await page.locator('.lcd-forms-manage .lcd-form-new-name').fill('wolf FORM');
+ await page.locator('.lcd-forms-manage .lcd-form-add-btn').click();
+ await expect(page.locator('#toast')).toContainText('already uses that name');
+ expect(state.puts.length).toBe(putsBefore);
+
+ // rename
+ const wolfName = page.locator('.lcd-forms-manage li[data-form-id="wolf"] .lcd-form-name');
+ await wolfName.fill('Werewolf');
+ await wolfName.blur();
+ await expect(page.locator('.lcd-forms-manage li[data-form-id="wolf"] .lcd-form-name')).toHaveValue('Werewolf');
+ expect(state.puts[state.puts.length - 1].sheet.forms[0].name).toBe('Werewolf');
+
+ // delete (confirm dialog)
+ await page.locator('.lcd-forms-manage li[data-form-id="bat-form"] .lcd-form-del').click();
+ await page.locator('#cd-ok').click();
+ await expect(page.locator('.lcd-forms-manage')).toContainText('Appearance forms (1)');
+ saved = state.puts[state.puts.length - 1].sheet;
+ expect(saved.forms.map(f => f.id)).toEqual(['wolf']);
+ expect(saved.active_form_id).toBe('');
+ expect(state.rec.voice).toBe('de_bob'); // the character and its voice are untouched
+});
diff --git a/tests/test_character_identity.py b/tests/test_character_identity.py
new file mode 100644
index 0000000..ce20312
--- /dev/null
+++ b/tests/test_character_identity.py
@@ -0,0 +1,166 @@
+"""Character visual identity: fingerprint parity with the browser, and the form-aware pair review."""
+from __future__ import annotations
+
+import base64
+import json
+import os
+import re
+import subprocess
+import tempfile
+import unittest
+from pathlib import Path
+from unittest import mock
+
+os.environ.setdefault("CONFIG_DIR", tempfile.mkdtemp(prefix="ttvc-charid-test-config-"))
+
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+import routes.characters as characters
+from routes.conversation import (
+ _CHARACTER_IDENTITY_FIELDS, _CHARACTER_IDENTITY_OVERRIDE_FIELDS, _CHARACTER_VISUAL_PROMPT_VERSION,
+ _character_identity_fingerprint,
+)
+
+ROOT = Path(__file__).resolve().parent.parent
+JS = (ROOT / "static/js/library-characters.js").read_text(encoding="utf-8")
+
+
+def _js_list(name: str) -> list[str]:
+ m = re.search(rf"const {name} = \[(.*?)\];", JS, re.S)
+ return re.findall(r"'([^']+)'", m.group(1))
+
+
+def _js_fingerprint(sheets: list[dict]) -> list[str]:
+ """Run the browser's own fingerprint code in Node."""
+ def grab(pattern: str) -> str:
+ return re.search(pattern, JS, re.S).group(0)
+ src = "\n".join([
+ grab(r"function _libStr\(v\) \{.*?\n\}"),
+ grab(r"const LIB_IDENTITY_FIELDS = \[.*?\];"),
+ grab(r"const LIB_IDENTITY_OVERRIDE_FIELDS = \[.*?\];"),
+ grab(r"function _libIdentityFingerprint\(sheet\) \{.*?\n\}"),
+ f"console.log(JSON.stringify({json.dumps(sheets)}.map(_libIdentityFingerprint)));",
+ ])
+ out = subprocess.run(["node", "-e", src], capture_output=True, text=True, check=True, timeout=30)
+ return json.loads(out.stdout)
+
+
+def _legacy_fingerprint(sheet: dict) -> str:
+ """The algorithm before override fields existed, for backward-compat checks."""
+ raw = "|".join(f"{k}:{sheet.get(k) if sheet.get(k) is not None else ''}" for k in _CHARACTER_IDENTITY_FIELDS)
+ value = 0
+ for ch in raw:
+ value = ((value << 5) - value + ord(ch)) & 0xFFFFFFFF
+ return format(value, "x")
+
+
+class FingerprintTests(unittest.TestCase):
+ def test_browser_and_server_use_the_same_field_lists(self):
+ self.assertEqual(_js_list("LIB_IDENTITY_FIELDS"), list(_CHARACTER_IDENTITY_FIELDS))
+ self.assertEqual(_js_list("LIB_IDENTITY_OVERRIDE_FIELDS"), list(_CHARACTER_IDENTITY_OVERRIDE_FIELDS))
+
+ def test_browser_and_server_compute_identical_fingerprints(self):
+ sheets = [
+ {},
+ {"physical": "tall, white hair", "clothing": "grey coat", "gender": "female", "age_estimate": "40"},
+ {"physical": "x", "visual_appearance": "copper hair, green eyes", "visual_costume": "blue wool coat"},
+ {"physical": "ä ö ü ß – »Zitat« 😀", "marks": ["scar", "tattoo"], "visual_species": "Elf"},
+ ]
+ self.assertEqual(_js_fingerprint(sheets), [_character_identity_fingerprint(s) for s in sheets])
+
+ def test_a_pair_made_before_overrides_existed_keeps_a_valid_fingerprint(self):
+ sheet = {"physical": "tall, white hair", "clothing": "grey coat", "gender": "female"}
+ self.assertEqual(_character_identity_fingerprint(sheet), _legacy_fingerprint(sheet))
+
+ def test_editing_an_override_marks_the_pair_stale(self):
+ base = {"physical": "tall", "clothing": "coat"}
+ before = _character_identity_fingerprint(base)
+ for key in _CHARACTER_IDENTITY_OVERRIDE_FIELDS:
+ with self.subTest(key=key):
+ self.assertNotEqual(_character_identity_fingerprint({**base, key: "changed"}), before)
+
+ def test_active_form_changes_the_fingerprint_but_not_the_base(self):
+ sheet = {"physical": "human", "forms": [{"id": "wolf", "name": "Wolf", "physical": "grey fur"}]}
+ base = _character_identity_fingerprint({**sheet, "active_form_id": ""})
+ self.assertNotEqual(_character_identity_fingerprint({**sheet, "active_form_id": "wolf"}), base)
+
+
+_PNG = base64.b64decode("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=")
+
+
+def _img(n: int) -> str:
+ """A distinct valid data URI per n (digests differ)."""
+ return "data:image/png;base64," + base64.b64encode(_PNG + bytes([n])).decode()
+
+
+def _pair_meta(sheet: dict) -> dict:
+ return {
+ "consistent_prompt_version": _CHARACTER_VISUAL_PROMPT_VERSION,
+ "consistent_identity_fingerprint": _character_identity_fingerprint(sheet),
+ "identity_consistent": True,
+ }
+
+
+class VisualPairReviewTests(unittest.TestCase):
+ def setUp(self):
+ app = FastAPI()
+ app.include_router(characters.router)
+ self.client = TestClient(app)
+
+ def review(self, records):
+ with mock.patch.object(characters, "char_get_all", return_value=records):
+ r = self.client.get("/api/characters/visual-pair-review")
+ self.assertEqual(r.status_code, 200)
+ return r.json()
+
+ def test_a_healthy_base_pair_and_a_healthy_form_pair_pass(self):
+ base = {"physical": "human", "clothing": "coat"}
+ form = {"id": "wolf", "name": "Wolf", "physical": "grey fur"}
+ form_fp = _character_identity_fingerprint({**base, "forms": [form], "active_form_id": "wolf"})
+ rec = {"id": "c1", "name": "Zerwas", "image": _img(1),
+ "sheet": {**base, **_pair_meta(base), "concept_art_image": _img(2),
+ "forms": [{**form, "image": _img(3), "concept_art_image": _img(4),
+ "consistent_prompt_version": _CHARACTER_VISUAL_PROMPT_VERSION,
+ "consistent_identity_fingerprint": form_fp, "identity_consistent": True}],
+ "active_form_id": "wolf"}}
+ self.assertEqual(self.review([rec])["issues"], [])
+
+ def test_a_stale_form_pair_is_reported_under_the_form_name(self):
+ base = {"physical": "human"}
+ form = {"id": "wolf", "name": "Wolf", "physical": "grey fur", "image": _img(3), "concept_art_image": _img(4),
+ "consistent_prompt_version": _CHARACTER_VISUAL_PROMPT_VERSION,
+ "consistent_identity_fingerprint": "deadbeef", "identity_consistent": True}
+ rec = {"id": "c1", "name": "Zerwas", "image": _img(1),
+ "sheet": {**base, **_pair_meta(base), "concept_art_image": _img(2), "forms": [form]}}
+ issues = self.review([rec])["issues"]
+ self.assertEqual(len(issues), 1)
+ self.assertEqual(issues[0]["form_id"], "wolf")
+ self.assertEqual(issues[0]["form_name"], "Wolf")
+ self.assertIn("appearance_changed_since_generation", issues[0]["issues"])
+
+ def test_an_active_form_no_longer_makes_the_base_pair_look_unfingerprinted(self):
+ base = {"physical": "human"}
+ rec = {"id": "c1", "name": "Zerwas", "image": _img(1),
+ "sheet": {**base, **_pair_meta(base), "concept_art_image": _img(2),
+ "forms": [{"id": "wolf", "name": "Wolf", "physical": "grey fur"}], "active_form_id": "wolf"}}
+ self.assertEqual(self.review([rec])["issues"], [])
+
+ def test_a_form_without_images_is_not_reviewed(self):
+ base = {"physical": "human"}
+ rec = {"id": "c1", "name": "A", "image": _img(1),
+ "sheet": {**base, **_pair_meta(base), "concept_art_image": _img(2),
+ "forms": [{"id": "f", "name": "F", "physical": "x"}]}}
+ self.assertEqual(self.review([rec])["issues"], [])
+
+ def test_the_same_asset_on_two_characters_is_flagged(self):
+ s = {"physical": "a"}
+ recs = [{"id": f"c{i}", "name": f"N{i}", "image": _img(9),
+ "sheet": {**s, **_pair_meta(s), "concept_art_image": _img(10 + i)}} for i in range(2)]
+ issues = self.review(recs)["issues"]
+ self.assertEqual({i["id"] for i in issues}, {"c0", "c1"})
+ self.assertTrue(all("asset_reused_across_characters" in i["issues"] for i in issues))
+
+
+if __name__ == "__main__":
+ unittest.main()
Stimme
'
@@ -1608,6 +1754,68 @@ async function _charDetailPage(rec, allChars, opts) {
_charDetailPage(updated, all.filter(function (item) { return item.book === rec.book; }), opts);
});
+ // ── Form management ───────────────────────────────────────────────────────
+ async function rerenderDetail() {
+ const all = await clGetAll().catch(function () { return allChars; });
+ const updated = all.find(function (item) { return item.id === rec.id; }) || rec;
+ _charDetailPage(updated, all.filter(function (item) { return item.book === rec.book; }), opts);
+ }
+ const formsStatus = pg.querySelector('.lcd-forms-status');
+ const setFormsStatus = function (msg) { if (formsStatus) formsStatus.textContent = msg || ''; };
+ const guardForms = async function (work) {
+ try { await work(); } catch (err) { setFormsStatus(''); toast(err.message || String(err), 'error'); }
+ };
+ pg.querySelector('.lcd-form-add-btn')?.addEventListener('click', function () {
+ guardForms(async function () {
+ await _libPersistSheet(rec, _libAddForm(baseSheet, pg.querySelector('.lcd-form-new-name').value));
+ toast('Form added - it starts as a copy of the base look; edit it below.', 'success');
+ await rerenderDetail();
+ });
+ });
+ pg.querySelector('.lcd-form-new-name')?.addEventListener('keydown', function (e) {
+ if (e.key === 'Enter') { e.preventDefault(); pg.querySelector('.lcd-form-add-btn')?.click(); }
+ });
+ pg.querySelectorAll('.lcd-forms-list li').forEach(function (row) {
+ const id = row.dataset.formId;
+ row.querySelector('.lcd-form-name').addEventListener('change', function () {
+ guardForms(async function () {
+ await _libPersistSheet(rec, _libRenameForm(baseSheet, id, row.querySelector('.lcd-form-name').value));
+ await rerenderDetail();
+ });
+ });
+ row.querySelector('.lcd-form-show').addEventListener('click', function () {
+ guardForms(async function () { await _libPersistSheet(rec, Object.assign({}, baseSheet, { active_form_id: id })); await rerenderDetail(); });
+ });
+ row.querySelector('.lcd-form-del').addEventListener('click', function () {
+ guardForms(async function () {
+ const form = characterForms.find(function (f) { return String(f?.id) === id; });
+ const ok = await confirmDialog('Delete the form "' + (form?.name || id) + '"? Its own text and images are removed; the character, its voice and the base look stay.',
+ { title: 'Delete form?', okLabel: 'Delete', danger: true });
+ if (!ok) return;
+ await _libPersistSheet(rec, _libDeleteForm(baseSheet, id));
+ await rerenderDetail();
+ });
+ });
+ row.querySelector('.lcd-form-gen').addEventListener('click', function () {
+ guardForms(async function () {
+ setFormsStatus('Generating images for this form…');
+ await _libGenerateFormImages(rec, [id], pg.querySelector('.lcd-visual-style')?.value || 'cinematic');
+ toast('Matching images generated for this form', 'success');
+ await rerenderDetail();
+ });
+ });
+ });
+ pg.querySelector('.lcd-forms-gen-all')?.addEventListener('click', function () {
+ guardForms(async function () {
+ const ids = characterForms.map(function (f) { return String(f?.id); });
+ await _libGenerateFormImages(rec, ids, pg.querySelector('.lcd-visual-style')?.value || 'cinematic', function (n, total, name) {
+ setFormsStatus('Generating images: form ' + n + ' of ' + total + ' (' + name + ')…');
+ });
+ toast('Images generated for all ' + ids.length + ' forms', 'success');
+ await rerenderDetail();
+ });
+ });
+
pg.querySelector('.lib-cpg-back').addEventListener('click', function (e) {
e.preventDefault();
e.stopPropagation();
@@ -1744,9 +1952,7 @@ async function _charDetailPage(rec, allChars, opts) {
btn.disabled = true;
btn.innerHTML = ' Saving…';
try {
- if (!rec.sheet) rec.sheet = {};
- rec.sheet[sheetKey] = text;
- rec.sheet[sheetKey + '_user_edited'] = true;
+ _libSetSheetPrompt(rec, sheetKey, text, true);
rec.updated = new Date();
if (typeof clPut === 'function') await clPut(rec);
// Voice prompts are also available as reusable design presets; the
@@ -1840,9 +2046,7 @@ async function _charDetailPage(rec, allChars, opts) {
if (!r.ok) throw new Error((await r.json().catch(function () { return {}; })).detail || r.statusText);
const d = await r.json();
if (!d[key]) throw new Error('Empty response — try again');
- if (!rec.sheet) rec.sheet = {};
- rec.sheet[key] = d[key];
- rec.sheet[key + '_user_edited'] = false;
+ _libSetSheetPrompt(rec, key, d[key], false);
rec.updated = new Date();
if (typeof clPut === 'function') await clPut(rec);
toast('Prompt generated', 'success');
@@ -1882,6 +2086,7 @@ async function _charDetailPage(rec, allChars, opts) {
clearTimeout(_saveTimers.get(key));
_saveTimers.set(key, setTimeout(async function () {
if (isRecKey) { rec[key] = value; }
+ else if (key === 'physical' || key === 'clothing') { _libSetFormField(rec, key, value); } // the active form's own text
else { if (!rec.sheet) rec.sheet = {}; rec.sheet[key] = value; }
rec.updated = new Date();
if (typeof clPut === 'function') await clPut(rec);
@@ -3343,7 +3548,12 @@ async function _libSaveCharacterVisual(rec, fields) {
return String(item?.id || '') === String(form.id || '') ? Object.assign({}, item, fields) : item;
}) : [];
} else {
- Object.assign(target, fields);
+ // The base appearance: the profile image is the record's own `image`; the concept image,
+ // prompt version, fingerprint and digests all belong on the sheet, where the UI and the
+ // pair review read them (they used to land on the record root or stay in memory only).
+ const { image, ...sheetFields } = fields;
+ if ('image' in fields) target.image = image;
+ if (Object.keys(sheetFields).length) target.sheet = Object.assign({}, target.sheet || {}, sheetFields);
}
target.updated = new Date();
if (typeof clPut === 'function') await clPut(target);
@@ -3354,6 +3564,42 @@ async function _libSaveCharacterVisual(rec, fields) {
return target;
}
+// Prompts that describe one appearance live on the active form; every other prompt
+// (voice, SillyTavern) belongs to the character as a whole.
+function _libSetSheetPrompt(rec, key, value, edited) {
+ const form = (key === 'image_prompt' || key === 'concept_art_prompt') ? _libActiveCharacterForm(rec) : null;
+ rec.sheet = Object.assign({}, rec.sheet || {});
+ if (form) {
+ rec.sheet.forms = (rec.sheet.forms || []).map(function (item) {
+ if (String(item?.id || '') !== String(form.id || '')) return item;
+ const next = Object.assign({}, item);
+ next[key] = value;
+ next[key + '_user_edited'] = edited;
+ return next;
+ });
+ } else {
+ rec.sheet[key] = value;
+ rec.sheet[key + '_user_edited'] = edited;
+ }
+}
+
+// The portrait prompt is built server-side from the same structured facts as the concept
+// sheet (no LLM call). Returns '' when it cannot be reached so callers can fall back.
+async function _libDeterministicPortraitPrompt(rec, bookProfile, sh) {
+ try {
+ const r = await fetch('/api/character-generate-prompts', {
+ method: 'POST', headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({
+ name: rec.name || '', book: rec.book || '', book_profile: bookProfile || {},
+ sheet: rec.sheet || {}, visual_style: _libStr(sh.visual_style) === 'concept' ? 'concept' : 'cinematic',
+ fields: ['image_prompt'],
+ }),
+ });
+ if (!r.ok) return '';
+ return _libStr((await r.json()).image_prompt).trim();
+ } catch (_) { return ''; }
+}
+
async function _charAutoGenerateImage(rec, provider) {
const form = _libActiveCharacterForm(rec);
const sh = form ? Object.assign({}, rec.sheet || {}, form) : (rec.sheet || {});
@@ -3373,7 +3619,12 @@ async function _charAutoGenerateImage(rec, provider) {
}
}
const bookProfile = typeof _getBookProfile === 'function' ? await _getBookProfile(rec.book) : {};
- const prompt = hasExplicitPrompt ? _libStr(sh.image_prompt).trim() : (typeof csBuildImagePrompt === 'function' ? csBuildImagePrompt(sh, bookProfile) : '');
+ // A hand-edited prompt is honoured; otherwise use the deterministic prompt so a lone avatar
+ // is built from exactly the facts the concept sheet uses (older records may still carry an
+ // LLM-authored prompt from before extraction stopped writing one).
+ const editedPrompt = sh.image_prompt_user_edited === true && hasExplicitPrompt;
+ let prompt = editedPrompt ? _libStr(sh.image_prompt).trim() : await _libDeterministicPortraitPrompt(rec, bookProfile, sh);
+ if (!prompt) prompt = hasExplicitPrompt ? _libStr(sh.image_prompt).trim() : (typeof csBuildImagePrompt === 'function' ? csBuildImagePrompt(sh, bookProfile) : '');
if (!prompt) throw new Error('No image prompt to work from yet');
const body = { prompt: prompt, image_kind: 'portrait' };
if (provider) body.provider = provider;
@@ -3383,14 +3634,8 @@ async function _charAutoGenerateImage(rec, provider) {
});
if (!r.ok) { const e = await r.json().catch(function () { return {}; }); throw new Error(e.detail || r.statusText); }
const d = await r.json();
- if (form) {
- await _libSaveCharacterVisual(rec, { image: d.image });
- const updatedForm = _libActiveCharacterForm(rec);
- if (updatedForm) updatedForm.image = d.image;
- } else {
- if (typeof clSetImage === 'function') await clSetImage(rec.id, d.image);
- rec.image = d.image;
- }
+ // Regenerating only the avatar gives a new face, so an existing matched pair no longer is one.
+ await _libSaveCharacterVisual(rec, sh.concept_art_image ? { image: d.image, identity_consistent: false } : { image: d.image });
// Bulk runs only re-render the whole grid once, at the very end — with a
// ComfyUI workflow that can take a minute or more per character, that
// left the toolbar's progress counter as the only sign anything was
@@ -3557,15 +3802,7 @@ async function _charAutoGenerateConsistentImages(rec, visualStyle) {
const d = await _cijPollJob(job_id, panel);
if (!d.profile || !d.reference) throw new Error('ComfyUI returned an incomplete image pair');
const visualFields = { image: d.profile, concept_art_image: d.reference, consistent_prompt_version: d.prompt_version || 'v3', consistent_identity_fingerprint: d.identity_fingerprint || '', profile_asset_digest: d.profile_asset_digest || '', reference_asset_digest: d.reference_asset_digest || '', identity_consistent: d.identity_consistent !== false };
- if (form) {
- await _libSaveCharacterVisual(rec, visualFields);
- const updatedForm = _libActiveCharacterForm(rec);
- if (updatedForm) Object.assign(updatedForm, visualFields);
- } else {
- if (typeof clSetImage === 'function') await clSetImage(rec.id, d.profile);
- Object.assign(rec, { image: d.profile });
- rec.sheet = Object.assign({}, rec.sheet || {}, { concept_art_image: d.reference, consistent_prompt_version: visualFields.consistent_prompt_version, consistent_identity_fingerprint: visualFields.consistent_identity_fingerprint, identity_consistent: visualFields.identity_consistent });
- }
+ await _libSaveCharacterVisual(rec, visualFields);
document.querySelectorAll('.lib-char-avatar[data-char-id="' + CSS.escape(rec.id) + '"]').forEach(function (av) {
av.innerHTML = '