@mengine/medeo-client 1.0.0 → 1.0.1-alpha.1

package/dist/testing.js

@@ -0,0 +1,339 @@
+import { B as bytesToBase64, N as VIDEO_DOCUMENT_SCHEMA_VERSION, o as createMirrorVideoDocumentAdapter, z as base64ToBytes } from "./document-DgffKwRw.js";
+import { LoroDoc, VersionVector, encodeFrontiers } from "loro-crdt";
+//#region src/testing/in-memory-mengine-server.ts
+/**
+* In-memory stand-in for `mengine-server`, exposed as a `fetchImpl`.
+*
+* It models the surface the client runtime uses under the Loro-native protocol
+* (Phase 5 §A1.5): snapshot, VV-diff pull (`GET .../sync?from=<vv b64>`), update
+* push with an `update_seq` ack, and an SSE `events` stream that broadcasts each
+* new update with its metadata — so multiple runtimes can converge through one
+* shared server without a real HTTP host. It is a test double, not a persistence
+* model: state lives in process and dies with it.
+*/
+var InMemoryMengineServer = class {
+	doc = new LoroDoc();
+	updates = [];
+	subscribers = /* @__PURE__ */ new Set();
+	seq = 0;
+	hasSnapshot = false;
+	/**
+	* Close every open SSE stream, simulating a network drop. Clients reconnect
+	* (a fresh `/events`) and catch up via their next sync — used to exercise
+	* disconnect recovery.
+	*/
+	dropStreams() {
+		for (const subscriber of this.subscribers) subscriber.close();
+		this.subscribers.clear();
+	}
+	fetchImpl = async (input, init) => {
+		const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+		const method = (init?.method ?? "GET").toUpperCase();
+		const path = this.parsePath(url);
+		if (path === "snapshot" && method === "GET") return this.handleSnapshot();
+		if (path.startsWith("bootstrap") && method === "POST") return this.handleBootstrap(init);
+		if (path.startsWith("sync") && method === "GET") return this.handleSync(url);
+		if (path === "updates" && method === "POST") return this.handlePush(init);
+		if (path === "events" && method === "GET") return this.handleEvents(init);
+		if (path === "audit" && method === "GET") return Response.json({ entries: this.updates.map((u) => ({
+			...u.meta,
+			update_seq: u.updateSeq
+		})) });
+		return new Response("not found", { status: 404 });
+	};
+	parsePath(url) {
+		const start = url.indexOf("/api/mengine/v1/docs/");
+		if (start < 0) return "";
+		const afterDocId = url.slice(start + 21);
+		return afterDocId.slice(afterDocId.indexOf("/") + 1);
+	}
+	version() {
+		return {
+			update_seq: this.seq,
+			server_vv: bytesToBase64(this.doc.oplogVersion().encode()),
+			frontiers: bytesToBase64(encodeFrontiers(this.doc.oplogFrontiers()))
+		};
+	}
+	handleSnapshot() {
+		if (!this.hasSnapshot) return Response.json({
+			kind: "rejected",
+			code: "not_found",
+			message: "no snapshot"
+		}, { status: 404 });
+		return Response.json({
+			snapshot: bytesToBase64(this.doc.export({ mode: "snapshot" })),
+			version: this.version()
+		});
+	}
+	async handleBootstrap(init) {
+		const body = JSON.parse(typeof init?.body === "string" ? init.body : "{}");
+		if (body.snapshot != null && !this.hasSnapshot) {
+			this.doc.import(base64ToBytes(body.snapshot));
+			this.hasSnapshot = true;
+		}
+		return this.handleSnapshot();
+	}
+	handleSync(url) {
+		const fromParam = new URL(url).searchParams.get("from");
+		const from = fromParam != null && fromParam !== "" ? VersionVector.decode(base64ToBytes(fromParam)) : void 0;
+		const update = this.doc.export({
+			mode: "update",
+			from
+		});
+		return Response.json({
+			update: bytesToBase64(update),
+			server_vv: bytesToBase64(this.doc.oplogVersion().encode())
+		});
+	}
+	async handlePush(init) {
+		const body = JSON.parse(typeof init?.body === "string" ? init.body : "{}");
+		if (body.update == null) return Response.json({
+			kind: "rejected",
+			code: "bad_request",
+			message: "no update"
+		}, { status: 400 });
+		const data = base64ToBytes(body.update);
+		const baseVV = this.doc.oplogVersion();
+		this.doc.import(data);
+		this.hasSnapshot = true;
+		this.seq += 1;
+		const meta = extractMeta(this.doc, baseVV);
+		const stored = {
+			updateSeq: this.seq,
+			data,
+			meta
+		};
+		this.updates.push(stored);
+		for (const subscriber of this.subscribers) subscriber.push(stored);
+		return Response.json({
+			kind: "ack",
+			update_seq: this.seq,
+			version: this.version()
+		});
+	}
+	handleEvents(init) {
+		const subscribers = this.subscribers;
+		const encoder = new TextEncoder();
+		const version = () => this.version();
+		let subscriber = null;
+		const stream = new ReadableStream({
+			start(controller) {
+				subscriber = {
+					push(update) {
+						const payload = JSON.stringify({
+							update_seq: update.updateSeq,
+							updates: [bytesToBase64(update.data)],
+							meta: update.meta,
+							version: version()
+						});
+						controller.enqueue(encoder.encode(`event: update\ndata: ${payload}\n\n`));
+					},
+					close() {
+						try {
+							controller.close();
+						} catch {}
+					}
+				};
+				subscribers.add(subscriber);
+			},
+			cancel() {
+				if (subscriber) subscribers.delete(subscriber);
+			}
+		});
+		const signal = init?.signal;
+		if (signal) signal.addEventListener("abort", () => {
+			if (subscriber) {
+				subscribers.delete(subscriber);
+				subscriber.close();
+			}
+		});
+		return new Response(stream, { headers: { "content-type": "text/event-stream" } });
+	}
+};
+/** Read the newest Change introduced since `baseVV` into wire metadata. */
+function extractMeta(doc, baseVV) {
+	const frontiers = bytesToBase64(encodeFrontiers(doc.oplogFrontiers()));
+	const json = doc.exportJsonUpdates(baseVV);
+	const parsed = typeof json === "string" ? JSON.parse(json) : json;
+	const peers = parsed.peers ?? [];
+	const change = (parsed.changes ?? []).at(-1);
+	if (change == null) return {
+		semantic_op: null,
+		payload: null,
+		intent: null,
+		message: null,
+		parse_error: false,
+		peer: "0",
+		counter: 0,
+		lamport: 0,
+		timestamp: 0,
+		frontiers
+	};
+	const [counterPart, peerPart] = change.id.split("@");
+	const message = change.msg ?? change.message ?? null;
+	const { semantic_op, payload, intent, parse_error } = parseMessage(message);
+	return {
+		semantic_op,
+		payload,
+		intent,
+		message,
+		parse_error,
+		peer: peers[Number(peerPart)] ?? peerPart ?? "0",
+		counter: Number(counterPart),
+		lamport: change.lamport ?? 0,
+		timestamp: change.timestamp ?? 0,
+		frontiers
+	};
+}
+function parseMessage(message) {
+	if (message == null || message === "") return {
+		semantic_op: null,
+		payload: null,
+		intent: null,
+		parse_error: false
+	};
+	try {
+		const parsed = JSON.parse(message);
+		if (parsed == null || typeof parsed !== "object" || !("semantic_op" in parsed)) return {
+			semantic_op: null,
+			payload: null,
+			intent: null,
+			parse_error: true
+		};
+		return {
+			semantic_op: typeof parsed.semantic_op === "string" ? parsed.semantic_op : null,
+			payload: parsed.payload ?? null,
+			intent: typeof parsed.intent === "string" ? parsed.intent : null,
+			parse_error: false
+		};
+	} catch {
+		return {
+			semantic_op: null,
+			payload: null,
+			intent: null,
+			parse_error: true
+		};
+	}
+}
+//#endregion
+//#region src/testing/index.ts
+const ACTOR_TEST = "1001";
+function createTestDraft() {
+	return {
+		id: "draft_test",
+		project_id: "project_test",
+		owner_id: "owner_test",
+		thumbnail_storage_key: "thumb.jpg",
+		timeline: {
+			duration_ms: 3e3,
+			unit_time_ms: 33.33
+		},
+		video_creation_settings: {
+			aspect_ratio: "16:9",
+			voice_id: "voice_test",
+			video_style_id: null,
+			asset_sources: []
+		},
+		chat_session_id: "chat_test",
+		main_track: {
+			id: "main_track",
+			parts_kind: "video_clip",
+			is_hidden: false,
+			items: [{
+				abs_time_position: 0,
+				part_id: "clip_a"
+			}, {
+				abs_time_position: 1e3,
+				part_id: "clip_b"
+			}]
+		},
+		above_main_tracks: [],
+		below_main_tracks: [],
+		part_aggregations: [],
+		part_library: {
+			clip_a: { video_clip: {
+				id: "clip_a",
+				kind: "video_clip",
+				duration_ms: 1e3,
+				play_in: 0,
+				play_out: 1e3,
+				volume: 1,
+				origin_media_id: "media_a"
+			} },
+			clip_b: { video_clip: {
+				id: "clip_b",
+				kind: "video_clip",
+				duration_ms: 2e3,
+				play_in: 0,
+				play_out: 2e3,
+				volume: 1,
+				origin_media_id: "media_b"
+			} }
+		},
+		version: 1
+	};
+}
+function createSeededDoc(docId, opts = {}, actor = ACTOR_TEST) {
+	return createMirrorVideoDocumentAdapter({
+		meta: {
+			schema_version: VIDEO_DOCUMENT_SCHEMA_VERSION,
+			draft_id: docId,
+			project_id: "project-test",
+			owner_id: "owner-test",
+			thumbnail_storage_key: "thumb-test",
+			chat_session_id: "chat-test",
+			video_creation_settings: {
+				aspect_ratio: "16:9",
+				voice_id: "test-voice",
+				video_style_id: null,
+				asset_sources: []
+			},
+			version: 1
+		},
+		timeline: { unit_time_ms: 33.33 },
+		tracks: [{
+			id: "main_track",
+			parts_kind: "video_clip",
+			is_hidden: false,
+			items: (opts.mainTrack ?? []).map((partId) => ({
+				part_id: partId,
+				time_position: { mode: "sequential" }
+			}))
+		}],
+		part_library: Object.fromEntries(Object.entries(opts.parts ?? {}).map(([partId, payload]) => [partId, toPartUnion(partId, payload)]))
+	}, { peerId: actor });
+}
+function mainTrackPartIds(doc) {
+	return ((doc.snapshot().tracks ?? []).find((t) => t.parts_kind === "video_clip")?.items ?? []).map((it) => it.part_id).filter((partId) => partId != null);
+}
+function toPartUnion(partId, payload) {
+	const partKind = payload.part_kind;
+	const durationMs = numberValue(payload.duration_ms);
+	if (partKind === "speech") return { speech: {
+		id: partId,
+		kind: "speech",
+		media_duration_ms: durationMs ?? 0,
+		audio_script: stringValue(payload.audio_script) ?? "s",
+		volume: numberValue(payload.volume) ?? 1,
+		audio_storage_key: stringValue(payload.audio_storage_key) ?? `${partId}.mp3`,
+		origin_speech_id: stringValue(payload.origin_speech_id) ?? `o_${partId}`,
+		voice: void 0,
+		caption_ids: []
+	} };
+	return { video_clip: {
+		id: partId,
+		kind: "video_clip",
+		play_in: numberValue(payload.play_in) ?? 0,
+		play_out: numberValue(payload.play_out) ?? durationMs ?? 0,
+		volume: numberValue(payload.volume) ?? 1,
+		origin_media_id: stringValue(payload.origin_media_id) ?? `media_${partId}`
+	} };
+}
+function numberValue(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function stringValue(value) {
+	return typeof value === "string" ? value : void 0;
+}
+//#endregion
+export { ACTOR_TEST, InMemoryMengineServer, createSeededDoc, createTestDraft, mainTrackPartIds };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mengine/medeo-client",
-  "version": "1.0.0",
+  "version": "1.0.1-alpha.1",
   "license": "UNLICENSED",
   "repository": {
     "type": "git",
@@ -14,6 +14,8 @@
   "type": "module",
   "exports": {
     ".": "./dist/index.js",
+    "./schemas": "./dist/schemas.js",
+    "./testing": "./dist/testing.js",
     "./package.json": "./package.json"
   },
   "publishConfig": {
@@ -21,16 +23,18 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
+    "immer": "^10.2.0",
     "loro-mirror": "^2.2.0",
     "zod": "^4.4.3",
-    "@mengine/storage": "1.0.0",
-    "@mengine/sync": "1.0.0",
-    "@mengine/utils": "1.0.0"
+    "@mengine/storage": "1.0.1-alpha.1",
+    "@mengine/sync": "1.0.1-alpha.1",
+    "@mengine/utils": "1.0.1-alpha.1"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",
     "@typescript/native-preview": "7.0.0-dev.20260521.1",
     "loro-crdt": "^1.13.6",
+    "tsx": "^4.22.3",
     "typescript": "^6.0.3",
     "vite-plugin-wasm": "^3.6.0",
     "vite-plus": "^0.1.23",