@liforma/client 0.4.0 → 0.4.2

package/dist/svelte/Experience.svelte

@@ -11,6 +11,7 @@
 		type ExperienceEventName,
 		type ExperienceSession,
 		type ListenOnceOptions,
+		type Session,
 		type SessionManifest,
 		type StartSessionOptions,
 		type UtteranceResult
@@ -47,13 +48,16 @@
 	let {
 		experienceId,
 		sessionEndpoint,
-		manifest,
-		acceptCredentialExposure = false,
+		launch: launchToken,
+		session: launchSessionSummary,
+		locale,
+		secondaryLocale,
+		learningLocale,
 		language,
 		mode,
-		responseMode,
 		speechInputMode,
 		startButton,
+		closeButton,
 		conversationProcessor,
 		speechOnly = false,
 		fit,
@@ -72,8 +76,9 @@
 		onConversationUpdate,
 		onMessage,
 		onListeningState,
-		onModeChange,
+		onActivityChange,
 		onConversationProcessorError,
+		onPlayerStatusChange,
 		onStateUpdate,
 		onClose,
 		onError
@@ -87,21 +92,18 @@
 	let activeGeneration: Generation | null = null;
 	const launchIdentities = new WeakMap<object, number>();
 
-	const startButtonKey = $derived(stableSerialize(startButton));
 	const launchKey = $derived(
 		stableSerialize([
 			experienceId,
 			sessionEndpoint,
-			manifest ? identityKey(manifest) : 0,
-			acceptCredentialExposure,
-			language,
+			launchToken,
+			launchSessionSummary ? identityKey(launchSessionSummary) : 0,
+			locale ?? language,
+			secondaryLocale ?? learningLocale,
 			mode,
-			responseMode,
 			speechInputMode,
-			startButtonKey,
 			conversationProcessor ? identityKey(conversationProcessor) : 0,
 			speechOnly,
-			fit,
 			avatarId,
 			locationId,
 			embedBaseUrl,
@@ -190,12 +192,10 @@
 			const id = (options as { readonly experienceId?: string }).experienceId;
 			if (typeof id === 'string' && id.trim()) return id;
 		}
-		if ('manifest' in options) {
-			const manifest = (options as { readonly manifest?: unknown }).manifest;
-			if (manifest && typeof manifest === 'object' && 'experienceId' in manifest) {
-				const id = (manifest as { readonly experienceId?: unknown }).experienceId;
-				if (typeof id === 'string' && id.trim()) return id;
-			}
+		if ('session' in options) {
+			const id = (options as { readonly session?: { readonly experienceId?: unknown } }).session
+				?.experienceId;
+			if (typeof id === 'string' && id.trim()) return id;
 		}
 		return experienceId?.trim() || undefined;
 	}
@@ -268,7 +268,7 @@
 		);
 		subscribe(generation, session, 'message', (event) => onMessage?.(event));
 		subscribe(generation, session, 'listeningState', (event) => onListeningState?.(event));
-		subscribe(generation, session, 'modeChange', (event) => onModeChange?.(event));
+		subscribe(generation, session, 'activityChange', (event) => onActivityChange?.(event));
 		subscribe(generation, session, 'conversationProcessorError', (event) =>
 			onConversationProcessorError?.(event)
 		);
@@ -276,61 +276,60 @@
 
 	function buildStartOptions(): StartSessionOptions {
 		const hasSessionEndpoint = Boolean(sessionEndpoint?.trim());
+		const hasLaunch = Boolean(launchToken?.trim());
 		if (hasSessionEndpoint && !experienceId?.trim()) {
 			throw new Error('sessionEndpoint requires experienceId.');
 		}
-		if (!hasSessionEndpoint && !experienceId && !manifest) {
-			throw new Error('Experience requires experienceId or manifest.');
+		if (!hasSessionEndpoint && !hasLaunch && !experienceId) {
+			throw new Error('Experience requires experienceId, sessionEndpoint, or launch.');
 		}
 
+		if (hasLaunch && launchToken) {
+			return {
+				launch: launchToken,
+				session: launchSessionSummary,
+				embedBaseUrl,
+				debug,
+				speechOnly,
+				conversationProcessor
+			};
+		}
 		if (hasSessionEndpoint && experienceId && sessionEndpoint) {
 			return {
 				experienceId,
 				sessionEndpoint,
+				locale,
+				secondaryLocale,
+				learningLocale,
 				language,
 				locationId,
 				avatarId,
 				embedBaseUrl,
 				debug,
 				mode,
-				responseMode,
 				speechInputMode,
 				speechOnly,
-				fit,
-				startButton: untrack(() => startButton),
-				conversationProcessor
-			};
-		}
-		if (manifest) {
-			return {
-				manifest,
-				acceptCredentialExposure,
-				embedBaseUrl,
-				debug,
-				speechOnly,
-				fit,
-				startButton: untrack(() => startButton),
 				conversationProcessor
 			};
 		}
 		if (experienceId) {
 			return {
 				experienceId,
+				locale,
+				secondaryLocale,
+				learningLocale,
 				language,
 				locationId,
 				avatarId,
 				embedBaseUrl,
 				debug,
 				mode,
-				responseMode,
 				speechInputMode,
 				speechOnly,
-				fit,
-				startButton: untrack(() => startButton),
 				conversationProcessor
 			};
 		}
-		throw new Error('Experience requires experienceId or manifest.');
+		throw new Error('Experience requires experienceId, sessionEndpoint, or launch.');
 	}
 
 	function snapshotLaunch(): LaunchSnapshot {
@@ -341,7 +340,7 @@
 		}
 	}
 
-	async function launch(
+	async function runLaunch(
 		generation: Generation,
 		container: HTMLDivElement,
 		options: StartSessionOptions
@@ -357,9 +356,15 @@
 			subscribeToEvents(generation, session);
 			const player = await session.attach({
 				container,
-				showClose: Boolean(onClose || returnUrl?.trim()),
-				onStateUpdate: (state: EmbedState) => {
-					if (!generation.destroyed) onStateUpdate?.(state);
+				fit: untrack(() => fit),
+				startButton: untrack(() => startButton),
+				closeButton: untrack(() => closeButton),
+				returnUrl: untrack(() => returnUrl),
+				showClose: Boolean(onClose || returnUrl?.trim() || closeButton),
+				onPlayerStatusChange: (state: EmbedState) => {
+					if (generation.destroyed) return;
+					onPlayerStatusChange?.(state);
+					onStateUpdate?.(state);
 				}
 			});
 			assertCurrent(generation);
@@ -437,6 +442,11 @@
 		return withSession((session) => session.listenOnce(options));
 	}
 
+	export function getSession(): Session | null {
+		return activeGeneration?.instance?.getSession() ?? null;
+	}
+
+	/** @deprecated Prefer getSession(). */
 	export function getManifest(): SessionManifest | null {
 		return activeGeneration?.instance?.getManifest() ?? null;
 	}
@@ -462,7 +472,7 @@
 			generation.ready.reject(error);
 			generation.started.reject(error);
 		} else {
-			void launch(generation, container, snapshot.options);
+			void runLaunch(generation, container, snapshot.options);
 		}
 
 		return () => cancelGeneration(generation);

package/dist/svelte/Experience.svelte.d.ts

@@ -1,4 +1,4 @@
-import { type ExperienceEvents, type ExperienceSession, type ListenOnceOptions, type SessionManifest, type UtteranceResult } from '@liforma/client';
+import { type ExperienceEvents, type ExperienceSession, type ListenOnceOptions, type Session, type SessionManifest, type UtteranceResult } from '@liforma/client';
 import type { ExperienceProps } from './types';
 declare const Experience: import("svelte").Component<ExperienceProps, {
     ready: () => Promise<ExperienceEvents["ready"]>;
@@ -12,6 +12,7 @@ declare const Experience: import("svelte").Component<ExperienceProps, {
     startListening: () => Promise<void>;
     stopListening: () => Promise<UtteranceResult>;
     listenOnce: (options?: ListenOnceOptions) => Promise<UtteranceResult>;
+    getSession: () => Session | null;
     getManifest: () => SessionManifest | null;
     getConversation: () => ReturnType<ExperienceSession["getConversation"]>;
     end: () => Promise<void>;

package/dist/svelte/ExperienceThumbnail.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-	import { onMount } from 'svelte';
+	import { onMount, untrack } from 'svelte';
 	import type { Attachment } from 'svelte/attachments';
 
 	import {
@@ -29,6 +29,7 @@
 		returnUrl,
 		playerBaseUrl,
 		parallax = true,
+		fit = 'full',
 		lazy = true,
 		class: className = '',
 		fallbackImage
@@ -46,6 +47,7 @@
 		returnUrl?: string;
 		playerBaseUrl?: string;
 		parallax?: boolean;
+		fit?: 'full' | 'face';
 		lazy?: boolean;
 		class?: string;
 		fallbackImage?: string;
@@ -126,6 +128,10 @@
 		void layers?.backgroundImage;
 		void layers?.foregroundImage;
 		void resolvedAvatarImage;
+		const alreadyShown = untrack(
+			() => backgroundReady || avatarReady || foregroundReady
+		);
+		if (alreadyShown) return;
 		backgroundReady = false;
 		avatarReady = false;
 		foregroundReady = false;
@@ -257,6 +263,7 @@
 		[
 			'liforma-et',
 			hasScene ? 'liforma-et--scene' : '',
+			fit === 'face' ? 'liforma-et--fit-face' : '',
 			parallaxLayersActive ? 'liforma-et--parallax' : '',
 			scrollParallax ? 'liforma-et--scroll-parallax' : '',
 			shouldLoad && !revealThumb ? 'liforma-et--loading' : '',

package/dist/svelte/ExperienceThumbnail.svelte.d.ts

@@ -13,6 +13,7 @@ type $$ComponentProps = {
     returnUrl?: string;
     playerBaseUrl?: string;
     parallax?: boolean;
+    fit?: 'full' | 'face';
     lazy?: boolean;
     class?: string;
     fallbackImage?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@liforma/client",
-	"version": "0.4.0",
+	"version": "0.4.2",
 	"type": "module",
 	"description": "Liforma browser SDK — Experience sessions, speech API, and Svelte embed component.",
 	"license": "MIT",
@@ -163,6 +163,7 @@
 		"fetch:lf-sta": "node scripts/fetch-wav2vec-phoneme-ctc.mjs",
 		"fetch:supertonic-3": "node scripts/fetch-supertonic-3.mjs",
 		"fetch:lf-tts": "node scripts/fetch-supertonic-3.mjs",
+		"fetch:lf-t2i-turbo": "python3 ../tools/krea-2-salad/scripts/fetch_cdn_snapshot.py",
 		"fetch:models": "npm run fetch:depth-anything-v2 && npm run fetch:video-depth-anything && npm run fetch:depth-pro && npm run fetch:face-landmarker && npm run fetch:anime-face-detector && npm run fetch:face-parsing && npm run fetch:lf-sta && npm run fetch:lf-tts",
 		"locations": "npm run catalogue:locations && npm run build:locations",
 		"configure:cors": "node scripts/configure-r2-cors.mjs",
@@ -178,6 +179,7 @@
 	},
 	"devDependencies": {
 		"@aws-sdk/client-s3": "^3.1000.0",
+		"@aws-sdk/lib-storage": "^3.1110.0",
 		"@elevenlabs/client": "^1.17.0",
 		"@sveltejs/package": "^2.5.8",
 		"@sveltejs/vite-plugin-svelte": "^7.0.0",

package/dist/next/v2/speechOnlyManifest.d.ts

@@ -1,7 +0,0 @@
-import type { SessionManifest } from './types/sessionManifest';
-/**
- * Strip avatar rendering and location scene assets from a Session Manifest.
- * Used when integrators request voice-only mode without authoring a separate experience.
- */
-export declare function applySpeechOnlyManifest(manifest: SessionManifest): SessionManifest;
-//# sourceMappingURL=speechOnlyManifest.d.ts.map

package/dist/next/v2/speechOnlyManifest.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"speechOnlyManifest.d.ts","sourceRoot":"","sources":["../../../src/v2/speechOnlyManifest.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAU/D;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,eAAe,GAAG,eAAe,CAiBlF"}

package/dist/next/v2/types/sessionManifestSchema.d.ts

@@ -1,183 +0,0 @@
-import { z } from 'zod';
-import type { SessionManifest } from './sessionManifest';
-export declare const sessionManifestSchema: z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
-    sessionId: z.ZodString;
-    experienceId: z.ZodString;
-    expiresAt: z.ZodString;
-    sessionToken: z.ZodString;
-    experience: z.ZodObject<{
-        title: z.ZodString;
-        slug: z.ZodString;
-        mode: z.ZodEnum<{
-            conversation: "conversation";
-            presenter: "presenter";
-        }>;
-        responseMode: z.ZodEnum<{
-            manual: "manual";
-            managed: "managed";
-            custom: "custom";
-        }>;
-        speechInputMode: z.ZodEnum<{
-            auto: "auto";
-            manual: "manual";
-            off: "off";
-        }>;
-        startButton: z.ZodOptional<z.ZodObject<{
-            label: z.ZodOptional<z.ZodString>;
-            ariaLabel: z.ZodOptional<z.ZodString>;
-            placement: z.ZodOptional<z.ZodEnum<{
-                center: "center";
-                "bottom-center": "bottom-center";
-                "bottom-left": "bottom-left";
-                "bottom-right": "bottom-right";
-            }>>;
-            variant: z.ZodOptional<z.ZodEnum<{
-                primary: "primary";
-                secondary: "secondary";
-                minimal: "minimal";
-            }>>;
-            appearance: z.ZodOptional<z.ZodObject<{
-                backgroundColor: z.ZodOptional<z.ZodString>;
-                textColor: z.ZodOptional<z.ZodString>;
-                borderColor: z.ZodOptional<z.ZodString>;
-                borderRadiusPx: z.ZodOptional<z.ZodNumber>;
-                size: z.ZodOptional<z.ZodEnum<{
-                    small: "small";
-                    medium: "medium";
-                    large: "large";
-                }>>;
-                shadow: z.ZodOptional<z.ZodEnum<{
-                    strong: "strong";
-                    none: "none";
-                    soft: "soft";
-                }>>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
-        openingMessage: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-    transport: z.ZodObject<{
-        type: z.ZodLiteral<"http">;
-        config: z.ZodObject<{
-            apiBaseUrl: z.ZodString;
-        }, z.core.$strip>;
-    }, z.core.$strip>;
-    runtime: z.ZodObject<{
-        cdnBaseUrl: z.ZodString;
-        input: z.ZodLiteral<"browserStt">;
-        renderer: z.ZodLiteral<"morph2d">;
-    }, z.core.$strip>;
-    pipeline: z.ZodOptional<z.ZodObject<{
-        stt: z.ZodObject<{
-            placement: z.ZodEnum<{
-                browser: "browser";
-                cloud: "cloud";
-            }>;
-            provider: z.ZodString;
-            model: z.ZodOptional<z.ZodString>;
-            config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        }, z.core.$strip>;
-        llm: z.ZodObject<{
-            placement: z.ZodEnum<{
-                browser: "browser";
-                cloud: "cloud";
-            }>;
-            provider: z.ZodString;
-            model: z.ZodOptional<z.ZodString>;
-            config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        }, z.core.$strip>;
-        tts: z.ZodObject<{
-            placement: z.ZodEnum<{
-                browser: "browser";
-                cloud: "cloud";
-            }>;
-            provider: z.ZodString;
-            model: z.ZodOptional<z.ZodString>;
-            config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        }, z.core.$strip>;
-        animation: z.ZodObject<{
-            enabled: z.ZodBoolean;
-            placement: z.ZodOptional<z.ZodEnum<{
-                browser: "browser";
-                cloud: "cloud";
-            }>>;
-            source: z.ZodEnum<{
-                none: "none";
-                azureViseme: "azureViseme";
-                speechToAnimation: "speechToAnimation";
-            }>;
-            provider: z.ZodOptional<z.ZodString>;
-            model: z.ZodOptional<z.ZodString>;
-            config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        }, z.core.$strip>;
-    }, z.core.$strip>>;
-    capabilities: z.ZodArray<z.ZodString>;
-    characters: z.ZodArray<z.ZodObject<{
-        characterId: z.ZodString;
-        displayName: z.ZodString;
-        avatarId: z.ZodString;
-        voiceId: z.ZodString;
-        sttLang: z.ZodString;
-        agentId: z.ZodString;
-        appearance: z.ZodOptional<z.ZodObject<{
-            costume: z.ZodOptional<z.ZodString>;
-            costumeClothes: z.ZodOptional<z.ZodString>;
-            hair: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    activeCharacterId: z.ZodString;
-    location: z.ZodOptional<z.ZodObject<{
-        locationId: z.ZodString;
-        title: z.ZodString;
-        scene: z.ZodOptional<z.ZodObject<{
-            type: z.ZodLiteral<"image">;
-            layers: z.ZodArray<z.ZodString>;
-            assets: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>;
-        }, z.core.$strip>>;
-        placement: z.ZodOptional<z.ZodObject<{
-            cx: z.ZodNumber;
-            cy: z.ZodNumber;
-            scale: z.ZodNumber;
-            distanceM: z.ZodNumber;
-        }, z.core.$strip>>;
-        metersPerDepth: z.ZodOptional<z.ZodNumber>;
-        hasZoomVariant: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    world: z.ZodOptional<z.ZodObject<{
-        worldId: z.ZodString;
-        rulesetVersion: z.ZodNumber;
-    }, z.core.$strip>>;
-    state: z.ZodObject<{
-        schemaVersion: z.ZodLiteral<1>;
-        values: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    }, z.core.$strip>;
-    tools: z.ZodArray<z.ZodUnknown>;
-    integration: z.ZodOptional<z.ZodObject<{
-        returnUrl: z.ZodOptional<z.ZodString>;
-        navigateOnClose: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    closeButton: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-        visible: z.ZodOptional<z.ZodBoolean>;
-        style: z.ZodOptional<z.ZodEnum<{
-            text: "text";
-            icon: "icon";
-        }>>;
-        label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        position: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-    billing: z.ZodOptional<z.ZodObject<{
-        payer: z.ZodLiteral<"creator">;
-        meterId: z.ZodString;
-    }, z.core.$strip>>;
-    language: z.ZodOptional<z.ZodEnum<{
-        en: "en";
-        es: "es";
-    }>>;
-    languagePackRevision: z.ZodOptional<z.ZodString>;
-    processorId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-/** Apply API defaults for interaction modes omitted by older mint paths. */
-export declare function normalizeSessionManifestInput(data: unknown): unknown;
-export declare function parseSessionManifest(data: unknown): SessionManifest;
-export declare function manifestHasSessionCredential(manifest: SessionManifest): boolean;
-//# sourceMappingURL=sessionManifestSchema.d.ts.map

package/dist/next/v2/types/sessionManifestSchema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sessionManifestSchema.d.ts","sourceRoot":"","sources":["../../../../src/v2/types/sessionManifestSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AA0FzD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwEhC,CAAC;AAEH,4EAA4E;AAC5E,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAgBpE;AAWD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,OAAO,GAAG,eAAe,CAMnE;AAED,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,eAAe,GAAG,OAAO,CAE/E"}

package/dist/react/v2/speechOnlyManifest.d.ts

@@ -1,7 +0,0 @@
-import type { SessionManifest } from './types/sessionManifest';
-/**
- * Strip avatar rendering and location scene assets from a Session Manifest.
- * Used when integrators request voice-only mode without authoring a separate experience.
- */
-export declare function applySpeechOnlyManifest(manifest: SessionManifest): SessionManifest;
-//# sourceMappingURL=speechOnlyManifest.d.ts.map

package/dist/react/v2/speechOnlyManifest.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"speechOnlyManifest.d.ts","sourceRoot":"","sources":["../../../src/v2/speechOnlyManifest.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAU/D;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,eAAe,GAAG,eAAe,CAiBlF"}