@tangle-network/agent-app 0.46.8 → 0.46.9

package/dist/studio-react/composer-persistence.d.ts

@@ -0,0 +1,12 @@
+import type { ModelOptionValue } from '../studio';
+import type { ComposerType } from './studio-composer';
+export interface PersistedComposerSelections {
+    v: 1;
+    type: ComposerType;
+    selectedModels: Partial<Record<ComposerType, string>>;
+    /** Option values are model-specific: two models in one lane may publish
+     *  different enums for the same parameter. */
+    optionsByModel: Record<string, Record<string, ModelOptionValue>>;
+}
+export declare function loadComposerSelections(workspaceId: string): PersistedComposerSelections | null;
+export declare function saveComposerSelections(workspaceId: string, snapshot: PersistedComposerSelections): void;

package/dist/studio-react/index.js

@@ -685,6 +685,58 @@ function optionValueLabel(param, value) {
   return text.charAt(0).toUpperCase() + text.slice(1);
 }
 
+// src/studio-react/composer-persistence.ts
+var COMPOSER_TYPES = ["image", "video", "speech"];
+function storageKey(workspaceId) {
+  return `studio-composer:${workspaceId}`;
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isComposerType(value) {
+  return COMPOSER_TYPES.some((type) => type === value);
+}
+function isOptionValue(value) {
+  return typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value);
+}
+function parseSelections(value) {
+  if (!isPlainObject(value) || value.v !== 1 || !isComposerType(value.type)) return null;
+  if (!isPlainObject(value.selectedModels) || !isPlainObject(value.optionsByModel)) return null;
+  const selectedModels = {};
+  for (const type of COMPOSER_TYPES) {
+    const modelId = value.selectedModels[type];
+    if (typeof modelId === "string") selectedModels[type] = modelId;
+  }
+  const optionsByModel = {};
+  for (const [modelId, rawOptions] of Object.entries(value.optionsByModel)) {
+    if (!isPlainObject(rawOptions)) continue;
+    const options = {};
+    for (const [param, optionValue] of Object.entries(rawOptions)) {
+      if (isOptionValue(optionValue)) options[param] = optionValue;
+    }
+    optionsByModel[modelId] = options;
+  }
+  return { v: 1, type: value.type, selectedModels, optionsByModel };
+}
+function loadComposerSelections(workspaceId) {
+  if (typeof window === "undefined") return null;
+  try {
+    const raw = window.localStorage.getItem(storageKey(workspaceId));
+    return raw === null ? null : parseSelections(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+}
+function saveComposerSelections(workspaceId, snapshot) {
+  if (typeof window === "undefined") return;
+  try {
+    window.localStorage.setItem(storageKey(workspaceId), JSON.stringify(snapshot));
+  } catch {
+  }
+}
+
 // src/studio-react/studio-composer.tsx
 import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
 var SEGMENTS = [
@@ -760,8 +812,26 @@ function StudioComposer({
   const [referenceImageUrl, setReferenceImageUrl] = useState3(null);
   const [isSubmitting, setIsSubmitting] = useState3(false);
   const [error, setError] = useState3(null);
+  const [hydratedWorkspaceId, setHydratedWorkspaceId] = useState3(null);
   const submitLockRef = useRef2(false);
   const bandRef = useRef2(null);
+  const hydratedRef = useRef2(false);
+  const persistedOptionsRef = useRef2({});
+  useEffect3(() => {
+    hydratedRef.current = false;
+    setHydratedWorkspaceId(null);
+    if (!workspaceId) return;
+    const persisted = loadComposerSelections(workspaceId);
+    if (persisted) {
+      setType(persisted.type);
+      setSelectedModels(persisted.selectedModels);
+      persistedOptionsRef.current = persisted.optionsByModel;
+    } else {
+      persistedOptionsRef.current = {};
+    }
+    hydratedRef.current = true;
+    setHydratedWorkspaceId(workspaceId);
+  }, [workspaceId]);
   useEffect3(() => {
     if (!workspaceId) return;
     let cancelled = false;
@@ -814,13 +884,35 @@ function StudioComposer({
   );
   useEffect3(() => {
     setOptionValues((current) => {
-      const next = reconcileOptionValues(options, current[type], {
+      const seed = { ...persistedOptionsRef.current[modelId], ...current[type] };
+      const next = reconcileOptionValues(options, seed, {
         allowCustomSize: supportsCustomImageSize(modelId)
       });
       const unchanged = Object.keys(next).length === Object.keys(current[type]).length && Object.entries(next).every(([key, value]) => current[type][key] === value);
       return unchanged ? current : { ...current, [type]: next };
     });
   }, [modelId, options, type]);
+  useEffect3(() => {
+    if (!workspaceId || !hydratedRef.current || hydratedWorkspaceId !== workspaceId) return;
+    if (!catalog && modelId && persistedOptionsRef.current[modelId] !== void 0 && !options) return;
+    const seed = { ...persistedOptionsRef.current[modelId], ...optionValues[type] };
+    const reconciled = reconcileOptionValues(options, seed, {
+      allowCustomSize: supportsCustomImageSize(modelId)
+    });
+    const reconciledReady = Object.keys(reconciled).length === Object.keys(optionValues[type]).length && Object.entries(reconciled).every(([key, value]) => optionValues[type][key] === value);
+    if (!reconciledReady) return;
+    const optionsByModel = {
+      ...persistedOptionsRef.current,
+      ...modelId ? { [modelId]: optionValues[type] } : {}
+    };
+    saveComposerSelections(workspaceId, {
+      v: 1,
+      type,
+      selectedModels,
+      optionsByModel
+    });
+    persistedOptionsRef.current = optionsByModel;
+  }, [catalog, hydratedWorkspaceId, modelId, optionValues, options, selectedModels, type, workspaceId]);
   const values = optionValues[type];
   const params = visibleParams(type, options);
   const audioMeta = type === "video" ? options?.audio : void 0;