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

package/dist/{document-DgffKwRw.js → loro-relay-doc-Br-ZJBHa.js}

@@ -1,7 +1,6 @@
 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 = "";
@@ -536,7 +535,12 @@ function cascadeAfterVideoClipChanges(doc, makeEmptyPart) {
 function solveVideoDocument(document) {
 	const doc = videoDocumentToTimelineDoc(document);
 	let counter = 0;
-	cascadeAfterVideoClipChanges(doc, () => ({ partId: `empty_${counter++}` }));
+	const derivedFillerPartIds = /* @__PURE__ */ new Set();
+	cascadeAfterVideoClipChanges(doc, () => {
+		const partId = `empty_${counter++}`;
+		derivedFillerPartIds.add(partId);
+		return { partId };
+	});
 	const absByPartId = /* @__PURE__ */ new Map();
 	for (const item of doc.main_track) absByPartId.set(item.part_id, item.abs_time_position);
 	for (const item of doc.speech_track) absByPartId.set(item.part_id, item.abs_time_position);
@@ -552,7 +556,8 @@ function solveVideoDocument(document) {
 			}))
 		})),
 		durationMs: doc.timeline.duration_ms,
-		partLibrary: doc.part_library
+		partLibrary: doc.part_library,
+		derivedFillerPartIds
 	};
 }
 function videoDocumentToTimelineDoc(document) {
@@ -876,11 +881,59 @@ function validateVideoDocument(document) {
 		validatePartValues(partId, part, issues);
 	}
 	for (const [idx, track] of (doc.tracks ?? []).entries()) validateTrack(track, `tracks/${idx}`, partLibrary, issues, track.parts_kind === "video_clip");
+	validateLaneTrackUniqueness(doc, issues);
 	validateSpeechCaptionReferences(partLibrary, issues);
 	validatePositionReferences(doc, partLibrary, issues);
 	return issues;
 }
 /**
+* Report a duplicated lane: two tracks sharing the same `id`, or two secondary
+* tracks of the same `parts_kind`.
+*
+* Found by the Phase 6 M0/S2 concurrency probe. `ensureLaneTrack` locates a lane
+* by `parts_kind` and mints `<kind>_track` when absent, so two replicas that both
+* start without (say) a caption track each create one; `tracks` is a
+* `LoroMovableList`, so the merge keeps BOTH. The lane is then split across two
+* same-id tracks, and the projection's `find`-by-kind returns only one of them —
+* so an item can be authoritative yet invisible in the pane a reader looks at.
+*
+* Flagged **recoverable**, not `error`, for two reasons. It is a reachable
+* outcome of ordinary concurrent editing, and hard-rejecting would make an
+* unavoidable merge result un-projectable — the same argument §11.1 makes for
+* orphans. And the projection already tolerates it: `solveVideoDocument`
+* concatenates every track of a kind, so the cascade sees all items regardless.
+* The defect is a *reader-visible* split, so the right response is to surface it
+* (loudly, in a channel someone reads), not to block the document.
+*
+* The main track is exempt from the kind check: `parts_kind === 'video_clip'` may
+* legitimately appear on several tracks (the projection treats only the first as
+* the main pane), so only its `id` collision is reported.
+*/
+function validateLaneTrackUniqueness(doc, issues) {
+	const tracks = doc.tracks ?? [];
+	const seenIds = /* @__PURE__ */ new Set();
+	const seenSecondaryKinds = /* @__PURE__ */ new Set();
+	for (const [idx, track] of tracks.entries()) {
+		const id = track?.id;
+		if (id != null && id !== "") if (seenIds.has(id)) issues.push({
+			code: "duplicate_lane_track",
+			path: `/tracks/${idx}/id`,
+			message: `Track "tracks/${idx}" reuses track id "${id}"`,
+			severity: "recoverable"
+		});
+		else seenIds.add(id);
+		const kind = track?.parts_kind;
+		if (kind == null || kind === "video_clip") continue;
+		if (seenSecondaryKinds.has(kind)) issues.push({
+			code: "duplicate_lane_track",
+			path: `/tracks/${idx}/parts_kind`,
+			message: `Lane "${kind}" is split across more than one track (at "tracks/${idx}")`,
+			severity: "recoverable"
+		});
+		else seenSecondaryKinds.add(kind);
+	}
+}
+/**
 * An `anchored` item whose `anchorPartId` no longer exists in the library is the
 * orphan condition (RFC 02 §4/§11.1) — e.g. a speech whose host video, or a
 * caption whose host speech, was concurrently deleted while this item was being
@@ -1102,7 +1155,7 @@ function toAuthoritativePartLibrary(partLibrary) {
 			const { duration_ms, rest } = splitDurationMs(part.caption);
 			out[partId] = { caption: {
 				...rest,
-				initial_duration_ms: duration_ms
+				initial_duration_ms: rest.initial_duration_ms ?? duration_ms
 			} };
 		} else if (part.bgm != null) out[partId] = { bgm: omitDurationMs(part.bgm) };
 	}
@@ -1209,7 +1262,7 @@ function fromVideoDocument(document) {
 		above_main_tracks: aboveTracks.map((t) => draftTrack(t, view.absByPartId)),
 		below_main_tracks: belowTracks.map((t) => draftTrack(t, view.absByPartId)),
 		part_aggregations: view.aggregations,
-		part_library: toReadViewPartLibrary(view.partLibrary, view.durationMs),
+		part_library: toReadViewPartLibrary(view.partLibrary, view.durationMs, view.derivedFillerPartIds),
 		version: document.meta.version
 	};
 }
@@ -1225,31 +1278,38 @@ function fromVideoDocument(document) {
 *
 * Parts are deep-cloned; the engine extensions (`media_duration_ms`,
 * `initial_duration_ms`) are kept alongside the injected `duration_ms`.
+*
+* `derivedFillerPartIds` are skipped: the solve minted them to lay the track out
+* and they are not part of the document (see `fromVideoDocument`). An empty clip a
+* writer placed deliberately is NOT in that set and is projected normally.
 */
-function toReadViewPartLibrary(partLibrary, durationMs) {
+function toReadViewPartLibrary(partLibrary, durationMs, derivedFillerPartIds) {
 	const out = {};
-	for (const [partId, part] of Object.entries(partLibrary)) if (part.video_clip != null) {
-		const clip = clone(part.video_clip);
-		out[partId] = { video_clip: {
-			...clip,
-			duration_ms: effectiveVideoClipDurationMs(clip)
-		} };
-	} else if (part.speech != null) {
-		const speech = clone(part.speech);
-		out[partId] = { speech: {
-			...speech,
-			duration_ms: speech.media_duration_ms
-		} };
-	} else if (part.caption != null) {
-		const caption = clone(part.caption);
-		out[partId] = { caption: {
-			...caption,
-			duration_ms: caption.initial_duration_ms
+	for (const [partId, part] of Object.entries(partLibrary)) {
+		if (derivedFillerPartIds.has(partId)) continue;
+		if (part.video_clip != null) {
+			const clip = clone(part.video_clip);
+			out[partId] = { video_clip: {
+				...clip,
+				duration_ms: effectiveVideoClipDurationMs(clip)
+			} };
+		} else if (part.speech != null) {
+			const speech = clone(part.speech);
+			out[partId] = { speech: {
+				...speech,
+				duration_ms: speech.media_duration_ms
+			} };
+		} else if (part.caption != null) {
+			const caption = clone(part.caption);
+			out[partId] = { caption: {
+				...caption,
+				duration_ms: caption.initial_duration_ms
+			} };
+		} else if (part.bgm != null) out[partId] = { bgm: {
+			...clone(part.bgm),
+			duration_ms: durationMs
 		} };
-	} else if (part.bgm != null) out[partId] = { bgm: {
-		...clone(part.bgm),
-		duration_ms: durationMs
-	} };
+	}
 	return out;
 }
 /** Deep-clone a part payload, dropping the derived read-view `duration_ms`. */
@@ -1422,7 +1482,8 @@ var MirrorVideoDocumentAdapter = class {
 			message: JSON.stringify({
 				semantic_op: audit.kind,
 				payload: audit.payload,
-				intent: audit.intent ?? null
+				intent: audit.intent ?? null,
+				actor: audit.actor ?? null
 			})
 		});
 	}
@@ -1436,7 +1497,7 @@ function createMirrorVideoDocument(document, options = {}) {
 		doc,
 		schema: videoDocumentMirrorSchema
 	}).setState((draft) => {
-		writeVideoDocumentToDraft(draft, document);
+		seedDraft(draft, document);
 	}, { origin: options.origin ?? "mengine.bootstrap" });
 	return doc;
 }
@@ -1444,8 +1505,8 @@ function createMirrorVideoDocument(document, options = {}) {
 function createMirrorVideoDocumentAdapter(document, options) {
 	return new MirrorVideoDocumentAdapter(createMirrorVideoDocument(document, options));
 }
-/** Write a whole `VideoDocument` into a draft (seed a fresh doc / plain-memory state). */
-function writeVideoDocumentToDraft(draft, document) {
+/** Write a whole `VideoDocument` into the mirror draft (used to seed a fresh doc). */
+function seedDraft(draft, document) {
 	draft.meta = {
 		schema_version: document.meta.schema_version,
 		draft_id: document.meta.draft_id ?? void 0,
@@ -1475,119 +1536,60 @@ function toTrackRow(track) {
 	};
 }
 //#endregion
-//#region src/editor/id-gen.ts
+//#region src/relay/loro-relay-doc.ts
 /**
-* Part-id generation, aligned with the online ecosystem.
+* Loro OpLog-relay primitives: the doc shape and update classification an update
+* *host* needs, as opposed to an editing client.
 *
-* 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.
+* A relay never materializes DocState (`docs/concepts/oplog_docstate` §Relay
+* Server) — it keeps a detached `LoroDoc` that validates and accumulates updates
+* and exports diffs by version vector.
 *
-* 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.
+* These live in `medeo-client` rather than in `mengine-server` because two
+* separate hosts must classify identically: the real server (`apps/mengine-server`,
+* both storage implementations) and the in-process test double
+* (`testing/in-memory-mengine-server.ts`) that client-side tests push against. A
+* double with its own verdict logic drifts from the server it stands in for, and
+* the four push outcomes it produces are exactly what those tests assert on — so
+* the classification is shared code, not duplicated code.
 */
-/** 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;
+/** Build a fresh detached relay doc (no DocState materialization). */
+function newRelayDoc() {
+	const doc = new LoroDoc();
+	doc.detach();
+	return doc;
 }
-/** A 26-char Crockford Base32 ULID (10-char time + 16-char random). */
-function ulid() {
-	return encodeTime(Date.now()) + encodeRandom();
+/** Load a detached relay doc from a stored snapshot. */
+function relayDocFromSnapshot(snapshot) {
+	const doc = newRelayDoc();
+	doc.import(snapshot);
+	return doc;
 }
-function generatePartId(prefix) {
-	return `${prefix}_${ulid()}`;
+/** A full-oplog clone (via snapshot round-trip) for non-destructive probing. */
+function cloneRelayDoc(doc) {
+	return relayDocFromSnapshot(doc.export({ mode: "snapshot" }));
 }
-//#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).
+* Classify an incoming update against `doc` without mutating it.
 *
-* 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.
+* Deliberately version-delta based, not `ImportStatus`-shape based: in loro-crdt
+* 1.13.x the JS `import()` returns `success`/`pending` as objects whose ranges
+* are not reliably populated, and a pending (out-of-order) import still buffers
+* the orphan op into the oplog. So this imports into a throwaway snapshot-clone
+* and inspects whether the oplog frontiers advanced — letting the caller import
+* into its canonical doc only on `accepted`, keeping orphan bytes out of the log.
 */
-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;
+function classifyUpdate(doc, update) {
+	const probe = cloneRelayDoc(doc);
+	let status;
+	try {
+		status = probe.import(update);
+	} catch {
+		return "corrupt_update";
 	}
-	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);
+	if (status?.pending != null) return "missing_dependency";
+	if (probe.cmpWithFrontiers(doc.oplogFrontiers()) !== 1) return "duplicate";
+	return "accepted";
 }
 //#endregion
-export { isEmptyVideoClip as A, bytesToBase64 as B, fillMainTrackTimeGaps as C, resolveSpeechOverlapByShiftingVideos as D, resolveAllSpeechOverlaps as E, speedOf as F, partUnionToDraft as I, recordEntries as L, safeDurationMs as M, VIDEO_DOCUMENT_SCHEMA_VERSION as N, syncAggregatedClipsTimePosition as O, effectiveVideoClipDurationMs as P, videoDocumentMirrorSchema as R, arrangeMainTrackSeamlessly as S, recalculateTimelineDuration as T, videoDocumentSchema as _, createMirrorVideoDocument as a, solveVideoDocument as b, readVideoDocumentFromDraft as c, fromVideoDocument as d, toVideoDocument as f, partUnionSchema as g, validateVideoDocument as h, MirrorVideoDocumentAdapter as i, partDurationMs as j, TIMELINE_SKELETON_DURATION_MS as k, buildSpeechHostMap as l, assertValidVideoDocument as m, createPlainMemoryAdapter as n, createMirrorVideoDocumentAdapter as o, VideoDocumentValidationError as p, generatePartId as r, writeVideoDocumentToDraft as s, PlainMemoryAdapter as t, derivePositionFromAbs as u, ensureLaneTrack as v, reassignSpeechesToVideoClipsByTime as w, cascadeAfterVideoClipChanges as x, findLaneTrack as y, base64ToBytes as z };
+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, ensureLaneTrack as _, createMirrorVideoDocument as a, cascadeAfterVideoClipChanges as b, buildSpeechHostMap as c, toVideoDocument as d, VideoDocumentValidationError as f, videoDocumentSchema as g, partUnionSchema as h, MirrorVideoDocumentAdapter as i, safeDurationMs as j, isEmptyVideoClip as k, derivePositionFromAbs as l, validateVideoDocument as m, newRelayDoc as n, createMirrorVideoDocumentAdapter as o, assertValidVideoDocument as p, relayDocFromSnapshot as r, readVideoDocumentFromDraft as s, classifyUpdate as t, fromVideoDocument as u, findLaneTrack as v, recalculateTimelineDuration as w, arrangeMainTrackSeamlessly as x, solveVideoDocument as y };

package/dist/testing.d.ts

@@ -1,4 +1,4 @@
-import { c as MirrorVideoDocumentAdapter, it as VideoDraft } from "./index-DRUGsbm2.js";
+import { $ as VideoDraft, i as MirrorVideoDocumentAdapter } from "./index-DLchEQG7.js";
 
 //#region src/testing/in-memory-mengine-server.d.ts
 /**
@@ -29,6 +29,21 @@ declare class InMemoryMengineServer {
   private handleSnapshot;
   private handleBootstrap;
   private handleSync;
+  /**
+   * Push one update, classifying it exactly as the real server does.
+   *
+   * This shares `classifyUpdate` with `apps/mengine-server` rather than assuming
+   * success, because the four push verdicts are the contract clients are written
+   * against: a double that always acks makes `duplicate` / `rejected` untestable
+   * above the storage layer, so an ack-waiter or a doc handle could mishandle
+   * them and still show green. It also mirrors the real server's two subtler
+   * behaviors — a non-accepted update is NOT imported (orphan bytes stay out of
+   * the log), and `duplicate` / `rejected` report the version from *before* the
+   * push, since nothing was appended.
+   *
+   * Status codes match the wire contract: `missing_dependency` is 409 (retryable
+   * after catch-up), `corrupt_update` is 422 (never retryable).
+   */
   private handlePush;
   private handleEvents;
 }

package/dist/testing.js

@@ -1,4 +1,4 @@
-import { B as bytesToBase64, N as VIDEO_DOCUMENT_SCHEMA_VERSION, o as createMirrorVideoDocumentAdapter, z as base64ToBytes } from "./document-DgffKwRw.js";
+import { L as base64ToBytes, M as VIDEO_DOCUMENT_SCHEMA_VERSION, R as bytesToBase64, o as createMirrorVideoDocumentAdapter, t as classifyUpdate } from "./loro-relay-doc-Br-ZJBHa.js";
 import { LoroDoc, VersionVector, encodeFrontiers } from "loro-crdt";
 //#region src/testing/in-memory-mengine-server.ts
 /**
@@ -35,10 +35,6 @@ var InMemoryMengineServer = class {
 		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) {
@@ -85,6 +81,21 @@ var InMemoryMengineServer = class {
 			server_vv: bytesToBase64(this.doc.oplogVersion().encode())
 		});
 	}
+	/**
+	* Push one update, classifying it exactly as the real server does.
+	*
+	* This shares `classifyUpdate` with `apps/mengine-server` rather than assuming
+	* success, because the four push verdicts are the contract clients are written
+	* against: a double that always acks makes `duplicate` / `rejected` untestable
+	* above the storage layer, so an ack-waiter or a doc handle could mishandle
+	* them and still show green. It also mirrors the real server's two subtler
+	* behaviors — a non-accepted update is NOT imported (orphan bytes stay out of
+	* the log), and `duplicate` / `rejected` report the version from *before* the
+	* push, since nothing was appended.
+	*
+	* Status codes match the wire contract: `missing_dependency` is 409 (retryable
+	* after catch-up), `corrupt_update` is 422 (never retryable).
+	*/
 	async handlePush(init) {
 		const body = JSON.parse(typeof init?.body === "string" ? init.body : "{}");
 		if (body.update == null) return Response.json({
@@ -94,6 +105,25 @@ var InMemoryMengineServer = class {
 		}, { status: 400 });
 		const data = base64ToBytes(body.update);
 		const baseVV = this.doc.oplogVersion();
+		const serverVersion = this.version();
+		const verdict = classifyUpdate(this.doc, data);
+		if (verdict === "corrupt_update") return Response.json({
+			kind: "rejected",
+			code: "corrupt_update",
+			message: "update failed to decode",
+			server_version: serverVersion
+		}, { status: 422 });
+		if (verdict === "missing_dependency") return Response.json({
+			kind: "rejected",
+			code: "missing_dependency",
+			message: "update depends on operations that are not in the server log",
+			server_version: serverVersion
+		}, { status: 409 });
+		if (verdict === "duplicate") return Response.json({
+			kind: "duplicate",
+			update_seq: null,
+			version: serverVersion
+		});
 		this.doc.import(data);
 		this.hasSnapshot = true;
 		this.seq += 1;
@@ -161,6 +191,7 @@ function extractMeta(doc, baseVV) {
 		semantic_op: null,
 		payload: null,
 		intent: null,
+		actor: null,
 		message: null,
 		parse_error: false,
 		peer: "0",
@@ -171,11 +202,12 @@ function extractMeta(doc, baseVV) {
 	};
 	const [counterPart, peerPart] = change.id.split("@");
 	const message = change.msg ?? change.message ?? null;
-	const { semantic_op, payload, intent, parse_error } = parseMessage(message);
+	const { semantic_op, payload, intent, actor, parse_error } = parseMessage(message);
 	return {
 		semantic_op,
 		payload,
 		intent,
+		actor,
 		message,
 		parse_error,
 		peer: peers[Number(peerPart)] ?? peerPart ?? "0",
@@ -185,11 +217,17 @@ function extractMeta(doc, baseVV) {
 		frontiers
 	};
 }
+/**
+* Mirrors `apps/mengine-server`'s `parseMessage` / `parseActor`. Kept in step
+* deliberately: this double is what harness tests push against, so a divergence
+* here would let them assert metadata the real server never produces.
+*/
 function parseMessage(message) {
 	if (message == null || message === "") return {
 		semantic_op: null,
 		payload: null,
 		intent: null,
+		actor: null,
 		parse_error: false
 	};
 	try {
@@ -198,12 +236,14 @@ function parseMessage(message) {
 			semantic_op: null,
 			payload: null,
 			intent: null,
+			actor: 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,
+			actor: parseActor(parsed.actor),
 			parse_error: false
 		};
 	} catch {
@@ -211,10 +251,21 @@ function parseMessage(message) {
 			semantic_op: null,
 			payload: null,
 			intent: null,
+			actor: null,
 			parse_error: true
 		};
 	}
 }
+/** A malformed `actor` yields null for the author alone, never `parse_error`. */
+function parseActor(actor) {
+	if (actor == null || typeof actor !== "object") return null;
+	const { user_id: userId, role } = actor;
+	if (typeof userId !== "string" || userId === "" || typeof role !== "string" || role === "") return null;
+	return {
+		user_id: userId,
+		role
+	};
+}
 //#endregion
 //#region src/testing/index.ts
 const ACTOR_TEST = "1001";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mengine/medeo-client",
-  "version": "1.0.1-alpha.1",
+  "version": "1.0.1",
   "license": "UNLICENSED",
   "repository": {
     "type": "git",
@@ -14,7 +14,6 @@
   "type": "module",
   "exports": {
     ".": "./dist/index.js",
-    "./schemas": "./dist/schemas.js",
     "./testing": "./dist/testing.js",
     "./package.json": "./package.json"
   },
@@ -23,18 +22,16 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "immer": "^10.2.0",
     "loro-mirror": "^2.2.0",
     "zod": "^4.4.3",
-    "@mengine/storage": "1.0.1-alpha.1",
-    "@mengine/sync": "1.0.1-alpha.1",
-    "@mengine/utils": "1.0.1-alpha.1"
+    "@mengine/storage": "1.0.1",
+    "@mengine/sync": "1.0.1",
+    "@mengine/utils": "1.0.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",