@morlay/ui-conversation-message-actions 0.0.12 → 0.0.13

package/dist/index.mjs

@@ -1,607 +1,3 @@
-import { Service } from "@deepseek-ai/cordis";
-import { randomUUID } from "node:crypto";
-import { SESSION_BRANCH_VERSION_SCHEMA, SESSION_BRANCH_VERSION_SCHEMA as SESSION_BRANCH_VERSION_SCHEMA$1, SessionBranchError, balanceRewindPrefix } from "@morlay/session-branch";
-//#region src/shared.ts
-const SESSION_EDITOR_PATH = "/session-editor";
-function toTimelinePayload(sessionId, timeline, messages, retryableTurns) {
-	const currentPath = /* @__PURE__ */ new Set();
-	for (const node of timeline.nodes) currentPath.add(String(node.sessionId));
-	const versions = timeline.nodes.map((node) => ({
-		sessionId: String(node.sessionId),
-		...node.parentSessionId === void 0 ? {} : { parentSessionId: String(node.parentSessionId) },
-		...node.effect === void 0 ? {} : {
-			effectId: node.effect.id,
-			inverseSessionId: String(node.inverseSessionId),
-			operation: node.effect.operation,
-			cascade: node.effect.cascade,
-			targetTurn: node.effect.targetTurn,
-			...node.effect.blockKind === void 0 ? {} : { blockKind: node.effect.blockKind },
-			...node.effect.before === void 0 ? {} : { before: node.effect.before },
-			...node.effect.after === void 0 ? {} : { after: node.effect.after }
-		},
-		createdAt: node.createdAt,
-		depth: depthOf(timeline, node.sessionId),
-		current: String(node.sessionId) === String(sessionId),
-		onCurrentEffectPath: currentPath.has(String(node.sessionId))
-	}));
-	const versionsById = new Map(versions.map((version) => [version.sessionId, version]));
-	const undoStack = [];
-	let cursor = versionsById.get(String(sessionId));
-	while (cursor?.inverseSessionId !== void 0) {
-		if (undoStack.includes(cursor.inverseSessionId)) break;
-		undoStack.push(cursor.inverseSessionId);
-		cursor = versionsById.get(cursor.inverseSessionId);
-	}
-	const redoSessionIds = versions.filter((version) => version.inverseSessionId === String(sessionId)).map((version) => version.sessionId);
-	return {
-		sessionId: String(sessionId),
-		messages,
-		retryableTurns,
-		versions,
-		undoStack,
-		redoSessionIds
-	};
-}
-function depthOf(timeline, sessionId) {
-	const byId = new Map(timeline.nodes.map((node) => [String(node.sessionId), node]));
-	let depth = 0;
-	let cursor = byId.get(String(sessionId));
-	const seen = /* @__PURE__ */ new Set();
-	while (cursor?.parentSessionId !== void 0 && !seen.has(String(cursor.sessionId))) {
-		seen.add(String(cursor.sessionId));
-		depth += 1;
-		cursor = byId.get(String(cursor.parentSessionId));
-	}
-	return depth;
-}
-//#endregion
-//#region src/index.ts
-function closedTurns(events) {
-	const result = [];
-	let current;
-	for (const event of events) {
-		if (event.type === "turn/start") {
-			current = {
-				turn: event.data.turn,
-				startSeq: event.seq,
-				assistants: []
-			};
-			continue;
-		}
-		if (current === void 0) continue;
-		if (event.type === "user/message" && current.user === void 0 && event.data.source.kind === "user") {
-			current.user = event;
-			continue;
-		}
-		if (event.type === "assistant/message" && event.data.turn === current.turn) {
-			current.assistants.push(event);
-			continue;
-		}
-		if (event.type === "turn/end" && event.data.turn === current.turn) {
-			result.push({
-				...current,
-				endSeq: event.seq,
-				closed: true
-			});
-			current = void 0;
-		}
-	}
-	if (current !== void 0) result.push({
-		...current,
-		closed: false
-	});
-	return result;
-}
-function isTextualBlock(block) {
-	return block?.type === "text" || block?.type === "reasoning";
-}
-function userText(message) {
-	return message.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
-}
-function cloneUser(message, content = structuredClone(message.content)) {
-	return Object.freeze({
-		id: randomUUID(),
-		role: "user",
-		content: Object.freeze(content),
-		source: Object.freeze({ kind: "user" })
-	});
-}
-function replaceTextBlock(content, blockIndex, text) {
-	const block = content[blockIndex];
-	if (!isTextualBlock(block)) throw new SessionBranchError("所选内容块不是可编辑文本。", "INVALID_BOUNDARY");
-	return content.map((candidate, index) => index === blockIndex ? {
-		...candidate,
-		text
-	} : structuredClone(candidate));
-}
-function editableMessages(turns) {
-	const result = [];
-	for (const turn of turns) {
-		if (turn.user !== void 0) for (const [blockIndex, block] of turn.user.data.content.entries()) {
-			if (block.type !== "text") continue;
-			result.push({
-				key: `${String(turn.user.seq)}:${String(blockIndex)}`,
-				turn: turn.turn,
-				eventSeq: turn.user.seq,
-				blockIndex,
-				kind: "user",
-				text: block.text,
-				time: turn.user.time
-			});
-		}
-		if (!turn.closed) continue;
-		for (const event of turn.assistants) for (const [blockIndex, block] of event.data.message.content.entries()) {
-			if (!isTextualBlock(block)) continue;
-			result.push({
-				key: `${String(event.seq)}:${String(blockIndex)}`,
-				turn: turn.turn,
-				eventSeq: event.seq,
-				blockIndex,
-				kind: block.type === "reasoning" ? "assistant.reasoning" : "assistant.response",
-				text: block.text,
-				time: event.time
-			});
-		}
-	}
-	return result;
-}
-function retryableTurns(turns) {
-	return turns.flatMap((turn) => turn.user === void 0 || !turn.closed ? [] : [{
-		turn: turn.turn,
-		userEventSeq: turn.user.seq,
-		preview: userText(turn.user.data),
-		time: turn.user.time
-	}]);
-}
-function downstreamUsers(turns, start) {
-	return turns.slice(start).flatMap((turn) => turn.user === void 0 ? [] : [cloneUser(turn.user.data)]);
-}
-function assistantReplacement(event, blockIndex, text) {
-	const replaced = replaceTextBlock(event.data.message.content, blockIndex, text).filter((block) => block.type === "text" || block.type === "reasoning");
-	return Object.freeze({
-		id: randomUUID(),
-		role: "assistant",
-		content: Object.freeze(replaced),
-		source: Object.freeze({
-			kind: "model",
-			provider: event.data.message.source.provider,
-			model: event.data.message.source.model
-		})
-	});
-}
-function pairVersionEffect(sourceSessionId, effect) {
-	return {
-		schemaVersion: SESSION_BRANCH_VERSION_SCHEMA$1,
-		effect: {
-			...effect,
-			id: randomUUID()
-		},
-		inverse: {
-			kind: "restore-version",
-			sessionId: sourceSessionId
-		}
-	};
-}
-function editPlan(operation, turns) {
-	const turnIndex = turns.findIndex((turn) => operation.eventSeq > turn.startSeq && (turn.endSeq === void 0 || operation.eventSeq < turn.endSeq));
-	const turn = turns[turnIndex];
-	if (turn === void 0) throw new SessionBranchError("所选消息不属于已落定回合。", "INVALID_BOUNDARY");
-	const event = turn.user?.seq === operation.eventSeq ? turn.user : turn.assistants.find((candidate) => candidate.seq === operation.eventSeq);
-	if (event === void 0) throw new SessionBranchError("所选消息不存在或不可编辑。", "INVALID_BOUNDARY");
-	if (event.type === "user/message") {
-		const before = event.data.content[operation.blockIndex];
-		if (before?.type !== "text") throw new SessionBranchError("所选用户消息块不是文本。", "INVALID_BOUNDARY");
-		const edited = cloneUser(event.data, replaceTextBlock(event.data.content, operation.blockIndex, operation.text));
-		const later = operation.cascade === "preserve" ? downstreamUsers(turns, turnIndex + 1) : [];
-		return {
-			anchorSeq: turn.startSeq,
-			...turn.closed ? {} : { rewindBoundary: event.seq },
-			version: pairVersionEffect(operation.sessionId, {
-				operation: "edit",
-				cascade: operation.cascade,
-				targetTurn: turn.turn,
-				targetEventSeq: event.seq,
-				targetBlockIndex: operation.blockIndex,
-				blockKind: "user",
-				before: before.text,
-				after: operation.text
-			}),
-			queuedUsers: [edited, ...later]
-		};
-	}
-	if (!turn.closed) throw new SessionBranchError("未闭合轮次的助手消息不可编辑。", "INVALID_BOUNDARY");
-	const before = event.data.message.content[operation.blockIndex];
-	if (!isTextualBlock(before)) throw new SessionBranchError("所选助手消息块不是文本或思考。", "INVALID_BOUNDARY");
-	const blockKind = before.type === "reasoning" ? "assistant.reasoning" : "assistant.response";
-	if (turn.user === void 0) throw new SessionBranchError("所选助手消息没有可重建的用户输入。", "INVALID_BOUNDARY");
-	return {
-		anchorSeq: turn.startSeq,
-		version: pairVersionEffect(operation.sessionId, {
-			operation: "edit",
-			cascade: operation.cascade,
-			targetTurn: turn.turn,
-			targetEventSeq: event.seq,
-			targetBlockIndex: operation.blockIndex,
-			blockKind,
-			before: before.text,
-			after: operation.text
-		}),
-		manualTurn: {
-			turn: turn.turn,
-			user: cloneUser(turn.user.data),
-			assistant: assistantReplacement(event, operation.blockIndex, operation.text)
-		},
-		queuedUsers: operation.cascade === "preserve" ? downstreamUsers(turns, turnIndex + 1) : []
-	};
-}
-function retryPlan(operation, turns) {
-	const turnIndex = turns.findIndex((turn) => turn.turn === operation.turn);
-	const turn = turns[turnIndex];
-	if (turn?.user === void 0) throw new SessionBranchError("所选回合没有可重放的用户输入。", "INVALID_BOUNDARY");
-	return {
-		anchorSeq: turn.startSeq,
-		version: pairVersionEffect(operation.sessionId, {
-			operation: "retry",
-			cascade: operation.cascade,
-			targetTurn: turn.turn,
-			targetEventSeq: turn.user.seq
-		}),
-		queuedUsers: operation.cascade === "preserve" ? downstreamUsers(turns, turnIndex) : [cloneUser(turn.user.data)]
-	};
-}
-function rerollPlan(operation, turns) {
-	for (let index = turns.length - 1; index >= 0; index -= 1) {
-		const turn = turns[index];
-		if (turn?.user === void 0 || !turn.closed) continue;
-		const target = turn.assistants.findLast((event) => event.data.message.content.some(isTextualBlock));
-		if (target === void 0) continue;
-		return {
-			anchorSeq: turn.startSeq,
-			version: pairVersionEffect(operation.sessionId, {
-				operation: "reroll",
-				cascade: "truncate",
-				targetTurn: turn.turn,
-				targetEventSeq: target.seq
-			}),
-			queuedUsers: [cloneUser(turn.user.data)]
-		};
-	}
-	throw new SessionBranchError("当前会话没有可重生成的已落定助手回复。", "INVALID_BOUNDARY");
-}
-function appendLogSeedEvent(events, type, data, ignorable = false) {
-	events.push({
-		type,
-		seq: events.length,
-		time: Date.now(),
-		data,
-		...ignorable ? { ignorable: true } : {}
-	});
-}
-function appendSurfaceSeedEvent(events, type, data, intent) {
-	events.push({
-		type,
-		seq: events.length,
-		time: Date.now(),
-		data,
-		surfaceOp: intent.surfaceOp,
-		...intent.sourceEventSeqs === void 0 ? {} : { sourceEventSeqs: intent.sourceEventSeqs }
-	});
-}
-function appendManualTurn(events, manual) {
-	const { turn, user, assistant } = manual;
-	appendLogSeedEvent(events, "turn/start", { turn });
-	appendSurfaceSeedEvent(events, "user/message", user, { surfaceOp: "append" });
-	appendLogSeedEvent(events, "step/start", {
-		turn,
-		step: 1
-	});
-	appendSurfaceSeedEvent(events, "assistant/message", {
-		turn,
-		step: 1,
-		message: assistant
-	}, {
-		surfaceOp: "append",
-		sourceEventSeqs: []
-	});
-	appendLogSeedEvent(events, "step/end", {
-		turn,
-		step: 1
-	});
-	appendLogSeedEvent(events, "turn/end", {
-		turn,
-		reason: { kind: "completed" }
-	});
-}
-function appendSeedSuffixLive(session, seedSuffix) {
-	for (const event of seedSuffix) {
-		if (event.ignorable === true) {
-			const s = session;
-			s.log.push({
-				...event,
-				seq: s.log.length
-			});
-			s.eventsSnapshot = void 0;
-			continue;
-		}
-		const s = session;
-		const raw = event;
-		if (raw.surfaceOp !== void 0) s.append(event.type, event.data, {
-			surfaceOp: raw.surfaceOp,
-			...raw.sourceEventSeqs === void 0 ? {} : { sourceEventSeqs: raw.sourceEventSeqs }
-		});
-		else s.append(event.type, event.data);
-	}
-}
-var SessionEditor = class extends Service {
-	static inject = [
-		"sessionBranch",
-		"sessionPersistence",
-		"sessions"
-	];
-	constructor(ctx) {
-		super(ctx, "sessionEditor");
-		registerHttpRoutes(ctx);
-	}
-	readBranchPrefix(id, atSeq, mode, signal) {
-		return this.ctx.sessionBranch.readBranchPrefix(id, atSeq, mode, signal);
-	}
-	fork(sourceId, atSeq, childSessionId, meta, signal) {
-		return this.ctx.sessionBranch.forkFrom(sourceId, {
-			...atSeq === void 0 ? {} : { atSeq },
-			...childSessionId === void 0 ? {} : { childSessionId },
-			...meta === void 0 ? {} : { meta }
-		}, signal);
-	}
-	rewind(id, toBoundary, signal) {
-		return this.ctx.sessionBranch.rewind(id, toBoundary, signal);
-	}
-	timeline(sessionId, signal) {
-		return this.ctx.sessionBranch.timeline(sessionId, signal);
-	}
-	edit(operation, signal) {
-		return this.branchOperation(operation, signal);
-	}
-	reroll(operation, signal) {
-		return this.branchOperation(operation, signal);
-	}
-	retry(operation, signal) {
-		return this.branchOperation(operation, signal);
-	}
-	async editableMessages(sessionId, signal) {
-		return editableMessages(closedTurns(await this.readEvents(sessionId, signal)));
-	}
-	async retryableTurns(sessionId, signal) {
-		return retryableTurns(closedTurns(await this.readEvents(sessionId, signal)));
-	}
-	async branchOperation(operation, signal) {
-		signal?.throwIfAborted();
-		const events = await this.readEvents(operation.sessionId, signal);
-		const turns = closedTurns(events);
-		const plan = operation.action === "edit" ? editPlan(operation, turns) : operation.action === "retry" ? retryPlan(operation, turns) : rerollPlan(operation, turns);
-		const headerConfig = events.findLast((event) => event.type === "request/header")?.data.header.config;
-		const seedSuffix = [];
-		appendLogSeedEvent(seedSuffix, "session-branch/version", plan.version, true);
-		if (plan.manualTurn !== void 0) appendManualTurn(seedSuffix, plan.manualTurn);
-		const turnIndex = turns.findIndex((turn) => turn.startSeq === plan.anchorSeq);
-		const boundary = plan.rewindBoundary !== void 0 ? plan.rewindBoundary : turnIndex <= 0 ? -1 : turns[turnIndex - 1].endSeq;
-		const live = this.ctx.sessions.get(operation.sessionId);
-		await this.ctx.sessionBranch.rewind(operation.sessionId, boundary, signal);
-		if (seedSuffix.length > 0) {
-			if (live !== void 0) {
-				appendSeedSuffixLive(live, seedSuffix);
-				this.ctx.sessionBranch.syncLiveCursor(operation.sessionId);
-				await this.ctx.sessions.flush(live);
-			} else {
-				const rawKeepLength = boundary + (plan.rewindBoundary === void 0 ? 1 : 0);
-				const keepLength = balanceRewindPrefix(events.slice(0, rawKeepLength)).length;
-				const renumbered = seedSuffix.map((event, index) => ({
-					...event,
-					seq: keepLength + index
-				}));
-				await this.ctx.sessionPersistence.append(operation.sessionId, renumbered);
-			}
-		}
-		const queuedTurns = await this.driveAgent(operation.sessionId, plan.queuedUsers, signal, headerConfig);
-		return {
-			sessionId: operation.sessionId,
-			queuedTurns,
-			live: this.ctx.sessions.get(operation.sessionId) !== void 0
-		};
-	}
-	async readEvents(sessionId, signal) {
-		const live = this.ctx.sessions.get(sessionId);
-		if (live !== void 0) return live.snapshotEvents();
-		return (await this.ctx.sessionBranch.readRawEvents(sessionId, signal)).events;
-	}
-	async driveAgent(sessionId, queuedUsers, signal, headerConfig) {
-		if (queuedUsers.length === 0) return 0;
-		signal?.throwIfAborted();
-		if (this.ctx.get("agents") === void 0) return 0;
-		const provider = headerConfig?.provider ?? "";
-		const model = headerConfig?.model ?? "";
-		if (provider.length === 0 || model.length === 0) {
-			const config = (await this.readEvents(sessionId, signal)).findLast((event) => event.type === "request/header")?.data.header.config;
-			const fallbackProvider = config?.provider ?? "";
-			const fallbackModel = config?.model ?? "";
-			if (fallbackProvider.length === 0 || fallbackModel.length === 0) return 0;
-			return this.queueThroughAgent(sessionId, queuedUsers, signal, fallbackProvider, fallbackModel);
-		}
-		return this.queueThroughAgent(sessionId, queuedUsers, signal, provider, model);
-	}
-	async queueThroughAgent(sessionId, queuedUsers, signal, provider, model) {
-		const agents = this.ctx.get("agents");
-		if (agents === void 0) return 0;
-		const existing = agents.get(sessionId);
-		if (existing !== void 0) {
-			for (const message of queuedUsers) existing.followup(message);
-			await this.ctx.sessions.flush(existing.session);
-			return queuedUsers.length;
-		}
-		const handle = await agents.resume({
-			resumeSessionId: sessionId,
-			agentOptions: {
-				provider,
-				model
-			}
-		}).catch((error) => {
-			this.ctx.logger.warn("session-editor: agent resume failed (%s); version remains durable", String(error));
-		});
-		if (handle === void 0) return 0;
-		for (const message of queuedUsers) handle.agent.followup(message);
-		await this.ctx.sessions.flush(handle.agent.session);
-		return queuedUsers.length;
-	}
-};
-function objectValue(value) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new TypeError("请求体必须是 JSON 对象。");
-	return value;
-}
-function sessionIdOf(value) {
-	if (typeof value !== "string" || value.length === 0) throw new TypeError("sessionId 必须是非空字符串。");
-	return value;
-}
-function integerOf(value, name) {
-	if (!Number.isSafeInteger(value) || value < 0) throw new TypeError(`${name} 必须是非负安全整数。`);
-	return value;
-}
-function cascadeOf(value) {
-	if (value !== "truncate" && value !== "preserve") throw new TypeError("cascade 必须是 truncate 或 preserve。");
-	return value;
-}
-function decodeOperation(value) {
-	const record = objectValue(value);
-	const sessionId = sessionIdOf(record["sessionId"]);
-	switch (record["action"]) {
-		case "edit":
-			if (typeof record["text"] !== "string") throw new TypeError("text 必须是字符串。");
-			return {
-				action: "edit",
-				sessionId,
-				eventSeq: integerOf(record["eventSeq"], "eventSeq"),
-				blockIndex: integerOf(record["blockIndex"], "blockIndex"),
-				text: record["text"],
-				cascade: cascadeOf(record["cascade"])
-			};
-		case "reroll": return {
-			action: "reroll",
-			sessionId
-		};
-		case "retry": return {
-			action: "retry",
-			sessionId,
-			turn: integerOf(record["turn"], "turn"),
-			cascade: cascadeOf(record["cascade"])
-		};
-		case "rewind": return {
-			action: "rewind",
-			sessionId,
-			toBoundary: integerOf(record["toBoundary"], "toBoundary")
-		};
-		case "fork": return {
-			action: "fork",
-			sessionId,
-			...record["atSeq"] === void 0 ? {} : { atSeq: integerOf(record["atSeq"], "atSeq") },
-			...record["childSessionId"] === void 0 ? {} : { childSessionId: sessionIdOf(record["childSessionId"]) }
-		};
-		default: throw new TypeError("action 必须是 edit、reroll、retry、rewind 或 fork。");
-	}
-}
-function requestJson(request) {
-	return new Promise((resolve, reject) => {
-		const decoder = new TextDecoder();
-		let text = "";
-		request.on("data", (chunk) => {
-			text += typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true });
-		});
-		request.on("end", () => {
-			try {
-				text += decoder.decode();
-				resolve(JSON.parse(text));
-			} catch (error) {
-				reject(error);
-			}
-		});
-		request.on("error", reject);
-	});
-}
-function respondJson(response, status, value) {
-	response.writeHead(status, {
-		"content-type": "application/json; charset=utf-8",
-		"cache-control": "no-store"
-	});
-	response.end(JSON.stringify(value));
-}
-async function readTimeline(editor, sessionId) {
-	return toTimelinePayload(sessionId, await editor.timeline(sessionId), await editor.editableMessages(sessionId), await editor.retryableTurns(sessionId));
-}
-async function runOperation(editor, operation) {
-	switch (operation.action) {
-		case "edit": {
-			const result = await editor.edit(operation);
-			return {
-				sessionId: result.sessionId,
-				queuedTurns: result.queuedTurns,
-				...result.live === void 0 ? {} : { live: result.live }
-			};
-		}
-		case "reroll": {
-			const result = await editor.reroll(operation);
-			return {
-				sessionId: result.sessionId,
-				queuedTurns: result.queuedTurns,
-				...result.live === void 0 ? {} : { live: result.live }
-			};
-		}
-		case "retry": {
-			const result = await editor.retry(operation);
-			return {
-				sessionId: result.sessionId,
-				queuedTurns: result.queuedTurns,
-				...result.live === void 0 ? {} : { live: result.live }
-			};
-		}
-		case "rewind":
-			await editor.rewind(operation.sessionId, operation.toBoundary);
-			return {
-				sessionId: operation.sessionId,
-				queuedTurns: 0
-			};
-		case "fork": return {
-			sessionId: await editor.fork(operation.sessionId, operation.atSeq, operation.childSessionId),
-			queuedTurns: 0
-		};
-	}
-}
-async function handleRoute(editor, request, response) {
-	try {
-		if (request.method === "GET") {
-			respondJson(response, 200, await readTimeline(editor, sessionIdOf(new URL(request.url ?? "/session-editor", "http://session-editor.local").searchParams.get("sessionId"))));
-			return;
-		}
-		if (request.method === "POST") {
-			respondJson(response, 200, await runOperation(editor, decodeOperation(await requestJson(request))));
-			return;
-		}
-		response.writeHead(405);
-		response.end();
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		respondJson(response, error instanceof TypeError ? 400 : 409, { error: message });
-	}
-}
-function registerHttpRoutes(ctx) {
-	const webServer = ctx.get("webServer");
-	if (webServer === void 0) return;
-	ctx.effect(() => {
-		const editor = ctx.sessionEditor;
-		return webServer.register({
-			kind: "exact",
-			path: SESSION_EDITOR_PATH,
-			handler: (request, response) => handleRoute(editor, request, response)
-		});
-	}, "session-editor: HTTP route");
-}
-//#endregion
+import { n as SessionEditor, t as SESSION_BRANCH_VERSION_SCHEMA } from "./src-CXYW0Bc0.mjs";
+import { closedTurns, editableMessages, retryableTurns } from "./plan.mjs";
 export { SESSION_BRANCH_VERSION_SCHEMA, SessionEditor, SessionEditor as default, closedTurns, editableMessages, retryableTurns };
-
-//# sourceMappingURL=index.mjs.map

package/dist/invariant.d.mts

@@ -4,5 +4,4 @@ declare const name = "ui-conversation-message-actions-invariant";
 declare const inject: string[];
 declare const apply: (ctx: Context) => Promise<() => void>;
 //#endregion
-export { apply, inject, name };
-//# sourceMappingURL=invariant.d.mts.map
+export { apply, inject, name };

package/dist/invariant.mjs

@@ -6,5 +6,3 @@ const install = () => {};
 const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
 //#endregion
 export { apply, inject, name };
-
-//# sourceMappingURL=invariant.mjs.map