@hyperframes/studio 0.7.61 → 0.7.62

package/src/utils/timelineCompositionInsert.ts

@@ -0,0 +1,90 @@
+import { createStudioSaveHttpError } from "./studioSaveDiagnostics";
+import { serializeStudioFileMutation } from "./studioFileMutationCoordinator";
+import type { RecordEditInput } from "./studioFileHistory";
+import { buildProjectApiPath } from "./projectRouting";
+
+interface TimelineCompositionInsertionResult {
+  path: string;
+  hostId: string;
+  before: string;
+  after: string;
+  version: string;
+}
+
+async function insertTimelineComposition(input: {
+  projectId: string;
+  targetPath: string;
+  sourcePath: string;
+  start: number;
+  track: number;
+}): Promise<TimelineCompositionInsertionResult> {
+  const current = await fetch(
+    buildProjectApiPath(input.projectId, `/files/${encodeURIComponent(input.targetPath)}`),
+  );
+  if (!current.ok) {
+    throw await createStudioSaveHttpError(current, `Failed to read ${input.targetPath}`);
+  }
+  const snapshot = (await current.json()) as { version?: string };
+  if (typeof snapshot.version !== "string") throw new Error("Missing composition file version");
+
+  const response = await fetch(
+    buildProjectApiPath(
+      input.projectId,
+      `/file-mutations/insert-composition/${encodeURIComponent(input.targetPath)}`,
+    ),
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        sourcePath: input.sourcePath,
+        start: input.start,
+        track: input.track,
+        expectedVersion: snapshot.version,
+      }),
+    },
+  );
+  if (!response.ok) {
+    throw await createStudioSaveHttpError(response, "Failed to add composition to timeline");
+  }
+  return (await response.json()) as TimelineCompositionInsertionResult;
+}
+
+export async function commitTimelineCompositionInsertion(input: {
+  projectId: string;
+  targetPath: string;
+  sourcePath: string;
+  start: number;
+  track: number;
+  writeFile: (path: string, content: string, expectedContent?: string) => Promise<void>;
+  recordEdit: (entry: RecordEditInput) => Promise<void>;
+  observeVersion?: (path: string, version: string | null) => void;
+  selectHost: (key: string) => void;
+  resync?: () => void;
+  refresh: () => void;
+}): Promise<void> {
+  await serializeStudioFileMutation(input.writeFile, input.targetPath, async () => {
+    const result = await insertTimelineComposition(input);
+    input.observeVersion?.(input.targetPath, result.version);
+    try {
+      await input.recordEdit({
+        label: "Add composition to timeline",
+        kind: "timeline",
+        files: { [input.targetPath]: { before: result.before, after: result.after } },
+      });
+    } catch (error) {
+      await input.writeFile(input.targetPath, result.before, result.after);
+      throw error;
+    }
+    input.selectHost(`${input.targetPath}#${result.hostId}`);
+    try {
+      input.resync?.();
+    } catch (error) {
+      console.error("[Studio] Composition insertion committed but preview resync failed", error);
+    }
+    try {
+      input.refresh();
+    } catch (error) {
+      console.error("[Studio] Composition insertion committed but refresh failed", error);
+    }
+  });
+}

package/src/utils/timelineElementSplit.test.ts

@@ -14,6 +14,7 @@ function element(overrides: Partial<TimelineElement> = {}): TimelineElement {
     start: 1,
     duration: 4,
     track: 0,
+    domId: "el-1",
     ...overrides,
   };
 }
@@ -77,10 +78,21 @@ describe("canSplitElementAt", () => {
     ).toBe(false);
   });
 
-  it("rejects locked, implicit and sub-composition elements", () => {
+  it("rejects locked and implicit elements while allowing identified compositions", () => {
     expect(canSplitElementAt(element({ timelineLocked: true }), 3)).toBe(false);
     expect(canSplitElementAt(element({ timingSource: "implicit" }), 3)).toBe(false);
-    expect(canSplitElementAt(element({ compositionSrc: "child.html" }), 3)).toBe(false);
+    expect(
+      canSplitElementAt(
+        element({ kind: "composition", compositionSrc: "child.html", playbackRate: 2 }),
+        3,
+      ),
+    ).toBe(true);
+  });
+
+  it("rejects missing identity and invalid playback rates", () => {
+    expect(canSplitElementAt(element({ domId: undefined }), 3)).toBe(false);
+    expect(canSplitElementAt(element({ playbackRate: 0 }), 3)).toBe(false);
+    expect(canSplitElementAt(element({ playbackRate: Number.NaN }), 3)).toBe(false);
   });
 });
 

package/src/utils/timelineElementSplit.ts

@@ -22,10 +22,14 @@ export function isSplitTimeWithinBounds(
 }
 
 export function canSplitElement(el: TimelineElement): boolean {
+  const hasStableIdentity = Boolean(el.hfId || el.domId || el.selector);
+  const hasValidRate =
+    el.playbackRate == null || (Number.isFinite(el.playbackRate) && el.playbackRate > 0);
   return (
     !el.timelineLocked &&
     el.timingSource !== "implicit" &&
-    !el.compositionSrc &&
+    hasStableIdentity &&
+    hasValidRate &&
     !!el.duration &&
     Number.isFinite(el.duration)
   );