@mengine/medeo-client 1.1.0 → 1.2.1-alpha.0

package/dist/{document-C98vSu7J.js → document-49OdvviW.js}

@@ -1,6 +1,7 @@
 import { Mirror, schema } from "loro-mirror";
 import { z } from "zod";
 import { LoroDoc } from "loro-crdt";
+import { produce } from "immer";
 //#region src/client/base64.ts
 function bytesToBase64(bytes) {
 	let binary = "";
@@ -230,6 +231,16 @@ function effectiveVideoClipDurationMs(clip) {
 	const effective = Math.round(sourceMs / speed);
 	return Number.isFinite(effective) && effective > 0 ? effective : 0;
 }
+/**
+* The `timeline.unit_time_ms` the read-view states when the document states none.
+*
+* One frame at 30fps. A document legitimately has no such fact (display
+* granularity is the editor's, not the timeline's), but the read-view IDL marks
+* the field `@required`, so the projection has to name a value. This one is a
+* usable granularity; `0` — which a downstream consumer had been defaulting to —
+* is not, and passes any `>= 0` guard on its way to an editor that cannot use it.
+*/
+const DEFAULT_UNIT_TIME_MS = 33.333;
 //#endregion
 //#region src/timeline-core/types.ts
 /** Total document duration when there is no real content (matches FE bgm fallback). */
@@ -1279,6 +1290,20 @@ function deriveItem(item, isMain, speechHost, partLibrary) {
 * Project the authoritative `VideoDocument` back into the legacy `VideoDraft`
 * read-view, solving each item's absolute position, the `part_aggregations`, and
 * the total duration via the timeline-core cascade.
+*
+* The read-view is a compatibility contract, and the IDL declares
+* `Timeline.unit_time_ms` and `Track.is_hidden` `@required`
+* (`video_draft_comp.smithy`) — so a projection that omitted them handed every
+* consumer a payload that violated the shape it claims to satisfy, leaving each
+* one to invent its own default. Two already had, and they disagreed: the agent
+* harness used `unit_time_ms: 0`, director used a frame at 30fps. Defaulting here
+* makes the contract true at the one place that produces it.
+*
+* These two are defaultable because the projection knows their values on its own:
+* absent `unit_time_ms` means "no display granularity was ever stated" and absent
+* `is_hidden` means "this track was never hidden". `version` is NOT defaultable
+* here — its only honest value is server state (`update_seq`) that a
+* `VideoDocument` cannot see, so it stays absent and the HTTP layer fills it.
 */
 function fromVideoDocument(document) {
 	assertValidVideoDocument(document);
@@ -1294,7 +1319,7 @@ function fromVideoDocument(document) {
 		thumbnail_storage_key: document.meta.thumbnail_storage_key,
 		timeline: {
 			duration_ms: view.durationMs,
-			unit_time_ms: document.timeline?.unit_time_ms
+			unit_time_ms: document.timeline?.unit_time_ms ?? 33.333
 		},
 		video_creation_settings: clone(document.meta.video_creation_settings),
 		chat_session_id: document.meta.chat_session_id,
@@ -1390,7 +1415,7 @@ function draftTrack(track, absByPartId) {
 	return {
 		id: track.id,
 		parts_kind: track.parts_kind,
-		is_hidden: track.is_hidden,
+		is_hidden: track.is_hidden ?? false,
 		items: (track.items ?? []).map((item) => ({
 			part_id: item.part_id,
 			abs_time_position: absByPartId.get(item.part_id) ?? 0
@@ -1588,7 +1613,7 @@ function createMirrorVideoDocument(document, options = {}) {
 		doc,
 		schema: videoDocumentMirrorSchema
 	}).setState((draft) => {
-		seedDraft(draft, document);
+		writeVideoDocumentToDraft(draft, document);
 	}, { origin: options.origin ?? "mengine.bootstrap" });
 	return doc;
 }
@@ -1596,8 +1621,8 @@ function createMirrorVideoDocument(document, options = {}) {
 function createMirrorVideoDocumentAdapter(document, options) {
 	return new MirrorVideoDocumentAdapter(createMirrorVideoDocument(document, options));
 }
-/** Write a whole `VideoDocument` into the mirror draft (used to seed a fresh doc). */
-function seedDraft(draft, document) {
+/** Write a whole `VideoDocument` into a draft (seed a fresh doc / plain-memory state). */
+function writeVideoDocumentToDraft(draft, document) {
 	draft.meta = {
 		schema_version: document.meta.schema_version,
 		draft_id: document.meta.draft_id ?? void 0,
@@ -1627,4 +1652,119 @@ function toTrackRow(track) {
 	};
 }
 //#endregion
-export { partDurationMs as A, reassignSpeechesToVideoClipsByTime as C, syncAggregatedClipsTimePosition as D, resolveSpeechOverlapByShiftingVideos as E, recordEntries as F, videoDocumentMirrorSchema as I, base64ToBytes as L, VIDEO_DOCUMENT_SCHEMA_VERSION as M, effectiveVideoClipDurationMs as N, TIMELINE_SKELETON_DURATION_MS as O, partUnionToDraft as P, bytesToBase64 as R, fillMainTrackTimeGaps as S, resolveAllSpeechOverlaps as T, findLaneTrack as _, buildInitialVideoDocument as a, cascadeAfterVideoClipChanges as b, fromVideoDocument as c, assertValidVideoDocument as d, validateVideoDocument as f, ensureLaneTrack as g, LANE_KINDS_IN_STACK_ORDER as h, readVideoDocumentFromDraft as i, safeDurationMs as j, isEmptyVideoClip as k, toVideoDocument as l, videoDocumentSchema as m, createMirrorVideoDocument as n, buildSpeechHostMap as o, partUnionSchema as p, createMirrorVideoDocumentAdapter as r, derivePositionFromAbs as s, MirrorVideoDocumentAdapter as t, VideoDocumentValidationError as u, laneTrackId as v, recalculateTimelineDuration as w, arrangeMainTrackSeamlessly as x, solveVideoDocument as y };
+//#region src/editor/id-gen.ts
+/**
+* Part-id generation, aligned with the online ecosystem.
+*
+* The authoritative online producers — agent-harness (`@harness/shared`
+* `genObjId`) and director.v2 (`common/obj_id.py` `gen_obj_id`) — both mint part
+* ids as `` `${prefix}_${ulid()}` ``, and real captured drafts use exactly that
+* shape (`clip_…` / `spe_…` / `cap_…` / `bgm_…`, each a 26-char ULID). The engine
+* previously emitted `vc_<base36 timestamp><6 random>`, a different prefix AND a
+* different encoding — the sole cross-repo id divergence. This module removes it
+* by emitting the same `<prefix>_<ULID>` bytes.
+*
+* The ULID is generated inline (Crockford Base32, 48-bit time + 80-bit random)
+* rather than pulling the `ulid` npm package: the randomness class matches the
+* old generator (both `Math.random`-based) and it keeps `@mengine/medeo-client`
+* dependency-free for a purely mechanical id string. Part ids only need to be
+* unique and lexicographically time-sortable, which this satisfies.
+*/
+/** Crockford Base32 alphabet (no I, L, O, U), per the ULID spec. */
+const CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+const TIME_LEN = 10;
+const RANDOM_LEN = 16;
+function encodeTime(now) {
+	let out = "";
+	let ms = now;
+	for (let i = TIME_LEN - 1; i >= 0; i--) {
+		const mod = ms % 32;
+		out = CROCKFORD[mod] + out;
+		ms = (ms - mod) / 32;
+	}
+	return out;
+}
+function encodeRandom() {
+	let out = "";
+	for (let i = 0; i < RANDOM_LEN; i++) out += CROCKFORD[Math.floor(Math.random() * 32)];
+	return out;
+}
+/** A 26-char Crockford Base32 ULID (10-char time + 16-char random). */
+function ulid() {
+	return encodeTime(Date.now()) + encodeRandom();
+}
+function generatePartId(prefix) {
+	return `${prefix}_${ulid()}`;
+}
+//#endregion
+//#region src/document/plain-memory-adapter.ts
+/**
+* Pure in-memory `SemanticDocumentAdapter` — no Loro/WASM. Holds a
+* `VideoDocumentDraft` object and applies each `transact` via immer `produce`,
+* journaling every audit that actually mutated state (plus any ids minted
+* during that transact).
+*
+* Known benign difference vs `MirrorVideoDocumentAdapter`: the editor's
+* `setPart` assigns a fresh part object on every call, so a same-value rewrite
+* produces a new immer state and IS journaled here, while the mirror's deep
+* diff emits no commit. Terminal `snapshot()` stays equal; replay is idempotent.
+*/
+var PlainMemoryAdapter = class {
+	state;
+	_journal = [];
+	baseIdFactory;
+	/** Non-null only while a `transact` edit callback is running. */
+	pendingIds = null;
+	/**
+	* Recording wrapper around the underlying factory. Callers (sandbox editor)
+	* use this so every minted id is appended to the current transact's list.
+	*/
+	idFactory;
+	constructor(document, options) {
+		assertValidVideoDocument(document);
+		const draft = {};
+		writeVideoDocumentToDraft(draft, document);
+		this.state = draft;
+		this.baseIdFactory = options?.idFactory ?? generatePartId;
+		this.idFactory = (prefix) => {
+			const id = this.baseIdFactory(prefix);
+			if (this.pendingIds != null) this.pendingIds.push(id);
+			return id;
+		};
+	}
+	get journal() {
+		return this._journal;
+	}
+	hasContent() {
+		return (this.state.meta?.schema_version ?? "") !== "";
+	}
+	snapshot() {
+		return readVideoDocumentFromDraft(this.state);
+	}
+	/**
+	* Apply one op via immer. A throw in `edit` discards the draft (state and
+	* journal unchanged). When `produce` returns the same reference, there was
+	* no structural change — skip journal, matching mirror "no change, no commit".
+	*/
+	transact(edit, audit) {
+		this.pendingIds = [];
+		try {
+			const next = produce(this.state, edit);
+			if (next !== this.state) {
+				this.state = next;
+				this._journal.push({
+					...audit,
+					generated_ids: this.pendingIds
+				});
+			}
+		} finally {
+			this.pendingIds = null;
+		}
+	}
+};
+/** Build a `PlainMemoryAdapter` seeded with `document`. */
+function createPlainMemoryAdapter(document, options) {
+	return new PlainMemoryAdapter(document, options);
+}
+//#endregion
+export { resolveSpeechOverlapByShiftingVideos as A, partUnionToDraft as B, solveVideoDocument as C, reassignSpeechesToVideoClipsByTime as D, fillMainTrackTimeGaps as E, safeDurationMs as F, videoDocumentMirrorSchema as H, DEFAULT_UNIT_TIME_MS as I, VIDEO_DOCUMENT_SCHEMA_VERSION as L, TIMELINE_SKELETON_DURATION_MS as M, isEmptyVideoClip as N, recalculateTimelineDuration as O, partDurationMs as P, effectiveVideoClipDurationMs as R, laneTrackId as S, arrangeMainTrackSeamlessly as T, base64ToBytes as U, recordEntries as V, bytesToBase64 as W, partUnionSchema as _, createMirrorVideoDocument as a, ensureLaneTrack as b, readVideoDocumentFromDraft as c, derivePositionFromAbs as d, fromVideoDocument as f, validateVideoDocument as g, assertValidVideoDocument as h, MirrorVideoDocumentAdapter as i, syncAggregatedClipsTimePosition as j, resolveAllSpeechOverlaps as k, buildInitialVideoDocument as l, VideoDocumentValidationError as m, createPlainMemoryAdapter as n, createMirrorVideoDocumentAdapter as o, toVideoDocument as p, generatePartId as r, writeVideoDocumentToDraft as s, PlainMemoryAdapter as t, buildSpeechHostMap as u, videoDocumentSchema as v, cascadeAfterVideoClipChanges as w, findLaneTrack as x, LANE_KINDS_IN_STACK_ORDER as y, speedOf as z };