@melite/formats 0.0.0-stage → 0.1.4-alpha

package/lib/poserSkin.js

@@ -0,0 +1,126 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+import { apiFetch } from "@melite/catalog";
+// Per-coefficient-signature cache — ONE for the whole estate (both
+// studios share it: previewing a shape in Body Studio primes the exact
+// entry Pose Studio needs, zero network). All shaped meshes share SOMA's
+// 18056-vertex layout; the cache key incorporates identity_model +
+// coeffs + local_changes + custom_targets + preview_pose so identical
+// shapes hit the cache on re-fetch.
+const _meshCache = new Map();
+export async function fetchBindMesh(query = {}) {
+    const { identityModel, identityCoeffs, localChanges, previewPose, customTargets, } = query;
+    const key = identityModel || "anny";
+    // Round coeffs to 1 decimal for the signature - visually-identical shapes
+    // share a cache entry without exploding it on every micro-drag.
+    const coeffsSig = identityCoeffs && identityCoeffs.length > 0
+        ? identityCoeffs.map(v => v.toFixed(1)).join(",")
+        : null;
+    const lcEntries = localChanges && Object.keys(localChanges).length > 0
+        ? Object.entries(localChanges)
+            // Object keys are unique, so the equal-key arm is unreachable:
+            // a two-arm comparator sorts identically here (proof: distinct
+            // strings are always ordered one way or the other).
+            .sort(([a], [b]) => (a < b ? -1 : 1))
+            .map(([k, v]) => `${k}=${v.toFixed(2)}`).join(",")
+        : null;
+    // Custom .target blendshape weights (e.g. {"anime_stylized_enhanced": 0.5}).
+    // Rounded to 2 decimals - same convention as localChanges.
+    const ctEntries = customTargets && Object.keys(customTargets).length > 0
+        ? Object.entries(customTargets)
+            // Same unique-keys proof as lcEntries above: two arms suffice.
+            .sort(([a], [b]) => (a < b ? -1 : 1))
+            .map(([k, v]) => `${k}=${v.toFixed(2)}`).join(",")
+        : null;
+    const poseSig = previewPose && previewPose !== "tpose" ? previewPose : null;
+    const cacheKey = [key, coeffsSig, lcEntries, ctEntries, poseSig].filter(Boolean).join("|");
+    const cached = _meshCache.get(cacheKey);
+    if (cached)
+        return cached;
+    const posePayload = poseSig ? { preview_pose: poseSig } : {};
+    let data;
+    if (coeffsSig || lcEntries || ctEntries) {
+        const res = await apiFetch("/v1/poser/mesh", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                identity_model: key,
+                ...posePayload,
+                ...(coeffsSig ? { identity_coeffs: identityCoeffs } : {}),
+                ...(lcEntries ? { local_changes: localChanges } : {}),
+                // Always send custom_targets for Anny POSTs, even when empty.
+                // The backend's set_identity treats a MISSING custom_targets
+                // field as "preserve previous state" (so phenotype-only edits
+                // don't wipe stylization). But the frontend always sends the
+                // full desired state - so omitting the field when the user
+                // drags a slider to 0 leaves the old weight active (the
+                // "slider at 0 shows ~50%" bug). Sending {} explicitly clears.
+                ...(key === "anny" ? { custom_targets: customTargets ?? {} } : {}),
+            }),
+        });
+        if (!res.ok)
+            throw new Error(`Failed to fetch shaped mesh (${key}): ${res.status}`);
+        data = (await res.json());
+    }
+    else {
+        const qs = new URLSearchParams({ identity_model: key });
+        if (poseSig)
+            qs.set("preview_pose", poseSig);
+        const res = await apiFetch(`/v1/poser/mesh?${qs.toString()}`);
+        if (!res.ok)
+            throw new Error(`Failed to fetch mesh (${key}): ${res.status}`);
+        data = (await res.json());
+    }
+    _meshCache.set(cacheKey, data);
+    return data;
+}
+export async function fetchIdentitySpace(model) {
+    const res = await apiFetch(`/v1/poser/identity-space?identity_model=${encodeURIComponent(model)}`);
+    if (!res.ok)
+        throw new Error(`Failed to fetch identity-space (${model}): ${res.status}`);
+    return (await res.json());
+}
+// Lift the bind pose so feet clear the floor (matches Kimodo scene.py:
+// bind_pos.y -= min_height; bind_pos.y += 0.02).
+const FLOOR_LIFT_Y = 0.02;
+// SOMA-X/ANNY mesh vertices arrive in centimeters (~170 units tall). The
+// Three.js scene (camera, grid, lights) is authored in meters (~1.7 units).
+// Convert at ingestion so downstream code never sees raw cm.
+const CM_TO_M = 0.01;
+/** SkinMeshData → flat Float32Array positions (V*3) in METERS with the
+ *  floor lift applied (the body-studio preview geometry path). */
+export function buildFlatPositions(meshData) {
+    const verts = meshData.vertices;
+    const arr = new Float32Array(verts.length * 3);
+    let minY = Infinity;
+    for (let i = 0; i < verts.length; i++) {
+        const yMeters = verts[i][1] * CM_TO_M;
+        if (yMeters < minY)
+            minY = yMeters;
+    }
+    if (!isFinite(minY))
+        minY = 0;
+    for (let i = 0; i < verts.length; i++) {
+        arr[i * 3] = verts[i][0] * CM_TO_M;
+        arr[i * 3 + 1] = verts[i][1] * CM_TO_M - minY + FLOOR_LIFT_Y;
+        arr[i * 3 + 2] = verts[i][2] * CM_TO_M;
+    }
+    return arr;
+}
+//# sourceMappingURL=poserSkin.js.map

package/lib/prompt-tags.json

@@ -0,0 +1,132 @@
+{
+    "_meta": {
+        "version": 1,
+        "description": "Curated prompt tag library for the editor autocomplete (E4.7). Tags are organized by category so the dropdown can group them. Each tag is a short phrase that reads naturally when appended to a prompt. The categories mirror the typical shot-authoring taxonomy: shot framing, camera movement, lighting, style, subject, mood, color grade.",
+        "noteOnIaC": "This file is checked into source control so the tag library survives environment wipes — adding tags here is the only step needed to grow the library."
+    },
+    "shot": [
+        "extreme close-up",
+        "close-up",
+        "medium close-up",
+        "medium shot",
+        "medium wide shot",
+        "wide shot",
+        "extreme wide shot",
+        "over-the-shoulder",
+        "low angle",
+        "high angle",
+        "dutch angle",
+        "aerial view",
+        "birds eye view",
+        "pov shot",
+        "two shot"
+    ],
+    "camera": [
+        "static shot",
+        "locked-off",
+        "dolly in",
+        "dolly out",
+        "tracking shot",
+        "pan left",
+        "pan right",
+        "tilt up",
+        "tilt down",
+        "handheld",
+        "steady cam",
+        "crane shot",
+        "drone shot",
+        "whip pan",
+        "zoom in",
+        "zoom out",
+        "orbital shot",
+        "parallax"
+    ],
+    "lighting": [
+        "golden hour",
+        "blue hour",
+        "magic hour",
+        "soft light",
+        "hard light",
+        "backlit",
+        "rim light",
+        "volumetric light",
+        "neon glow",
+        "candlelight",
+        "moonlight",
+        "overcast",
+        "high key",
+        "low key",
+        "chiaroscuro",
+        "studio lighting",
+        "natural light"
+    ],
+    "style": [
+        "cinematic",
+        "photorealistic",
+        "hyperreal",
+        "documentary",
+        "film noir",
+        "anime",
+        "watercolor",
+        "oil painting",
+        "3d render",
+        "vintage film",
+        "8mm",
+        "vhs",
+        "cyberpunk",
+        "vaporwave",
+        "minimalist",
+        "maximalist",
+        "surreal",
+        "dreamlike"
+    ],
+    "motion": [
+        "slow motion",
+        "fast motion",
+        "time-lapse",
+        "hyperlapse",
+        "freeze frame",
+        "match cut",
+        "subtle motion",
+        "dynamic motion",
+        "fluid motion",
+        "glitch transition"
+    ],
+    "mood": [
+        "serene",
+        "tense",
+        "melancholic",
+        "euphoric",
+        "ominous",
+        "playful",
+        "mysterious",
+        "romantic",
+        "epic",
+        "intimate",
+        "lonely",
+        "triumphant"
+    ],
+    "color": [
+        "teal and orange",
+        "desaturated",
+        "high contrast",
+        "warm tones",
+        "cool tones",
+        "monochrome",
+        "sepia",
+        "pastel palette",
+        "vivid colors",
+        "muted palette",
+        "neon palette"
+    ],
+    "subject": [
+        "lone figure",
+        "crowd",
+        "vehicle",
+        "landscape",
+        "interior",
+        "cityscape",
+        "nature",
+        "abstract"
+    ]
+}

package/lib/promptTags.d.ts

@@ -0,0 +1,42 @@
+export type PromptTagCategory = 'shot' | 'camera' | 'lighting' | 'style' | 'motion' | 'mood' | 'color' | 'subject';
+export interface PromptTag {
+    /** The phrase as it would be inserted into a prompt. */
+    value: string;
+    /** Category bucket (for grouping in the dropdown). */
+    category: PromptTagCategory;
+}
+/** Category display order for the dropdown (matches the JSON key order). */
+export declare const TAG_CATEGORY_ORDER: readonly PromptTagCategory[];
+/** Human-readable labels for each category. */
+export declare const TAG_CATEGORY_LABELS: Record<PromptTagCategory, string>;
+export declare const ALL_PROMPT_TAGS: readonly PromptTag[];
+/** Case-insensitive containment filter — the workhorse for suggestions. */
+export declare function filterTags(tags: readonly PromptTag[], query: string, limit?: number): PromptTag[];
+
+
+
+
+
+
+
+
+
+
+
+
+
+export declare function extractCurrentToken(text: string, cursorPos?: number): string;
+/**
+ * Insert a tag at the current token position, returning the new text +
+ * new cursor position. The token being typed is replaced by the tag
+ * value; a comma + space separator is appended so the user can keep
+ * adding tags.
+ *
+ *   insertTagAtToken("a cat, gol", 11, "golden hour")
+ *     → { text: "a cat, golden hour, ", cursor: 21 }
+ */
+export declare function insertTagAtToken(text: string, cursorPos: number, tagValue: string): {
+    text: string;
+    cursor: number;
+};
+//# sourceMappingURL=promptTags.d.ts.map

package/lib/promptTags.js

@@ -0,0 +1,116 @@
+/**
+ * E4.7 — Prompt tag library + autocomplete helpers.
+ *
+ * The tag library lives in `src/data/prompt-tags.json` (checked into
+ * source — the IaC piece that survives wipes). This module loads it,
+ * flattens it into a searchable list, and exposes filtering helpers
+ * the PromptAutocomplete component uses to render suggestions.
+ *
+ * Tags are short phrases (e.g. "golden hour", "dolly in", "teal and
+ * orange") that read naturally when appended to a prompt. The current-
+ * token extractor finds the substring being typed after the last comma
+ * or semicolon, so suggestions apply to the phrase the user is mid-
+ * type on, not the whole prompt.
+ */
+import tagsJson from './prompt-tags.json' with { type: 'json' };
+/** Category display order for the dropdown (matches the JSON key order). */
+export const TAG_CATEGORY_ORDER = [
+    'shot', 'camera', 'lighting', 'style',
+    'motion', 'mood', 'color', 'subject',
+];
+/** Human-readable labels for each category. */
+export const TAG_CATEGORY_LABELS = {
+    shot: 'Shot',
+    camera: 'Camera',
+    lighting: 'Lighting',
+    style: 'Style',
+    motion: 'Motion',
+    mood: 'Mood',
+    color: 'Color',
+    subject: 'Subject',
+};
+/**
+ * Flatten the JSON tag map into a single list of { value, category }.
+ * Computed once at module load (the JSON is static) and frozen so
+ * callers can't mutate the canonical list.
+ */
+function flatten(json) {
+    const out = [];
+    for (const cat of TAG_CATEGORY_ORDER) {
+        const arr = json[cat];
+        // Runtime armor for hand-edits that bypass tsc; pinned by
+        // promptTagsArmor.spec.ts (mocked malformed database).
+        if (!Array.isArray(arr))
+            continue;
+        for (const value of arr) {
+            if (typeof value === 'string' && value.length > 0) {
+                out.push({ value, category: cat });
+            }
+        }
+    }
+    return out;
+}
+export const ALL_PROMPT_TAGS = Object.freeze(flatten(tagsJson));
+/** Case-insensitive containment filter — the workhorse for suggestions. */
+export function filterTags(tags, query, limit = 8) {
+    const q = query.trim().toLowerCase();
+    if (!q)
+        return [];
+    // Prefer prefix matches first (they read better), then substring.
+    const prefix = [];
+    const substring = [];
+    for (const tag of tags) {
+        const v = tag.value.toLowerCase();
+        if (v.startsWith(q))
+            prefix.push(tag);
+        else if (v.includes(q))
+            substring.push(tag);
+    }
+    // Stable order within each bucket (JSON order). Prefix bucket wins.
+    return [...prefix, ...substring].slice(0, limit);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+export function extractCurrentToken(text, cursorPos = text.length) {
+    const upTo = text.slice(0, cursorPos);
+    // Find the last comma or semicolon before the cursor.
+    const lastComma = Math.max(upTo.lastIndexOf(','), upTo.lastIndexOf(';'));
+    const tokenStart = lastComma === -1 ? 0 : lastComma + 1;
+    // ltrim whitespace + newlines.
+    return upTo.slice(tokenStart).replace(/^\s+/, '');
+}
+/**
+ * Insert a tag at the current token position, returning the new text +
+ * new cursor position. The token being typed is replaced by the tag
+ * value; a comma + space separator is appended so the user can keep
+ * adding tags.
+ *
+ *   insertTagAtToken("a cat, gol", 11, "golden hour")
+ *     → { text: "a cat, golden hour, ", cursor: 21 }
+ */
+export function insertTagAtToken(text, cursorPos, tagValue) {
+    const upTo = text.slice(0, cursorPos);
+    const after = text.slice(cursorPos);
+    const lastComma = Math.max(upTo.lastIndexOf(','), upTo.lastIndexOf(';'));
+    const tokenStart = lastComma === -1 ? 0 : lastComma + 1;
+    // Keep the prefix (everything before the current token), trimmed.
+    const prefix = upTo.slice(0, tokenStart).trimEnd();
+    // If there's a prefix, ensure it ends with a separator + space.
+    const sep = prefix.length > 0 ? (prefix.endsWith(',') ? ' ' : ', ') : '';
+    const insertion = `${prefix}${sep}${tagValue}, `;
+    const newText = insertion + after;
+    const newCursor = insertion.length;
+    return { text: newText, cursor: newCursor };
+}
+//# sourceMappingURL=promptTags.js.map

package/lib/psdExport.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Minimal layered PSD (Photoshop) writer — 8-bit RGB with per-layer alpha.
+ *
+ * Produces a single-group PSD where each provided layer becomes a PSD layer
+ * (channels R, G, B, transparency mask), plus a flattened composite as the
+ * merged "Image Data" section. Channel data is stored raw (uncompressed) for
+ * simplicity and maximum reader compatibility. This is a best-effort base
+ * implementation — it round-trips in Photoshop, Krita, and GIMP for typical
+ * RGB layers but does not support 16-bit, adjustment layers, or smart objects.
+ */
+export type BlendMode = 'normal' | 'multiply' | 'screen' | 'overlay' | 'darken' | 'lighten' | 'color-dodge' | 'color-burn' | 'hard-light' | 'soft-light' | 'difference' | 'exclusion' | 'hue' | 'saturation' | 'color' | 'luminosity';
+export interface PsdLayerInput {
+    name: string;
+    /** RGBA PNG/JPEG dataUrl of the layer content. Null/empty = skip. */
+    dataUrl: string | null;
+    /** Opacity 0–1. */
+    opacity: number;
+    blendMode: BlendMode;
+    visible: boolean;
+}
+/**
+ * Build a layered PSD Blob. `width`/`height` define the canvas; every layer is
+ * composited into that extent. The merged composite flattens visible layers.
+ */
+export declare function buildPsd(layers: PsdLayerInput[], width: number, height: number, mergedRgba?: Uint8ClampedArray): Promise<Blob>;
+/** Trigger a browser download for a Blob. */
+export declare function downloadBlob(blob: Blob, filename: string): void;
+//# sourceMappingURL=psdExport.d.ts.map