Skip to content

armgit / hypit

Public Imported from GitHub
0

Clone any viral video with AI agents. Not just a script, the whole workflow: swap the face, the words, the B-roll, ship 100 variants in one command, and get your 100M views.

feat: enable explicit timing edits in studio

kashorinf1891ea55595
diff --git a/packages/studio-adapter/src/index.ts b/packages/studio-adapter/src/index.ts
index b5df3683..bb7fcbce 100644
--- a/packages/studio-adapter/src/index.ts
+++ b/packages/studio-adapter/src/index.ts
@@ -95,7 +95,7 @@ export type StudioEditHandle = {
readonly id: string;
readonly operation: StudioEditOperation;
readonly enabled: boolean;
- readonly source?: StudioParameter["source"];
+ readonly sources?: readonly StudioParameter["source"][];
readonly disabledReason?: string;
};
diff --git a/packages/studio/src/parameters.ts b/packages/studio/src/parameters.ts
index 073f7347..32e4e171 100644
--- a/packages/studio/src/parameters.ts
+++ b/packages/studio/src/parameters.ts
@@ -5,6 +5,7 @@ import type {
StudioParameterDeclaration,
StudioEntityDraft,
StudioPlacement,
+ StudioEditHandle,
} from "@hypit/studio-adapter";
import { parseSvs } from "@hypit/svs";
@@ -197,3 +198,32 @@ export function parametersForDraft(input: {
});
return [...direct, ...recipes];
}
+
+const ABSOLUTE_DURATION = /^\s*\d+(?:\.\d+)?(?:f|ms|s)\s*$/u;
+
+/**
+ * Timing handles are deliberately narrower than timing parameters. A literal
+ * absolute start/end can be rewritten as frames without changing its semantic
+ * source; a Selection/Moment expression cannot be moved from a downstream
+ * rectangle. `at + for` has one legal edge: changing `for` changes only its end.
+ */
+export function timingEditHandles(parameters: readonly StudioParameter[]): readonly StudioEditHandle[] {
+ const byName = new Map(parameters.map((parameter) => [parameter.id.slice(parameter.id.lastIndexOf(":") + 1), parameter]));
+ const start = byName.get("start");
+ const end = byName.get("end");
+ const at = byName.get("at");
+ const duration = byName.get("for");
+ const absolute = (parameter: StudioParameter | undefined): parameter is StudioParameter =>
+ parameter !== undefined && parameter.writable && ABSOLUTE_DURATION.test(parameter.value);
+ if (absolute(start) && absolute(end)) {
+ return [
+ { id: "move", operation: "move", enabled: true, sources: [start.source, end.source] },
+ { id: "trim-start", operation: "trim-start", enabled: true, sources: [start.source] },
+ { id: "trim-end", operation: "trim-end", enabled: true, sources: [end.source] },
+ ];
+ }
+ if (at !== undefined && !at.writable && absolute(duration)) {
+ return [{ id: "trim-end", operation: "trim-end", enabled: true, sources: [duration.source] }];
+ }
+ return [];
+}
diff --git a/packages/studio/src/snapshot.ts b/packages/studio/src/snapshot.ts
index f98c5080..e9f2c2bd 100644
--- a/packages/studio/src/snapshot.ts
+++ b/packages/studio/src/snapshot.ts
@@ -22,7 +22,7 @@ import {
} from "./studio-registry.js";
import type { StudioAdapterRegistry } from "./studio-registry.js";
import type { StudioEntityDraft } from "./studio-registry.js";
-import { parametersForDraft } from "./parameters.js";
+import { parametersForDraft, timingEditHandles } from "./parameters.js";
import type { StudioSourceFile } from "./parameters.js";
type Present = {
@@ -346,7 +346,10 @@ export function snapshot(registry: StudioAdapterRegistry, built: Preview, input:
declarations: registry.parameterDeclarations(item, placement, draft.lane),
placements: built.source.observations.placements,
});
- return parameters.length === 0 ? draft : { ...draft, parameters };
+ const editHandles = timingEditHandles(parameters);
+ return parameters.length === 0 && editHandles.length === 0
+ ? draft
+ : { ...draft, parameters, ...(editHandles.length === 0 ? {} : { editHandles }) };
});
const clips: Clip[] = drafts
.filter((draft) => draft.lane === undefined)
diff --git a/packages/studio/src/style.css b/packages/studio/src/style.css
index 0948fa91..4a4bf771 100644
--- a/packages/studio/src/style.css
+++ b/packages/studio/src/style.css
@@ -771,6 +771,7 @@ button:focus-visible, textarea:focus-visible {
box-shadow: none;
color: #fff;
}
+.clip.editing { box-shadow: 0 0 0 1px #fff; }
.clip:focus-visible { outline: 0; }
.clip-selection {
position: absolute;
diff --git a/packages/studio/src/ui/main.ts b/packages/studio/src/ui/main.ts
index d90dd64f..956265f4 100644
--- a/packages/studio/src/ui/main.ts
+++ b/packages/studio/src/ui/main.ts
@@ -6,6 +6,7 @@ import type { Highlight } from "./code.js";
import { intentAtOffset, intentTones, liveRanges, spanAtOffset } from "./markers.js";
import { clipAtOffset, createStore } from "./selection.js";
import { createStage } from "./stage.js";
+import { writeSourceTransaction } from "./writeback.js";
import { createTimeline } from "./timeline.js";
import "../style.css";
@@ -97,6 +98,12 @@ const project = app.querySelector<HTMLElement>("[data-project]")!;
const status = app.querySelector<HTMLElement>("[data-status]")!;
const failureView = app.querySelector<HTMLElement>("[data-failure]")!;
+timeline.element.addEventListener("studio:write", (event) => {
+ const state = (event as CustomEvent<{ readonly state?: string }>).detail.state;
+ status.className = state === "error" ? "status error" : state === "saved" ? "status saved" : "status saving";
+ status.textContent = state === "error" ? "Save failed" : state === "saved" ? "Saved" : "Saving";
+});
+
// Program-level facts never change while a Source is being read, so they live in
// the header rather than taking a panel that would have to sit over something.
function renderMeta(snapshot: StudioSnapshot): void {
@@ -187,20 +194,12 @@ async function writeParameter(parameter: Clip["parameters"][number], replacement
status.textContent = parameterWriteState;
status.className = "status saving";
try {
- const response = await fetch("/__studio/transaction", {
- method: "POST",
- headers: { "content-type": "application/json" },
- body: JSON.stringify({
- revision: state.snapshot.revision,
- patches: [{
- path: parameter.source.path,
- range: parameter.source.range,
- replacement,
- preimage: parameter.source.preimage,
- }],
- }),
- });
- if (!response.ok) throw new Error(await response.text());
+ await writeSourceTransaction(state.snapshot.revision, [{
+ path: parameter.source.path,
+ range: parameter.source.range,
+ replacement,
+ preimage: parameter.source.preimage,
+ }]);
parameterWriteState = "Saved";
status.textContent = parameterWriteState;
status.className = "status saved";
diff --git a/packages/studio/src/ui/timeline.ts b/packages/studio/src/ui/timeline.ts
index 8b6d6d93..a2c3d9df 100644
--- a/packages/studio/src/ui/timeline.ts
+++ b/packages/studio/src/ui/timeline.ts
@@ -6,6 +6,7 @@ import { icon, setIcon } from "./icons.js";
import { mountMaterialPreview } from "./material-preview.js";
import type { State, Store } from "./selection.js";
import { createZoom } from "./zoom.js";
+import { writeSourceTransaction } from "./writeback.js";
export type Timeline = {
readonly element: HTMLElement;
@@ -189,6 +190,14 @@ export function createTimeline(store: Store): Timeline {
let pointerArmed = false;
let pointerDownX = 0;
let pointerDownOnItem = false;
+ let activeEdit: {
+ readonly clip: StudioSnapshot["tracks"][number]["clips"][number];
+ readonly operation: "move" | "trim-start" | "trim-end";
+ readonly sources: readonly StudioSnapshot["tracks"][number]["clips"][number]["parameters"][number]["source"][];
+ readonly startFrame: number;
+ readonly pointerId: number;
+ readonly node: HTMLElement;
+ } | undefined;
lanes.addEventListener("pointerdown", (event) => {
pointerDownOnItem = (event.target as HTMLElement).closest(
".clip, .semantic-segment, .semantic-word, .semantic-selection, .semantic-moment",
@@ -213,13 +222,43 @@ export function createTimeline(store: Store): Timeline {
hover.style.transform = `translate3d(${at}px,0,0)`;
hoverTime.textContent = state === undefined ? "" : frameTimecode(state.snapshot, frame);
hover.classList.add("visible");
+ if (activeEdit !== undefined) return;
if (!pointerArmed || event.buttons !== 1) return;
if (pointerDownOnItem && Math.abs(event.clientX - pointerDownX) < 3) return;
store.seek(frame, "timeline");
});
const finishPointer = (event: PointerEvent): void => {
+ const edit = activeEdit;
+ activeEdit = undefined;
+ edit?.node.classList.remove("editing");
pointerArmed = false;
try { lanes.releasePointerCapture(event.pointerId); } catch { /* already released */ }
+ if (edit === undefined || state === undefined || event.type === "pointercancel") return;
+ const nextFrame = frameAt(event.clientX);
+ const rawDelta = nextFrame - edit.startFrame;
+ const delta = Math.max(
+ -edit.clip.startFrame,
+ Math.min(state.snapshot.space.frameCount - edit.clip.endFrameExclusive, rawDelta),
+ );
+ const replacement = (frame: number): string => `${Math.max(0, Math.round(frame))}f`;
+ const patches = edit.operation === "move"
+ ? [
+ { ...edit.sources[0]!, replacement: replacement(edit.clip.startFrame + delta) },
+ { ...edit.sources[1]!, replacement: replacement(edit.clip.endFrameExclusive + delta) },
+ ]
+ : edit.operation === "trim-start"
+ ? [{ ...edit.sources[0]!, replacement: replacement(Math.min(edit.clip.endFrameExclusive - 1, nextFrame)) }]
+ : [{ ...edit.sources[0]!, replacement: replacement(Math.max(edit.clip.startFrame + 1, nextFrame)) }];
+ if (patches.every((patch) => patch.replacement === patch.preimage)) return;
+ element.dispatchEvent(new CustomEvent("studio:write", { detail: { state: "saving" } }));
+ void writeSourceTransaction(state.snapshot.revision, patches).then(() => {
+ element.dispatchEvent(new CustomEvent("studio:write", { detail: { state: "saved" } }));
+ }).catch((error: unknown) => {
+ // The next snapshot/error event is the source of truth; a failed gesture
+ // must never be represented by a local optimistic rectangle.
+ console.error(error);
+ element.dispatchEvent(new CustomEvent("studio:write", { detail: { state: "error" } }));
+ });
};
lanes.addEventListener("pointerup", finishPointer);
lanes.addEventListener("pointercancel", finishPointer);
@@ -644,7 +683,32 @@ export function createTimeline(store: Store): Timeline {
node.querySelector(".clip-name")!.textContent = clipHeaderLabel(clip);
node.querySelector(".clip-meta")!.textContent = `${((clip.endFrameExclusive - clip.startFrame) / fps(snapshot)).toFixed(2)}s`;
node.querySelector(".clip-content-text")!.textContent = clipBodyLabel(clip);
- node.addEventListener("pointerdown", () => {
+ node.addEventListener("pointerdown", (event) => {
+ const rect = node.getBoundingClientRect();
+ const edge = Math.min(8, Math.max(4, rect.width / 3));
+ const nearStart = event.clientX - rect.left <= edge;
+ const nearEnd = rect.right - event.clientX <= edge;
+ const handle = clip.editHandles.find((candidate) =>
+ candidate.enabled
+ && ((candidate.operation === "trim-start" && nearStart)
+ || (candidate.operation === "trim-end" && nearEnd)
+ || (candidate.operation === "move" && !nearStart && !nearEnd)));
+ if (handle !== undefined && handle.sources !== undefined
+ && (handle.operation === "move" || handle.operation === "trim-start" || handle.operation === "trim-end")) {
+ event.stopPropagation();
+ activeEdit = {
+ clip,
+ operation: handle.operation,
+ sources: handle.sources,
+ startFrame: frameAt(event.clientX),
+ pointerId: event.pointerId,
+ node,
+ };
+ node.classList.add("editing");
+ try { lanes.setPointerCapture(event.pointerId); } catch { /* local pointer */ }
+ store.select(clip.id, "timeline");
+ return;
+ }
if (clip.interaction.select) store.select(clip.id, "timeline");
});
node.addEventListener("dblclick", () => store.seek(clip.startFrame, "timeline"));
diff --git a/packages/studio/src/ui/writeback.ts b/packages/studio/src/ui/writeback.ts
new file mode 100644
index 00000000..0b1897f2
--- /dev/null
+++ b/packages/studio/src/ui/writeback.ts
@@ -0,0 +1,17 @@
+import type { Range } from "../shared.js";
+
+export type SourcePatch = {
+ readonly path: string;
+ readonly range: Range;
+ readonly replacement: string;
+ readonly preimage: string;
+};
+
+export async function writeSourceTransaction(revision: number, patches: readonly SourcePatch[]): Promise<void> {
+ const response = await fetch("/__studio/transaction", {
+ method: "POST",
+ headers: { "content-type": "application/json" },
+ body: JSON.stringify({ revision, patches }),
+ });
+ if (!response.ok) throw new Error(await response.text());
+}