cozyclay 1.0.0 → 1.2.0

package/src/ardy/client.js

@@ -7,6 +7,7 @@
  * sidecar as an expected state and reports it as data — never as a thrown
  * error — so the UI can degrade to a hint instead of crashing.
  */
+import { ko, isKo } from "../locale.js";
 
 const JSON_HEADERS = { "Content-Type": "application/json" };
 
@@ -39,7 +40,7 @@ export async function checkBridge() {
 	try {
 		const res = await fetch("/ardy/health", { signal: AbortSignal.timeout(PROBE_TIMEOUT_MS) });
 		if (!res.ok) {
-			return { ok: false, reason: await reasonOf(res, `bridge unhealthy (HTTP ${res.status})`) };
+			return { ok: false, reason: await reasonOf(res, isKo ? `브리지 상태가 좋지 않아요(HTTP ${res.status})` : `bridge unhealthy (HTTP ${res.status})`) };
 		}
 		const payload = await res.json();
 		return {
@@ -49,7 +50,7 @@ export async function checkBridge() {
 			device: payload.device,
 		};
 	} catch (err) {
-		return { ok: false, reason: err?.message || "bridge unreachable" };
+		return { ok: false, reason: err?.message || ko("bridge unreachable", "브리지에 연결할 수 없어요") };
 	}
 }
 
@@ -91,7 +92,7 @@ export async function generate(body, onEvent, { signal } = {}) {
 	if (!res.ok) {
 		throw new Error(await reasonOf(res, `generate failed (HTTP ${res.status})`));
 	}
-	if (!res.body) throw new Error("generate: response has no body stream");
+	if (!res.body) throw new Error(ko("generate: response has no body stream", "생성 응답에 본문 스트림이 없어요"));
 
 	const reader = res.body.getReader();
 	const decoder = new TextDecoder();
@@ -118,7 +119,7 @@ export async function generate(body, onEvent, { signal } = {}) {
 		const terminal = applyLine(buffer.trim());
 		if (terminal) return terminal;
 	}
-	throw new Error("generate: stream ended without a done or error event");
+	throw new Error(ko("generate: stream ended without a done or error event", "완료 또는 오류 이벤트 없이 생성 스트림이 끝났어요"));
 
 	/** Parse one ndjson line; returns the done event, throws on error/bad line. */
 	function applyLine(line) {

package/src/ardy/mp4-duration.js

@@ -0,0 +1,102 @@
+const CONTAINER_BOXES = new Set(["moov", "trak", "mdia"]);
+
+function boxType(view, offset) {
+	return String.fromCharCode(
+		view.getUint8(offset + 4),
+		view.getUint8(offset + 5),
+		view.getUint8(offset + 6),
+		view.getUint8(offset + 7),
+	);
+}
+
+function walkBoxes(view, start, end, visit) {
+	let offset = start;
+	while (offset + 8 <= end) {
+		let size = view.getUint32(offset);
+		let headerSize = 8;
+		if (size === 1) {
+			if (offset + 16 > end) throw new Error("Invalid MP4 extended-size box");
+			const extendedSize = view.getBigUint64(offset + 8);
+			if (extendedSize > BigInt(Number.MAX_SAFE_INTEGER)) throw new Error("MP4 box is too large to inspect safely");
+			size = Number(extendedSize);
+			headerSize = 16;
+		} else if (size === 0) {
+			size = end - offset;
+		}
+		if (size < headerSize || offset + size > end) throw new Error("Invalid MP4 box size");
+
+		const box = { type: boxType(view, offset), start: offset, end: offset + size, payload: offset + headerSize };
+		visit(box);
+		if (CONTAINER_BOXES.has(box.type)) walkBoxes(view, box.payload, box.end, visit);
+		offset = box.end;
+	}
+	if (offset !== end) throw new Error("Invalid trailing MP4 box data");
+}
+
+function timingFields(view, box) {
+	const version = view.getUint8(box.payload);
+	const timescaleOffset = box.payload + (version === 1 ? 20 : 12);
+	const durationOffset = timescaleOffset + 4;
+	const durationBytes = version === 1 ? 8 : 4;
+	if ((version !== 0 && version !== 1) || durationOffset + durationBytes > box.end) {
+		throw new Error(`Invalid ${box.type} box`);
+	}
+	return {
+		version,
+		timescale: view.getUint32(timescaleOffset),
+		duration: version === 1 ? view.getBigUint64(durationOffset) : BigInt(view.getUint32(durationOffset)),
+		durationOffset,
+	};
+}
+
+function writeDuration(view, fields, duration) {
+	if (fields.version === 1) {
+		view.setBigUint64(fields.durationOffset, duration);
+		return;
+	}
+	if (duration > 0xffffffffn) throw new Error("Corrected mdhd duration does not fit a version 0 box");
+	view.setUint32(fields.durationOffset, Number(duration));
+}
+
+/**
+ * Repair MediaRecorder MP4 files whose mdhd duration was written in mvhd units.
+ *
+ * mvhd is the movie header and uses the movie timescale (commonly 1000), while
+ * mdhd is a media-track header and must use that track's media timescale
+ * (commonly 30000). They describe the same elapsed time with different clocks;
+ * copying the mvhd duration number into mdhd makes a 30000 Hz track read 30x
+ * too short.
+ */
+export function repairMp4MediaDurations(input) {
+	const source = input instanceof ArrayBuffer
+		? new Uint8Array(input)
+		: ArrayBuffer.isView(input)
+			? new Uint8Array(input.buffer, input.byteOffset, input.byteLength)
+			: null;
+	if (!source) throw new TypeError("repairMp4MediaDurations expects an ArrayBuffer or typed array");
+
+	const output = Uint8Array.from(source);
+	const view = new DataView(output.buffer);
+	let movie = null;
+	const mediaHeaders = [];
+	walkBoxes(view, 0, output.byteLength, (box) => {
+		if (box.type === "mvhd") movie = timingFields(view, box);
+		if (box.type === "mdhd") mediaHeaders.push(timingFields(view, box));
+	});
+	if (!movie || movie.timescale === 0) throw new Error("MP4 is missing a valid mvhd box");
+	if (mediaHeaders.length === 0) throw new Error("MP4 is missing an mdhd box");
+
+	for (const media of mediaHeaders) {
+		if (media.timescale === 0) throw new Error("MP4 contains an mdhd box with timescale 0");
+		const numerator = movie.duration * BigInt(media.timescale);
+		const correctedDuration = (numerator + BigInt(movie.timescale) / 2n) / BigInt(movie.timescale);
+		writeDuration(view, media, correctedDuration);
+	}
+	return output;
+}
+
+/** Preserve the recorded Blob's MIME type while repairing its MP4 headers. */
+export async function repairRecordedMp4(blob) {
+	if (!(blob instanceof Blob)) throw new TypeError("repairRecordedMp4 expects a Blob");
+	return new Blob([repairMp4MediaDurations(await blob.arrayBuffer())], { type: blob.type });
+}

package/src/ardy/timeline-coordinates.js

@@ -15,3 +15,14 @@ export function promptMoveStartFrame(startFrame, startClientX, clientX, laneWidt
 	const framesPerPixel = Math.max(0, displayFrameCount - 1) / Math.max(1, laneWidth);
 	return startFrame + (clientX - startClientX) * framesPerPixel;
 }
+
+/** Optional Shot blocks use their own explicit inclusive range. Gaps remain
+ * visible free-camera time instead of being inferred from the next card. */
+export function shotBlockGeometry(shots, index, frameCount, displayFrameCount = frameCount) {
+	const shot = shots[index];
+	if (!shot || frameCount < 1 || displayFrameCount < 1) return null;
+	const denominator = Math.max(1, displayFrameCount - 1);
+	const startFrame = Math.max(0, Math.min(frameCount - 1, shot.startFrame));
+	const endFrame = Math.max(startFrame, Math.min(frameCount - 1, shot.endFrame ?? startFrame));
+	return { startFrame, endFrame, startPct: startFrame / denominator, endPct: endFrame / denominator };
+}