@hyperframes/studio 0.8.80 → 0.8.82

package/src/hooks/useElementLifecycleOps.ts

@@ -3,7 +3,7 @@ import { useCallback } from "react";
 import { usePlayerStore } from "../player";
 import {
   readProjectFileContent,
-  saveProjectFilesWithHistory,
+  saveServerRewriteWithHistory,
   type DomEditCommitBaseParams,
 } from "../utils/studioFileHistory";
 import { createStudioSaveHttpError } from "../utils/studioSaveDiagnostics";
@@ -111,8 +111,6 @@ export function useElementLifecycleOps({
         (candidate) => (candidate.sourceFile || activeCompPath || "index.html") === targetPath,
       );
       try {
-        const originalContent = await readProjectFileContent(pid, targetPath);
-
         const patchTargets = sameFile.map((member) => buildDomEditPatchTarget(member));
         if (patchTargets.some((t) => !t.id && !t.selector && !t.hfId)) {
           throw new Error("Selected element has no patchable target");
@@ -125,6 +123,7 @@ export function useElementLifecycleOps({
           .map((member) => member.hfId)
           .filter((hfId): hfId is string => Boolean(hfId));
         if (onTrySdkDelete && hfIds.length === sameFile.length) {
+          const originalContent = await readProjectFileContent(pid, targetPath);
           let allHandled = true;
           for (const hfId of hfIds) {
             // The SDK owns the document it edits, so every member is removed
@@ -150,28 +149,41 @@ export function useElementLifecycleOps({
         // cost a round trip and a rewrite of the file EACH, and a canvas
         // selection runs to hundreds of members — the file ended up correct, but
         // only after long enough that Delete looked like it had done nothing.
-        const removeResponse = await fetch(
-          buildProjectApiPath(
-            pid,
-            `/file-mutations/remove-elements/${encodeURIComponent(targetPath)}`,
-          ),
-          {
-            method: "POST",
-            headers: { "Content-Type": "application/json", ...studioWriteHeaders() },
-            body: JSON.stringify({ targets: patchTargets }),
+        const deleted = await saveServerRewriteWithHistory({
+          projectId: pid,
+          path: targetPath,
+          label: "Delete element",
+          writeFile: writeProjectFile,
+          recordEdit: editHistory.recordEdit,
+          rewrite: async (originalContent) => {
+            const removeResponse = await fetch(
+              buildProjectApiPath(
+                pid,
+                `/file-mutations/remove-elements/${encodeURIComponent(targetPath)}`,
+              ),
+              {
+                method: "POST",
+                headers: { "Content-Type": "application/json", ...studioWriteHeaders() },
+                body: JSON.stringify({ targets: patchTargets }),
+              },
+            );
+            if (!removeResponse.ok) {
+              throw await createStudioSaveHttpError(
+                removeResponse,
+                `Failed to delete element from ${targetPath}`,
+              );
+            }
+            const removeData = (await removeResponse.json()) as {
+              changed?: boolean;
+              content?: string;
+            };
+            if (!removeData.changed) return null;
+            return {
+              disk: typeof removeData.content === "string" ? removeData.content : originalContent,
+            };
           },
-        );
-        if (!removeResponse.ok) {
-          throw await createStudioSaveHttpError(
-            removeResponse,
-            `Failed to delete element from ${targetPath}`,
-          );
-        }
-        const removeData = (await removeResponse.json()) as {
-          changed?: boolean;
-          content?: string;
-        };
-        if (!removeData.changed) {
+        });
+        if (!deleted) {
           // A member the file no longer holds simply does not match, which is
           // normal for one nested inside another member already removed. Nothing
           // matching at all means the preview is describing a document the file
@@ -180,19 +192,6 @@ export function useElementLifecycleOps({
           showToast("Nothing to delete, the preview was out of date. Try again.");
           return domEditCommitDeclined("preview-stale");
         }
-        const patchedContent =
-          typeof removeData.content === "string" ? removeData.content : originalContent;
-        await saveProjectFilesWithHistory({
-          projectId: pid,
-          label: "Delete element",
-          files: { [targetPath]: patchedContent },
-          readFile: async () => originalContent,
-          // remove-element already wrote the removal, so disk holds THAT — not
-          // the content read at the top. Undo still goes back to the original.
-          diskContent: { [targetPath]: patchedContent },
-          writeFile: writeProjectFile,
-          recordEdit: editHistory.recordEdit,
-        });
 
         clearDomSelection();
         usePlayerStore.getState().setSelectedElementId(null);

package/src/hooks/useFileManager.projectOwnership.test.tsx

@@ -31,19 +31,19 @@ import { StudioFileConflictError } from "../utils/studioSaveDiagnostics";
 
 (globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
 
-function useTestFileManager(projectId: string) {
+function useTestFileManager(projectId: string, showToast = vi.fn()) {
   return useFileManager({
     projectId,
-    showToast: vi.fn(),
+    showToast,
     recordEdit: vi.fn(async () => {}),
     setRefreshKey: vi.fn(),
   });
 }
 
-async function mountTestFileManager(projectId = "project-a") {
+async function mountTestFileManager(projectId = "project-a", showToast = vi.fn()) {
   const captured: { manager: ReturnType<typeof useFileManager> | null } = { manager: null };
   function Probe() {
-    captured.manager = useTestFileManager(projectId);
+    captured.manager = useTestFileManager(projectId, showToast);
     return null;
   }
   const root = createRoot(document.createElement("div"));
@@ -237,3 +237,50 @@ describe("useFileManager project ownership", () => {
     await act(async () => root.unmount());
   });
 });
+
+describe("useFileManager uploads", () => {
+  afterEach(() => vi.unstubAllGlobals());
+
+  async function uploadClip(response: Record<string, unknown>) {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async () =>
+        Response.json(
+          { ok: true, files: [], skipped: [], invalid: [], ...response },
+          { status: 201 },
+        ),
+      ),
+    );
+    const showToast = vi.fn();
+    const { manager, root } = await mountTestFileManager("project-a", showToast);
+    const added = await act(() => manager.uploadProjectFiles([new File(["x"], "clip.mp4")]));
+    await act(async () => root.unmount());
+    return { added, showToast };
+  }
+
+  it("says which uploads were added without a media check, and why", async () => {
+    const reason =
+      "not checked: ffprobe was not found. Install FFmpeg or set HYPERFRAMES_FFPROBE_PATH.";
+    const { added, showToast } = await uploadClip({
+      files: ["clip.mp4"],
+      unchecked: [{ name: "clip.mp4", reason }],
+    });
+
+    expect(added).toEqual(["clip.mp4"]);
+    expect(showToast).toHaveBeenCalledWith(`Added clip.mp4, ${reason}`, "info");
+  });
+
+  it("says why each upload was not added", async () => {
+    const { added, showToast } = await uploadClip({
+      invalid: [
+        { name: "clip.mp4", reason: "no supported video stream found" },
+        { name: "song.mp3", reason: "no supported audio stream found" },
+      ],
+    });
+
+    expect(added).toEqual([]);
+    expect(showToast).toHaveBeenCalledWith(
+      "Not added: clip.mp4 (no supported video stream found), song.mp3 (no supported audio stream found)",
+    );
+  });
+});

package/src/hooks/useFileManager.ts

@@ -4,6 +4,7 @@ import { FONT_EXT, isMediaFile } from "../utils/mediaTypes";
 import { fontFamilyFromAssetPath, type ImportedFontAsset } from "../components/editor/fontAssets";
 import { findTagByTarget, type PatchTarget } from "../utils/sourcePatcher";
 import { StudioFileConflictError } from "../utils/studioSaveDiagnostics";
+import { serializeStudioFileMutation } from "../utils/studioFileMutationCoordinator";
 import { useFileTree } from "./useFileTree";
 import { useEditorSave } from "./useEditorSave";
 import { useProjectFileWriter } from "./useProjectFileWriter";
@@ -98,16 +99,18 @@ export function useFileManager({
 
   const overwriteExternalConflict = useCallback(
     async (conflict: StudioFileConflictError) => {
-      if (conflict.currentContent != null) {
-        await writeProjectFile(
-          conflict.filePath,
-          conflict.attemptedContent,
-          conflict.currentContent,
-        );
-      } else {
-        fileVersions.set(conflict.filePath, conflict.currentVersion);
-        await writeProjectFile(conflict.filePath, conflict.attemptedContent);
-      }
+      await serializeStudioFileMutation(writeProjectFile, conflict.filePath, async () => {
+        if (conflict.currentContent != null) {
+          await writeProjectFile(
+            conflict.filePath,
+            conflict.attemptedContent,
+            conflict.currentContent,
+          );
+        } else {
+          fileVersions.set(conflict.filePath, conflict.currentVersion);
+          await writeProjectFile(conflict.filePath, conflict.attemptedContent);
+        }
+      });
       updateEditingFileContent(conflict.filePath, conflict.attemptedContent);
     },
     [fileVersions, updateEditingFileContent, writeProjectFile],
@@ -207,8 +210,14 @@ export function useFileManager({
             showToast(`Skipped (too large): ${data.skipped.join(", ")}`);
           }
           if (data.invalid?.length) {
-            const names = data.invalid.map((entry: { name: string }) => entry.name).join(", ");
-            showToast(`Unsupported media skipped: ${names}`);
+            const why = data.invalid
+              .map((entry: { name: string; reason: string }) => `${entry.name} (${entry.reason})`)
+              .join(", ");
+            showToast(`Not added: ${why}`);
+          }
+          if (data.unchecked?.length) {
+            const names = data.unchecked.map((entry: { name: string }) => entry.name).join(", ");
+            showToast(`Added ${names}, ${data.unchecked[0].reason}`, "info");
           }
           await refreshFileTree();
           setRefreshKey((k) => k + 1);

package/src/hooks/useGroupCommits.ts

@@ -1,8 +1,7 @@
 import { buildProjectApiPath } from "../utils/projectRouting";
 import { useCallback } from "react";
 import {
-  readProjectFileContent,
-  saveProjectFilesWithHistory,
+  saveServerRewriteWithHistory,
   type DomEditCommitBaseParams,
 } from "../utils/studioFileHistory";
 import {
@@ -125,36 +124,36 @@ async function commitStructuralMutation(
     | "reloadPreview"
   >,
 ): Promise<{ content?: string; groupId?: string }> {
-  const originalContent = await readProjectFileContent(pid, targetPath);
-
-  const mutateResponse = await fetch(
-    buildProjectApiPath(pid, `/file-mutations/${route}/${encodeURIComponent(targetPath)}`),
-    {
-      method: "POST",
-      headers: { "Content-Type": "application/json", ...studioWriteHeaders() },
-      body: JSON.stringify(body),
-    },
-  );
-  if (!mutateResponse.ok) {
-    const errBody = (await mutateResponse.json().catch(() => null)) as { error?: string } | null;
-    throw new Error(errBody?.error ?? `Failed to ${label.toLowerCase()} in ${targetPath}`);
-  }
-  const mutateData = (await mutateResponse.json()) as { content?: string; groupId?: string };
-  const patchedContent =
-    typeof mutateData.content === "string" ? mutateData.content : originalContent;
-
-  await saveProjectFilesWithHistory({
+  let result: { content?: string; groupId?: string } = {};
+  await saveServerRewriteWithHistory({
     projectId: pid,
+    path: targetPath,
     label,
-    files: { [targetPath]: patchedContent },
-    readFile: async () => originalContent,
     writeFile: deps.writeProjectFile,
     recordEdit: deps.editHistory.recordEdit,
+    rewrite: async (originalContent) => {
+      const mutateResponse = await fetch(
+        buildProjectApiPath(pid, `/file-mutations/${route}/${encodeURIComponent(targetPath)}`),
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json", ...studioWriteHeaders() },
+          body: JSON.stringify(body),
+        },
+      );
+      if (!mutateResponse.ok) {
+        const errBody = (await mutateResponse.json().catch(() => null)) as {
+          error?: string;
+        } | null;
+        throw new Error(errBody?.error ?? `Failed to ${label.toLowerCase()} in ${targetPath}`);
+      }
+      result = (await mutateResponse.json()) as { content?: string; groupId?: string };
+      return { disk: typeof result.content === "string" ? result.content : originalContent };
+    },
   });
   deps.clearDomSelection();
   deps.forceReloadSdkSession?.();
   deps.reloadPreview();
-  return mutateData;
+  return result;
 }
 
 export function useGroupCommits(params: UseGroupCommitsParams) {

package/src/hooks/useGsapAnimationOps.ts

@@ -1,4 +1,8 @@
 import { useCallback } from "react";
+import {
+  serializeStudioFileMutation,
+  type StudioProjectFileWriter,
+} from "../utils/studioFileMutationCoordinator";
 import type { Composition } from "@hyperframes/sdk";
 import type { DomEditSelection } from "../components/editor/domEditingTypes";
 import { roundTo3 } from "../utils/rounding";
@@ -27,6 +31,7 @@ interface GsapAnimationOpsParams extends SdkAnimationDeps {
   commitMutation: CommitMutation;
   commitMutationSafely: SafeGsapCommitMutation;
   showToast: (message: string, tone?: "error" | "info") => void;
+  writeProjectFile?: StudioProjectFileWriter;
 }
 
 export function useGsapAnimationOps({
@@ -37,6 +42,7 @@ export function useGsapAnimationOps({
   showToast,
   sdkSession,
   sdkDeps,
+  writeProjectFile,
 }: GsapAnimationOpsParams) {
   const updateGsapMeta = useCallback(
     async (
@@ -122,13 +128,17 @@ export function useGsapAnimationOps({
         const pid = projectIdRef.current;
         const targetPath = selection.sourceFile || activeCompPath || "index.html";
         if (!pid) return;
-        const assigned = await assignGsapTargetAutoIdIfNeeded({
-          projectId: pid,
-          targetPath,
-          selection,
-          autoId,
-          showToast,
-        });
+        const assign = () =>
+          assignGsapTargetAutoIdIfNeeded({
+            projectId: pid,
+            targetPath,
+            selection,
+            autoId,
+            showToast,
+          });
+        const assigned = await (writeProjectFile
+          ? serializeStudioFileMutation(writeProjectFile, targetPath, assign)
+          : assign());
         if (!assigned) return;
       }
 
@@ -181,7 +191,15 @@ export function useGsapAnimationOps({
         { label: `Add GSAP ${method} animation`, softReload: true },
       );
     },
-    [activeCompPath, commitMutation, projectIdRef, showToast, sdkSession, sdkDeps],
+    [
+      activeCompPath,
+      commitMutation,
+      projectIdRef,
+      showToast,
+      sdkSession,
+      sdkDeps,
+      writeProjectFile,
+    ],
   );
 
   type KeyframeEntry = {

package/src/hooks/useGsapScriptCommits.ts

@@ -523,6 +523,7 @@ export function useGsapScriptCommits({ projectIdRef, activeCompPath, previewIfra
     showToast,
     sdkSession,
     sdkDeps,
+    writeProjectFile,
   });
   const keyframeOps = useGsapKeyframeOps({
     activeCompPath,

package/src/hooks/useLintModal.test.tsx

@@ -69,6 +69,21 @@ describe("useLintModal hasLintError", () => {
   });
 });
 
+describe("useLintModal lintFindingCount", () => {
+  it("counts findings, not files, with the result open and after it closes", async () => {
+    const findings = ["a", "b", "c"].map((message) => ({
+      severity: "warning",
+      message,
+      file: "index.html",
+    }));
+    await mountWithLint(async () => ({ json: async () => ({ findings }) }));
+    expect(latest?.lintFindingCount).toBe(3);
+    act(() => latest?.closeLintModal());
+    expect(latest?.findingsByFile.size).toBe(1);
+    expect(latest?.lintFindingCount).toBe(3);
+  });
+});
+
 describe("useLintModal background lint", () => {
   it("waits for the live preview to boot before asking the server to lint", async () => {
     usePlayerStore.setState({ previewBooted: false });

package/src/hooks/useLintModal.ts

@@ -98,8 +98,10 @@ export function useLintModal(projectId: string | null, refreshKey?: number) {
 
   const findingsByElement = useMemo(() => groupFindings((f) => f.elementId), [groupFindings]);
   const findingsByFile = useMemo(() => groupFindings((f) => f.file), [groupFindings]);
-  // Reads the list the badge count reads: the manual result when present, else the background one.
-  const hasLintError = (lintModal ?? backgroundFindings).some((f) => f.severity === "error");
+  // The badge counts findings, not files: the manual result when present, else the background one.
+  const badgeFindings = lintModal ?? backgroundFindings;
+  const lintFindingCount = badgeFindings.length;
+  const hasLintError = badgeFindings.some((f) => f.severity === "error");
 
   // Sync lint findings directly to the player store — eliminates the
   // mirroring useEffect that was previously in App.tsx.
@@ -115,6 +117,7 @@ export function useLintModal(projectId: string | null, refreshKey?: number) {
     backgroundFindings,
     findingsByElement,
     findingsByFile,
+    lintFindingCount,
     hasLintError,
   };
 }

package/src/hooks/useProjectCompositionVariables.ts

@@ -51,7 +51,7 @@ async function readGroup(
  * full parse, so large projects don't pay N openComposition calls.
  */
 export function useProjectCompositionVariables(
-  fileTree: string[],
+  compositionPaths: string[],
   excludePath: string | null,
   readProjectFile: (path: string) => Promise<string>,
   refreshKey: unknown,
@@ -60,7 +60,7 @@ export function useProjectCompositionVariables(
 
   useEffect(() => {
     let cancelled = false;
-    const htmlFiles = fileTree.filter((p) => p.endsWith(".html") && p !== excludePath);
+    const htmlFiles = compositionPaths.filter((p) => p !== excludePath);
 
     void (async () => {
       const out: CompositionVariableGroup[] = [];
@@ -75,7 +75,7 @@ export function useProjectCompositionVariables(
       cancelled = true;
     };
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [fileTree, excludePath, readProjectFile, refreshKey]);
+  }, [compositionPaths, excludePath, readProjectFile, refreshKey]);
 
   return groups;
 }

package/src/hooks/useThumbnailStripSize.test.tsx

@@ -0,0 +1,47 @@
+// @vitest-environment happy-dom
+import { act } from "react";
+import { createRoot } from "react-dom/client";
+import { expect, it } from "vitest";
+import { MockResizeObserver, reportResize } from "./resizeObserverTestUtils";
+import { useThumbnailStripSize } from "./useThumbnailStripSize";
+
+Reflect.set(globalThis, "IS_REACT_ACT_ENVIRONMENT", true);
+
+it("does not re-render the strip when the observer reports the size it already holds", () => {
+  const originalResizeObserver = globalThis.ResizeObserver;
+  globalThis.ResizeObserver = MockResizeObserver as unknown as typeof ResizeObserver;
+  const host = document.createElement("div");
+  document.body.append(host);
+  Object.defineProperty(host, "clientWidth", { configurable: true, value: 300 });
+  Object.defineProperty(host, "clientHeight", { configurable: true, value: 40 });
+  const root = createRoot(host);
+  let stripRenders = 0;
+  function Strip({ label }: { label: string }) {
+    stripRenders += 1;
+    return label;
+  }
+  function Harness() {
+    const [size, ref] = useThumbnailStripSize();
+    return (
+      <div ref={ref}>
+        <Strip label={`${size.width}x${size.height}`} />
+      </div>
+    );
+  }
+  try {
+    act(() => root.render(<Harness />));
+    expect(host.textContent).toBe("300x40");
+    const settled = stripRenders;
+
+    act(() => reportResize(300, 40));
+    expect(stripRenders).toBe(settled);
+
+    act(() => reportResize(320, 40));
+    expect(stripRenders).toBe(settled + 1);
+    expect(host.textContent).toBe("320x40");
+  } finally {
+    act(() => root.unmount());
+    host.remove();
+    globalThis.ResizeObserver = originalResizeObserver;
+  }
+});

package/src/hooks/useThumbnailStripSize.ts

@@ -0,0 +1,31 @@
+import { useCallback, useRef, useState } from "react";
+import { useMountEffect } from "./useMountEffect";
+
+interface StripSize {
+  width: number;
+  height: number;
+}
+
+const resize = (width: number, height: number) => (prev: StripSize) =>
+  prev.width === width && prev.height === height ? prev : { width, height };
+
+/** Size of the thumbnail's parent, kept current by a ResizeObserver; 0x0 until measured. */
+export function useThumbnailStripSize() {
+  const [size, setSize] = useState<StripSize>({ width: 0, height: 0 });
+  const observerRef = useRef<ResizeObserver | null>(null);
+
+  const ref = useCallback((element: HTMLDivElement | null) => {
+    observerRef.current?.disconnect();
+    if (!element) return;
+    const target = element.parentElement ?? element;
+    setSize(resize(target.clientWidth, target.clientHeight));
+    observerRef.current = new ResizeObserver(([entry]) =>
+      setSize(resize(entry.contentRect.width, entry.contentRect.height)),
+    );
+    observerRef.current.observe(target);
+  }, []);
+
+  useMountEffect(() => () => observerRef.current?.disconnect());
+
+  return [size, ref] as const;
+}

package/src/hooks/useTimelineAssetDropOps.ts

@@ -109,8 +109,6 @@ export function useTimelineAssetDropOps({
       }
 
       try {
-        const originalContent = await readFileContent(pid, targetPath);
-
         const normalizedStart = Number(formatTimelineAttributeNumber(placement.start));
         const duration =
           Number.isFinite(durationOverride) && durationOverride != null && durationOverride > 0
@@ -120,7 +118,6 @@ export function useTimelineAssetDropOps({
         // A video with an audio stream lands audible; the mixer only hears a
         // <video> marked data-has-audio, and a muted drop was losing the sound.
         const hasAudio = await resolveDroppedAssetHasAudio(pid, assetPath, kind);
-        const newId = buildTimelineAssetId(assetPath, collectHtmlIds(originalContent));
         const resolvedAssetSrc = resolveTimelineAssetSrc(targetPath, assetPath);
 
         const resolvedTargetPath = targetPath || "index.html";
@@ -129,45 +126,51 @@ export function useTimelineAssetDropOps({
         );
         const newElementZIndex = Math.max(1, relevantElements.length + 1);
 
-        const { source: sourceWithRoom, track } = resolveDropTrack({
-          source: originalContent,
-          // insertRow counts the rows the timeline shows, so plan against those.
-          elements: relevantElements,
-          placement,
-          dropped: {
-            id: newId,
-            tag: kind === "image" ? "img" : kind,
-            start: normalizedStart,
-            duration: normalizedDuration,
-          },
-        });
-        const patchedContent = extendRootDurationInSource(
-          insertTimelineAssetIntoSource(
-            sourceWithRoom,
-            buildTimelineAssetInsertHtml({
+        let newId = "";
+        let track = 0;
+        const insertAsset = (originalContent: string) => {
+          newId = buildTimelineAssetId(assetPath, collectHtmlIds(originalContent));
+          const resolved = resolveDropTrack({
+            source: originalContent,
+            // insertRow counts the rows the timeline shows, so plan against those.
+            elements: relevantElements,
+            placement,
+            dropped: {
               id: newId,
-              hfId: `hf-${generateId()}`,
-              assetPath: resolvedAssetSrc,
-              kind,
+              tag: kind === "image" ? "img" : kind,
               start: normalizedStart,
               duration: normalizedDuration,
-              track,
-              zIndex: newElementZIndex,
-              hasAudio,
-              geometry: fitTimelineAssetGeometry(
-                null,
-                resolveTimelineAssetCompositionSize(originalContent),
-              ),
-            }),
-          ),
-          normalizedStart + normalizedDuration,
-        );
+            },
+          });
+          track = resolved.track;
+          return extendRootDurationInSource(
+            insertTimelineAssetIntoSource(
+              resolved.source,
+              buildTimelineAssetInsertHtml({
+                id: newId,
+                hfId: `hf-${generateId()}`,
+                assetPath: resolvedAssetSrc,
+                kind,
+                start: normalizedStart,
+                duration: normalizedDuration,
+                track,
+                zIndex: newElementZIndex,
+                hasAudio,
+                geometry: fitTimelineAssetGeometry(
+                  null,
+                  resolveTimelineAssetCompositionSize(originalContent),
+                ),
+              }),
+            ),
+            normalizedStart + normalizedDuration,
+          );
+        };
 
         await saveProjectFilesWithHistory({
           projectId: pid,
           label: "Add timeline asset",
-          files: { [targetPath]: patchedContent },
-          readFile: async () => originalContent,
+          files: { [targetPath]: insertAsset },
+          readFile: (path) => readFileContent(pid, path),
           writeFile: writeProjectFile,
           recordEdit,
         });