@uemcp/server 1.0.0 → 1.1.0

package/README.md

@@ -182,6 +182,36 @@ This is intended to let an MCP client resolve the canonical Unreal project ident
 - Actor paths do not survive a load: re-run `list_actors` against the new world rather than reusing paths from the old one
 - One load at a time per editor; a second request while one is running is refused with `open_level_in_progress` rather than queued
 
+### `read_data_table` / `write_data_table_row`
+
+- A DataTable is where a project keeps its tuning data, and it is a binary `.uasset` — `find_assets` can locate one but nothing can read it off disk, so these are the only way in. `read_data_table` loads the asset and reports the row struct it is typed on, an ordered column list (`{ name, type }`, using the same type rendering `get_class_reflection` emits), and each row as a column-name-to-value map
+- Values are `ExportText`, the same format `get_actor_details` and `get_cdo_defaults` emit and `set_actor_property` accepts, so a value read here writes straight back with no translation. Column names are the **authored** names, so a Blueprint (user-defined) row struct reports the names the editor shows rather than its mangled internal ones
+- Rows page in **name order** — `RowMap` iteration follows hashing, which shifts as rows are added, so a cursor over it would skip or repeat rows between pages. Pages are trimmed by encoded bytes as well as by `maxRows`, because one row of a wide tuning struct can cost more than a whole page of asset entries; `totalRowCount` stays authoritative when a page truncates
+- `loadIfNeeded: false` refuses to load an unloaded table and reports `asset_not_loaded`. Unlike `get_blueprint_summary` there is no metadata-only fallback: a DataTable carries no Asset Registry tags describing its rows
+- `write_data_table_row` upserts or deletes one row. **Every column name and value is validated against the row struct before anything is written**, into scratch memory that is only copied in once the whole row imports, so a rejected write leaves the table byte-identical — there is no partial application. An unknown column reports `unknown_column` and lists the valid ones; a value that will not parse reports `invalid_row_value` and names the field and its type
+- Numeric and boolean values are range-checked **before** `ImportText` rather than after: the engine's importer takes `not-a-number` as `0` and reports success, and silent coercion is exactly the failure a tuning-data write cannot afford
+- The write runs inside a single `FScopedTransaction` (Ctrl+Z reverses it) and marks the package dirty **without saving** — compose with `save_dirty_packages`. `dryRun: true` validates everything and reports `state: 'validated'`, opening no transaction
+- Deleting a row that does not exist is **not** a failure: it reports `rowExisted: false` with an explanatory message, because the table is already in the requested state
+- A `.uasset` sits read-only on disk until it is checked out under Perforce or Git-LFS file locking. That case is detected before anything is mutated and reported as `source_control_checkout_required` rather than surfacing later as an unexplained save error
+- In a non-editor plugin build `read_data_table` fails with `unsupported` and `write_data_table_row` returns `state: 'unsupported'`
+
+### `export_data_table` / `import_data_table`
+
+- The bulk half, built on the engine's own JSON and CSV serializers rather than the per-row walk above
+- `export_data_table` returns the serialized table in **chunks by character offset**, because the engine produces one string rather than anything row-addressable. Concatenate chunks in `nextCursor` order to reassemble; a single chunk is not valid JSON or CSV on its own. Chunks are cut by encoded byte cost and never inside a surrogate pair
+- `import_data_table` **replaces every row** — that is what the engine's importer does, so a row absent from the content is a row deleted. Use `write_data_table_row` to change one value. It runs in one transaction and dirties the package without saving, exactly like the per-row write
+- Rows the importer rejects come back in `problems` while the rest still apply, so check `problemCount` even on success. `dryRun: true` runs the import against a transient duplicate and reports the resulting row count and problems without touching the real table
+- The whole payload travels in one 64 KiB bridge frame, so `content` is capped at `BRIDGE_DATA_TABLE_MAX_IMPORT_CHARS` (16 K characters, sized so worst-case UTF-8 expansion still fits). A table larger than that cannot be imported this way
+
+### `create_data_table` / `rename_data_table` / `delete_data_table` / `rename_data_table_row`
+
+- The lifecycle half: the tools above all require a table that already exists, and until these landed nothing could make one over the bridge
+- `create_data_table` binds a row struct at creation and never after — `UDataTable::RowStruct` can be reassigned, but that reinterprets existing row memory through the new layout, so the bridge does not expose it. Native structs are addressed as `/Script/<Module>.<Struct>`, a Blueprint struct by its object path; anything that is neither an `FTableRowBase` child nor a user-defined struct reports `invalid_row_struct` rather than producing a table that accepts no rows. The new table is dirty and **unsaved**, like every other DataTable write
+- `rename_data_table` renames, moves, or both — one operation to the asset tools. References from other assets are fixed up and a redirector is left at the old path, so existing hard references keep resolving. `newName` must be a bare asset name: one carrying a path separator is refused rather than silently relocating the asset somewhere the caller never named
+- `delete_data_table` is **the one DataTable tool with no transaction behind it** — asset deletion is not undoable, and there is no dirty-package step to reconsider at. A table other assets reference is refused with `asset_referenced` and its referencers reported; `force` deletes anyway and breaks them
+- `rename_data_table_row` keeps the row's position and values, which an upsert-under-the-new-name plus a delete-of-the-old does not: that pair costs two transactions and moves the row to the end. It refuses a missing row (`row_not_found`) and a name already taken (`row_already_exists`), since renaming onto an existing row would discard that row's values. **Row names are how other assets address rows**, so a rename breaks any `FDataTableRowHandle` pointing at the old name — nothing fixes those up
+- Rename and delete both need referencer data, which is only trustworthy once the Asset Registry's initial gather has finished — mid-scan `GetReferencers` returns a short list that reads as "nothing depends on this". Both drive the scan to completion first (starting it when a headless editor never did), and report `asset_registry_scanning` only if it is still incomplete afterwards. On a large project that wait can be long enough to hit the bridge read timeout
+
 ## MCP Resources
 
 Resources carry context a client can attach without spending a tool call and a model turn. Every one of them is served from in-memory state or the local filesystem: **a resource read never opens a bridge socket and never waits on the editor**, so an unreachable or absent editor produces a structured payload rather than a timeout.

package/dist/index.mjs

@@ -459,6 +459,24 @@ const BRIDGE_OPEN_LEVEL_STATUS_STATES = [
 	"failed",
 	"unknown_job"
 ];
+const BRIDGE_READ_DATA_TABLE_REQUEST_TYPE = "read_data_table";
+const BRIDGE_WRITE_DATA_TABLE_ROW_REQUEST_TYPE = "write_data_table_row";
+const BRIDGE_EXPORT_DATA_TABLE_REQUEST_TYPE = "export_data_table";
+const BRIDGE_IMPORT_DATA_TABLE_REQUEST_TYPE = "import_data_table";
+const BRIDGE_CREATE_DATA_TABLE_REQUEST_TYPE = "create_data_table";
+const BRIDGE_RENAME_DATA_TABLE_REQUEST_TYPE = "rename_data_table";
+const BRIDGE_DELETE_DATA_TABLE_REQUEST_TYPE = "delete_data_table";
+const BRIDGE_RENAME_DATA_TABLE_ROW_REQUEST_TYPE = "rename_data_table_row";
+const BRIDGE_DATA_TABLE_VALUE_MAX_CHARS = 4096;
+const BRIDGE_DATA_TABLE_ROW_OPERATIONS = ["upsert", "delete"];
+const BRIDGE_DATA_TABLE_WRITE_STATES = [
+	"applied",
+	"validated",
+	"unsupported"
+];
+const BRIDGE_DATA_TABLE_FORMATS = ["json", "csv"];
+const BRIDGE_DATA_TABLE_MAX_EXPORT_CHARS = 24576;
+const BRIDGE_DATA_TABLE_MAX_IMPORT_CHARS = 16384;
 const requestIdSchema = z.string().trim().min(1);
 const nonEmptyStringSchema = z.string().trim().min(1);
 const boundedStringSchema = z.string().trim().max(512);
@@ -568,6 +586,15 @@ const openLevelJobIdSchema = z.string().trim().min(1);
 const levelPathSchema = z.string().trim().min(1).max(512);
 const actorPathBatchSchema = z.array(actorPathSchema).min(1).max(64);
 const actorTagArraySchema = z.array(boundedStringSchema).max(16);
+const dataTableCursorSchema = z.number().int().min(0);
+const dataTableMaxRowsSchema = z.number().int().min(1).max(100);
+const dataTableRowNameSchema = z.string().trim().min(1).max(256);
+const dataTableRowOperationSchema = z.enum(BRIDGE_DATA_TABLE_ROW_OPERATIONS);
+const dataTableWriteStateSchema = z.enum(BRIDGE_DATA_TABLE_WRITE_STATES);
+const dataTableFormatSchema = z.enum(BRIDGE_DATA_TABLE_FORMATS);
+const dataTableValueMapSchema = z.record(z.string().trim().min(1).max(256), z.string().max(BRIDGE_DATA_TABLE_VALUE_MAX_CHARS)).refine((value) => Object.keys(value).length <= 200, { message: `A write carries at most ${String(200)} columns.` });
+const dataTableImportContentSchema = z.string().min(1).max(BRIDGE_DATA_TABLE_MAX_IMPORT_CHARS);
+const dataTableAssetNameSchema = z.string().trim().min(1).max(256).refine((value) => !value.includes("/") && !value.includes("."), { message: "An asset name must not contain a path separator; use destinationPath to move the asset." });
 const vectorInputSchema = z.object({
 	x: z.number().default(0),
 	y: z.number().default(0),
@@ -972,6 +999,87 @@ const bridgeGetOpenLevelStatusRequestSchema = z.object({
 	type: z.literal(BRIDGE_GET_OPEN_LEVEL_STATUS_REQUEST_TYPE),
 	version: z.literal(2)
 });
+const bridgeReadDataTableRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	cursor: dataTableCursorSchema.default(0),
+	loadIfNeeded: z.boolean().default(true),
+	maxRows: dataTableMaxRowsSchema,
+	rowNameFilter: boundedStringSchema.optional(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_READ_DATA_TABLE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeWriteDataTableRowRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	dryRun: z.boolean().default(false),
+	operation: dataTableRowOperationSchema,
+	rowName: dataTableRowNameSchema,
+	values: dataTableValueMapSchema.optional(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_WRITE_DATA_TABLE_ROW_REQUEST_TYPE),
+	version: z.literal(2)
+}).refine((value) => value.operation !== "upsert" || value.values !== void 0, {
+	message: "A write_data_table_row upsert requires values.",
+	path: ["values"]
+}).refine((value) => value.operation !== "delete" || value.values === void 0, {
+	message: "A write_data_table_row delete must not carry values.",
+	path: ["values"]
+});
+const bridgeExportDataTableRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	cursor: dataTableCursorSchema.default(0),
+	format: dataTableFormatSchema.default("json"),
+	loadIfNeeded: z.boolean().default(true),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_EXPORT_DATA_TABLE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeImportDataTableRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	content: dataTableImportContentSchema,
+	dryRun: z.boolean().default(false),
+	format: dataTableFormatSchema.default("json"),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_IMPORT_DATA_TABLE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeCreateDataTableRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	dryRun: z.boolean().default(false),
+	rowStructPath: assetPathSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_CREATE_DATA_TABLE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeRenameDataTableRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	destinationPath: assetPathSchema.optional(),
+	dryRun: z.boolean().default(false),
+	newName: dataTableAssetNameSchema.optional(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_RENAME_DATA_TABLE_REQUEST_TYPE),
+	version: z.literal(2)
+}).refine((value) => value.newName !== void 0 || value.destinationPath !== void 0, {
+	message: "A rename_data_table requires a newName, a destinationPath, or both.",
+	path: ["newName"]
+});
+const bridgeDeleteDataTableRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	dryRun: z.boolean().default(false),
+	force: z.boolean().default(false),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_DELETE_DATA_TABLE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeRenameDataTableRowRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	dryRun: z.boolean().default(false),
+	newRowName: dataTableRowNameSchema,
+	rowName: dataTableRowNameSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_RENAME_DATA_TABLE_ROW_REQUEST_TYPE),
+	version: z.literal(2)
+});
 const bridgeGetAssetDependenciesRequestSchema = z.object({
 	assetPath: assetPathSchema,
 	categories: z.array(assetDependencyCategorySchema).max(BRIDGE_ASSET_DEPENDENCY_CATEGORIES.length).default(["package"]),
@@ -1714,6 +1822,127 @@ const bridgeGetOpenLevelStatusSuccessResponseSchema = z.object({
 		path: ["finishedAt"]
 	});
 });
+const bridgeDataTableColumnSchema = z.object({
+	name: z.string(),
+	type: z.string()
+});
+const bridgeDataTableRowSchema = z.object({
+	rowName: z.string(),
+	values: z.record(z.string(), z.string())
+});
+const bridgeReadDataTableSuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	columns: z.array(bridgeDataTableColumnSchema).max(200),
+	columnsTruncated: z.boolean(),
+	nextCursor: dataTableCursorSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	rows: z.array(bridgeDataTableRowSchema).max(100),
+	rowStructName: z.string(),
+	rowStructPath: z.string(),
+	totalRowCount: z.number().int().min(0),
+	truncated: z.boolean(),
+	type: z.literal(BRIDGE_READ_DATA_TABLE_REQUEST_TYPE),
+	valueTruncated: z.boolean(),
+	version: z.literal(2)
+});
+const bridgeWriteDataTableRowSuccessResponseSchema = z.object({
+	applied: dataTableRowOperationSchema,
+	assetPath: z.string(),
+	created: z.boolean(),
+	dryRun: z.boolean(),
+	message: z.string().trim().min(1).optional(),
+	ok: z.literal(true),
+	packageDirty: z.boolean(),
+	requestId: requestIdSchema,
+	rowExisted: z.boolean(),
+	rowName: z.string(),
+	state: dataTableWriteStateSchema,
+	transactionTitle: z.string().trim().min(1).optional(),
+	type: z.literal(BRIDGE_WRITE_DATA_TABLE_ROW_REQUEST_TYPE),
+	version: z.literal(2)
+}).refine(isLevelEditStateConsistent, levelEditStateRefinement);
+const bridgeExportDataTableSuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	content: z.string().max(BRIDGE_DATA_TABLE_MAX_EXPORT_CHARS),
+	format: dataTableFormatSchema,
+	nextCursor: dataTableCursorSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	rowCount: z.number().int().min(0),
+	totalChars: z.number().int().min(0),
+	truncated: z.boolean(),
+	type: z.literal(BRIDGE_EXPORT_DATA_TABLE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeImportDataTableSuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	dryRun: z.boolean(),
+	message: z.string().trim().min(1).optional(),
+	ok: z.literal(true),
+	packageDirty: z.boolean(),
+	problemCount: z.number().int().min(0),
+	problems: z.array(z.string()).max(50),
+	replacedRowCount: z.number().int().min(0),
+	requestId: requestIdSchema,
+	rowCount: z.number().int().min(0),
+	state: dataTableWriteStateSchema,
+	transactionTitle: z.string().trim().min(1).optional(),
+	type: z.literal(BRIDGE_IMPORT_DATA_TABLE_REQUEST_TYPE),
+	version: z.literal(2)
+}).refine(isLevelEditStateConsistent, levelEditStateRefinement);
+const bridgeCreateDataTableSuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	created: z.boolean(),
+	dryRun: z.boolean(),
+	ok: z.literal(true),
+	packageDirty: z.boolean(),
+	requestId: requestIdSchema,
+	rowStructPath: z.string(),
+	state: dataTableWriteStateSchema,
+	type: z.literal(BRIDGE_CREATE_DATA_TABLE_REQUEST_TYPE),
+	version: z.literal(2)
+}).refine(isLevelEditStateConsistent, levelEditStateRefinement);
+const bridgeRenameDataTableSuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	dryRun: z.boolean(),
+	leftRedirector: z.boolean().optional(),
+	newAssetPath: z.string(),
+	ok: z.literal(true),
+	packageDirty: z.boolean(),
+	renamed: z.boolean(),
+	requestId: requestIdSchema,
+	state: dataTableWriteStateSchema,
+	type: z.literal(BRIDGE_RENAME_DATA_TABLE_REQUEST_TYPE),
+	version: z.literal(2)
+}).refine(isLevelEditStateConsistent, levelEditStateRefinement);
+const bridgeDeleteDataTableSuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	deleted: z.boolean(),
+	dryRun: z.boolean(),
+	forced: z.boolean(),
+	ok: z.literal(true),
+	referencerCount: z.number().int().min(0),
+	referencers: z.array(z.string()).max(25),
+	requestId: requestIdSchema,
+	state: dataTableWriteStateSchema,
+	type: z.literal(BRIDGE_DELETE_DATA_TABLE_REQUEST_TYPE),
+	version: z.literal(2)
+}).refine(isLevelEditStateConsistent, levelEditStateRefinement);
+const bridgeRenameDataTableRowSuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	dryRun: z.boolean(),
+	newRowName: z.string(),
+	ok: z.literal(true),
+	packageDirty: z.boolean(),
+	renamed: z.boolean(),
+	requestId: requestIdSchema,
+	rowName: z.string(),
+	state: dataTableWriteStateSchema,
+	transactionTitle: z.string().trim().min(1).optional(),
+	type: z.literal(BRIDGE_RENAME_DATA_TABLE_ROW_REQUEST_TYPE),
+	version: z.literal(2)
+}).refine(isLevelEditStateConsistent, levelEditStateRefinement);
 const bridgeAssetDependencySchema = z.object({
 	category: assetDependencyCategorySchema,
 	isHard: z.boolean(),
@@ -1991,6 +2220,14 @@ const bridgeUndoResponseSchema = z.union([bridgeUndoSuccessResponseSchema, bridg
 const bridgeRedoResponseSchema = z.union([bridgeRedoSuccessResponseSchema, bridgeErrorResponseSchema]);
 const bridgeOpenLevelResponseSchema = z.union([bridgeOpenLevelSuccessResponseSchema, bridgeErrorResponseSchema]);
 const bridgeGetOpenLevelStatusResponseSchema = z.union([bridgeGetOpenLevelStatusSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeReadDataTableResponseSchema = z.union([bridgeReadDataTableSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeWriteDataTableRowResponseSchema = z.union([bridgeWriteDataTableRowSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeExportDataTableResponseSchema = z.union([bridgeExportDataTableSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeImportDataTableResponseSchema = z.union([bridgeImportDataTableSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeCreateDataTableResponseSchema = z.union([bridgeCreateDataTableSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeRenameDataTableResponseSchema = z.union([bridgeRenameDataTableSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeDeleteDataTableResponseSchema = z.union([bridgeDeleteDataTableSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeRenameDataTableRowResponseSchema = z.union([bridgeRenameDataTableRowSuccessResponseSchema, bridgeErrorResponseSchema]);
 const bridgeFindAssetsResponseSchema = z.union([bridgeFindAssetsSuccessResponseSchema, bridgeErrorResponseSchema]);
 const bridgeGetAssetDependenciesResponseSchema = z.union([bridgeGetAssetDependenciesSuccessResponseSchema, bridgeErrorResponseSchema]);
 const bridgeFindBlueprintReferencesResponseSchema = z.union([bridgeFindBlueprintReferencesSuccessResponseSchema, bridgeErrorResponseSchema]);
@@ -2002,6 +2239,94 @@ const bridgeGetBlueprintCompileStatusResponseSchema = z.union([bridgeGetBlueprin
 const bridgeGetConfigValueResponseSchema = z.union([bridgeGetConfigValueSuccessResponseSchema, bridgeErrorResponseSchema]);
 const bridgeSetConfigValueResponseSchema = z.union([bridgeSetConfigValueSuccessResponseSchema, bridgeErrorResponseSchema]);
 const bridgeListConfigSectionResponseSchema = z.union([bridgeListConfigSectionSuccessResponseSchema, bridgeErrorResponseSchema]);
+function createBridgeReadDataTableRequest(assetPath, options = {}, requestId = randomUUID()) {
+	return bridgeReadDataTableRequestSchema.parse({
+		assetPath,
+		cursor: options.cursor,
+		loadIfNeeded: options.loadIfNeeded,
+		maxRows: options.maxRows ?? 25,
+		requestId,
+		rowNameFilter: options.rowNameFilter,
+		type: BRIDGE_READ_DATA_TABLE_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeWriteDataTableRowRequest(assetPath, rowName, operation, options = {}, requestId = randomUUID()) {
+	return bridgeWriteDataTableRowRequestSchema.parse({
+		assetPath,
+		dryRun: options.dryRun,
+		operation,
+		requestId,
+		rowName,
+		type: BRIDGE_WRITE_DATA_TABLE_ROW_REQUEST_TYPE,
+		values: options.values,
+		version: 2
+	});
+}
+function createBridgeExportDataTableRequest(assetPath, options = {}, requestId = randomUUID()) {
+	return bridgeExportDataTableRequestSchema.parse({
+		assetPath,
+		cursor: options.cursor,
+		format: options.format,
+		loadIfNeeded: options.loadIfNeeded,
+		requestId,
+		type: BRIDGE_EXPORT_DATA_TABLE_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeImportDataTableRequest(assetPath, content, options = {}, requestId = randomUUID()) {
+	return bridgeImportDataTableRequestSchema.parse({
+		assetPath,
+		content,
+		dryRun: options.dryRun,
+		format: options.format,
+		requestId,
+		type: BRIDGE_IMPORT_DATA_TABLE_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeCreateDataTableRequest(assetPath, rowStructPath, options = {}, requestId = randomUUID()) {
+	return bridgeCreateDataTableRequestSchema.parse({
+		assetPath,
+		dryRun: options.dryRun,
+		requestId,
+		rowStructPath,
+		type: BRIDGE_CREATE_DATA_TABLE_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeRenameDataTableRequest(assetPath, options = {}, requestId = randomUUID()) {
+	return bridgeRenameDataTableRequestSchema.parse({
+		assetPath,
+		destinationPath: options.destinationPath,
+		dryRun: options.dryRun,
+		newName: options.newName,
+		requestId,
+		type: BRIDGE_RENAME_DATA_TABLE_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeDeleteDataTableRequest(assetPath, options = {}, requestId = randomUUID()) {
+	return bridgeDeleteDataTableRequestSchema.parse({
+		assetPath,
+		dryRun: options.dryRun,
+		force: options.force,
+		requestId,
+		type: BRIDGE_DELETE_DATA_TABLE_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeRenameDataTableRowRequest(assetPath, rowName, newRowName, options = {}, requestId = randomUUID()) {
+	return bridgeRenameDataTableRowRequestSchema.parse({
+		assetPath,
+		dryRun: options.dryRun,
+		newRowName,
+		requestId,
+		rowName,
+		type: BRIDGE_RENAME_DATA_TABLE_ROW_REQUEST_TYPE,
+		version: 2
+	});
+}
 function createBridgeFindAssetsRequest(options = {}, requestId = randomUUID()) {
 	return bridgeFindAssetsRequestSchema.parse({
 		classNames: options.classNames,
@@ -2569,6 +2894,30 @@ async function sendBridgeStartTraceRequest(request, options) {
 async function sendBridgeStopTraceRequest(request, options) {
 	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeStopTraceResponseSchema, request.requestId);
 }
+async function sendBridgeReadDataTableRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeReadDataTableResponseSchema, request.requestId);
+}
+async function sendBridgeWriteDataTableRowRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeWriteDataTableRowResponseSchema, request.requestId);
+}
+async function sendBridgeExportDataTableRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeExportDataTableResponseSchema, request.requestId);
+}
+async function sendBridgeImportDataTableRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeImportDataTableResponseSchema, request.requestId);
+}
+async function sendBridgeCreateDataTableRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeCreateDataTableResponseSchema, request.requestId);
+}
+async function sendBridgeRenameDataTableRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeRenameDataTableResponseSchema, request.requestId);
+}
+async function sendBridgeDeleteDataTableRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeDeleteDataTableResponseSchema, request.requestId);
+}
+async function sendBridgeRenameDataTableRowRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeRenameDataTableRowResponseSchema, request.requestId);
+}
 async function sendBridgeFindAssetsRequest(request, options) {
 	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeFindAssetsResponseSchema, request.requestId);
 }
@@ -5747,6 +6096,62 @@ const findAssetsInputSchema = {
 	recursiveClasses: bridgeFindAssetsRequestSchema.shape.recursiveClasses.describe("Whether classNames also match subclasses (default true)."),
 	recursivePaths: bridgeFindAssetsRequestSchema.shape.recursivePaths.describe("Whether packagePaths also match sub-folders (default true).")
 };
+const readDataTableInputSchema = {
+	assetPath: bridgeReadDataTableRequestSchema.shape.assetPath.describe("Object path of the DataTable asset, as find_assets reports it (e.g. /Game/Data/DT_Weapons.DT_Weapons)."),
+	cursor: bridgeReadDataTableRequestSchema.shape.cursor.describe("Offset into the name-ordered row list (default 0). Pass the previous response nextCursor to fetch the next page."),
+	loadIfNeeded: bridgeReadDataTableRequestSchema.shape.loadIfNeeded.describe("Whether to load the asset when the editor does not already have it in memory (default true). A DataTable carries no Asset Registry tags describing its rows, so with this false an unloaded table reports asset_not_loaded rather than an empty table."),
+	maxRows: bridgeReadDataTableRequestSchema.shape.maxRows.default(25).describe("Maximum number of rows to return per page (1-100, default 25). totalRowCount still reports the unbounded row count."),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor holds the DataTable."),
+	rowNameFilter: bridgeReadDataTableRequestSchema.shape.rowNameFilter.describe("Optional case-insensitive substring matched against each row name, applied before paging.")
+};
+const writeDataTableRowInputSchema = {
+	assetPath: bridgeWriteDataTableRowRequestSchema.shape.assetPath.describe("Object path of the DataTable asset to write (e.g. /Game/Data/DT_Weapons.DT_Weapons)."),
+	dryRun: bridgeWriteDataTableRowRequestSchema.shape.dryRun.describe("When true, resolve the row struct and validate every column and value without opening a transaction or dirtying the package (default false)."),
+	operation: bridgeWriteDataTableRowRequestSchema.shape.operation.describe("'upsert' inserts the row or replaces it if it already exists; 'delete' removes it by name. Deleting a row that is not there is reported through rowExisted=false, not as an error."),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor holds the DataTable."),
+	rowName: bridgeWriteDataTableRowRequestSchema.shape.rowName.describe("Name of the row to write or delete, as read_data_table reports it."),
+	values: bridgeWriteDataTableRowRequestSchema.shape.values.describe("Column name to value, in the same ExportText format read_data_table emits (required for upsert, forbidden for delete). Every column and value is validated against the row struct before anything is written: an unknown column or a value that will not parse rejects the whole write, so a row is never partially applied. Columns omitted on an upsert of an existing row keep their current value.")
+};
+const exportDataTableInputSchema = {
+	assetPath: bridgeExportDataTableRequestSchema.shape.assetPath.describe("Object path of the DataTable asset to export (e.g. /Game/Data/DT_Weapons.DT_Weapons)."),
+	cursor: bridgeExportDataTableRequestSchema.shape.cursor.describe("Character offset into the serialized table (default 0). Pass the previous response nextCursor to fetch the next chunk."),
+	format: bridgeExportDataTableRequestSchema.shape.format.describe("Serialization to use: 'json' (default) or 'csv'. Both come from the engine's own DataTable exporters."),
+	loadIfNeeded: bridgeExportDataTableRequestSchema.shape.loadIfNeeded.describe("Whether to load the asset when the editor does not already have it in memory (default true)."),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor holds the DataTable.")
+};
+const importDataTableInputSchema = {
+	assetPath: bridgeImportDataTableRequestSchema.shape.assetPath.describe("Object path of the DataTable asset to overwrite (e.g. /Game/Data/DT_Weapons.DT_Weapons)."),
+	content: bridgeImportDataTableRequestSchema.shape.content.describe(`Complete serialized table in the chosen format, up to ${String(BRIDGE_DATA_TABLE_MAX_IMPORT_CHARS)} characters — the whole payload travels in one bridge frame, so a table larger than that cannot be imported this way. This REPLACES every row: a row absent from the content is deleted.`),
+	dryRun: bridgeImportDataTableRequestSchema.shape.dryRun.describe("When true, parse the content and report the row count and problems without replacing anything (default false)."),
+	format: bridgeImportDataTableRequestSchema.shape.format.describe("Serialization the content is in: 'json' (default) or 'csv'."),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor holds the DataTable.")
+};
+const createDataTableInputSchema = {
+	assetPath: bridgeCreateDataTableRequestSchema.shape.assetPath.describe("Object path for the new DataTable, e.g. /Game/Data/DT_Weapons. Fails if an asset already exists there."),
+	dryRun: bridgeCreateDataTableRequestSchema.shape.dryRun.describe("When true, resolve and validate the row struct and destination without creating anything (default false)."),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor should create the table."),
+	rowStructPath: bridgeCreateDataTableRequestSchema.shape.rowStructPath.describe("Struct backing every row. Native structs use /Script/<Module>.<Struct>; a Blueprint struct uses its object path. Must derive FTableRowBase. Cannot be changed after creation.")
+};
+const renameDataTableInputSchema = {
+	assetPath: bridgeRenameDataTableRequestSchema.shape.assetPath.describe("Object path of the DataTable to rename or move (e.g. /Game/Data/DT_Weapons.DT_Weapons)."),
+	destinationPath: bridgeRenameDataTableRequestSchema.shape.destinationPath.describe("Package path to move the asset into, e.g. /Game/Data/Archive. Omit to keep it where it is."),
+	dryRun: bridgeRenameDataTableRequestSchema.shape.dryRun.describe("When true, validate the destination without moving anything (default false)."),
+	newName: bridgeRenameDataTableRequestSchema.shape.newName.describe("New asset name without any path, e.g. DT_WeaponsLegacy. Omit to keep the current name."),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor holds the DataTable.")
+};
+const deleteDataTableInputSchema = {
+	assetPath: bridgeDeleteDataTableRequestSchema.shape.assetPath.describe("Object path of the DataTable to delete (e.g. /Game/Data/DT_Weapons.DT_Weapons)."),
+	dryRun: bridgeDeleteDataTableRequestSchema.shape.dryRun.describe("When true, report what would be deleted and what still references it, without deleting (default false)."),
+	force: bridgeDeleteDataTableRequestSchema.shape.force.describe("Delete even when other assets reference the table, breaking those references (default false). Without it a referenced table is refused and its referencers are reported."),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor holds the DataTable.")
+};
+const renameDataTableRowInputSchema = {
+	assetPath: bridgeRenameDataTableRowRequestSchema.shape.assetPath.describe("Object path of the DataTable holding the row (e.g. /Game/Data/DT_Weapons.DT_Weapons)."),
+	dryRun: bridgeRenameDataTableRowRequestSchema.shape.dryRun.describe("When true, validate both names without renaming anything (default false)."),
+	newRowName: bridgeRenameDataTableRowRequestSchema.shape.newRowName.describe("Name to rename the row to. Fails if a row already uses it."),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor holds the DataTable."),
+	rowName: bridgeRenameDataTableRowRequestSchema.shape.rowName.describe("Current name of the row to rename.")
+};
 const listActorsInputSchema = {
 	classNames: bridgeListActorsRequestSchema.shape.classNames.describe("Actor class names to match, either short (StaticMeshActor, PointLight) or full class paths (/Script/Engine.StaticMeshActor, /Game/BP/BP_Foo.BP_Foo_C). Subclasses match too. Empty means every class."),
 	cursor: bridgeListActorsRequestSchema.shape.cursor.describe("Offset into the stable-ordered matched list (default 0). Pass the previous response nextCursor to fetch the next page."),
@@ -6464,6 +6869,110 @@ function registerMcpTools(server, dependencies) {
 			recursivePaths
 		}, dependencies));
 	});
+	server.registerTool("read_data_table", {
+		description: "Read a DataTable asset's contents: the row struct it is typed on, its ordered column list (name plus the same type rendering get_class_reflection emits), and its rows as column-name-to-value maps. Values are ExportText, the format write_data_table_row accepts back, so a value read here round-trips. Rows are paged by name order: pass the previous response nextCursor to fetch the next page (totalRowCount reports the full count). A DataTable is a binary .uasset with no Asset Registry tags describing its rows, so there is no way to read one off disk instead — this tool loads it.",
+		inputSchema: readDataTableInputSchema,
+		title: "Read Data Table"
+	}, async ({ assetPath, cursor, loadIfNeeded, maxRows, projectId, rowNameFilter }) => {
+		return toToolSuccess(await readDataTable({
+			assetPath,
+			cursor,
+			loadIfNeeded,
+			maxRows,
+			projectId,
+			rowNameFilter
+		}, dependencies));
+	});
+	server.registerTool("write_data_table_row", {
+		description: "Insert, update, or delete a single DataTable row. Every column name and value is validated against the row struct before anything is written — an unknown column or a value that will not parse rejects the whole write with an error naming the field, so a row is never partially applied and there is no silent coercion. The write runs inside one transaction, so a human at the editor can Ctrl+Z it, and it marks the package dirty without saving: call save_dirty_packages to persist. Deleting a row that does not exist reports rowExisted=false rather than failing. Use dryRun to validate first. For a whole-table replace use import_data_table instead.",
+		inputSchema: writeDataTableRowInputSchema,
+		title: "Write Data Table Row"
+	}, async ({ assetPath, dryRun, operation, projectId, rowName, values }) => {
+		return toToolSuccess(await writeDataTableRow({
+			assetPath,
+			dryRun,
+			operation,
+			projectId,
+			rowName,
+			values
+		}, dependencies));
+	});
+	server.registerTool("export_data_table", {
+		description: "Serialize a whole DataTable through the engine's own JSON or CSV exporter. Returned in chunks by character offset because the engine produces one string rather than something row-addressable: concatenate the chunks in cursor order to reassemble, and note a single chunk is not valid JSON or CSV on its own. Use read_data_table when you want structured, per-row access; use this when you want the table in the same text form the editor's own export produces.",
+		inputSchema: exportDataTableInputSchema,
+		title: "Export Data Table"
+	}, async ({ assetPath, cursor, format, loadIfNeeded, projectId }) => {
+		return toToolSuccess(await exportDataTable({
+			assetPath,
+			cursor,
+			format,
+			loadIfNeeded,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("import_data_table", {
+		description: "REPLACE every row of a DataTable from a JSON or CSV payload, using the engine's own importer. This is destructive: any row not present in the content is deleted, so it is the wrong tool for changing one value — use write_data_table_row for that. The whole payload travels in one bridge frame, so a table beyond the content character bound cannot be imported this way. Runs inside one transaction (Ctrl+Z reverses it) and marks the package dirty without saving. Rows the importer rejects come back in problems while the rest still apply, so check problemCount even on success; dryRun reports the row count and problems without replacing anything.",
+		inputSchema: importDataTableInputSchema,
+		title: "Import Data Table"
+	}, async ({ assetPath, content, dryRun, format, projectId }) => {
+		return toToolSuccess(await importDataTable({
+			assetPath,
+			content,
+			dryRun,
+			format,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("create_data_table", {
+		description: "Create a new empty DataTable asset backed by a row struct. The struct is fixed at creation — UDataTable can have its RowStruct swapped later, but that reinterprets existing rows through the new layout, so the bridge does not expose it; create a new table instead. The struct must derive FTableRowBase, and creation fails if an asset already exists at the path. The new table is marked dirty but not written to disk: call save_dirty_packages to persist it, or it disappears when the editor closes. Use read_data_table to confirm the column set the struct produced.",
+		inputSchema: createDataTableInputSchema,
+		title: "Create Data Table"
+	}, async ({ assetPath, dryRun, projectId, rowStructPath }) => {
+		return toToolSuccess(await createDataTable({
+			assetPath,
+			dryRun,
+			projectId,
+			rowStructPath
+		}, dependencies));
+	});
+	server.registerTool("rename_data_table", {
+		description: "Rename a DataTable, move it to another package path, or both. Goes through the editor's asset tools, so references from other assets are fixed up and a redirector is left at the old path to keep hard references resolving. Renaming is not a transaction the editor can Ctrl+Z — it rewrites packages on disk. Use dryRun to check the destination is free first.",
+		inputSchema: renameDataTableInputSchema,
+		title: "Rename Data Table"
+	}, async ({ assetPath, destinationPath, dryRun, newName, projectId }) => {
+		return toToolSuccess(await renameDataTable({
+			assetPath,
+			destinationPath,
+			dryRun,
+			newName,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("delete_data_table", {
+		description: "Delete a DataTable asset from the project. This is the one DataTable tool that cannot be undone — asset deletion is not a transaction, so there is no Ctrl+Z and no dirty-package step to reconsider at. A table other assets still reference is refused, and those referencers are reported; force deletes anyway and breaks them. Always dryRun first on a table you did not create: it reports the referencers without touching anything.",
+		inputSchema: deleteDataTableInputSchema,
+		title: "Delete Data Table"
+	}, async ({ assetPath, dryRun, force, projectId }) => {
+		return toToolSuccess(await deleteDataTable({
+			assetPath,
+			dryRun,
+			force,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("rename_data_table_row", {
+		description: "Rename a single row, keeping its position in the table and its values intact. Not the same as an upsert under the new name followed by a delete of the old one: that pair costs two transactions and moves the row to the end. Fails if the row does not exist or the new name is already taken. Runs inside one transaction (Ctrl+Z reverses it) and marks the package dirty without saving. Note that row names are how other assets address rows, so a rename breaks any FDataTableRowHandle pointing at the old name — nothing fixes those up.",
+		inputSchema: renameDataTableRowInputSchema,
+		title: "Rename Data Table Row"
+	}, async ({ assetPath, dryRun, newRowName, projectId, rowName }) => {
+		return toToolSuccess(await renameDataTableRow({
+			assetPath,
+			dryRun,
+			newRowName,
+			projectId,
+			rowName
+		}, dependencies));
+	});
 	server.registerTool("get_asset_dependencies", {
 		description: "Report an asset's package-level dependencies (what it needs) and referencers (what needs it) from the Unreal Asset Registry — the Reference Viewer data — so you can judge the blast radius before changing it. Depth is 1: transitive links are not walked. Each list pages independently via nextDependencyCursor / nextReferencerCursor.",
 		inputSchema: getAssetDependenciesInputSchema,
@@ -6864,6 +7373,213 @@ async function findAssets(input, dependencies) {
 		truncated: response.truncated
 	};
 }
+async function readDataTable(input, dependencies) {
+	const normalizedProjectId = projectIdSchema.parse(input.projectId);
+	const entry = dependencies.registry.getProject(normalizedProjectId);
+	if (!entry) throw new Error(`No registered Unreal engine was found for projectId '${normalizedProjectId}'.`);
+	const response = await sendBridgeReadDataTableRequest(createBridgeReadDataTableRequest(input.assetPath, {
+		cursor: input.cursor,
+		loadIfNeeded: input.loadIfNeeded,
+		maxRows: input.maxRows,
+		rowNameFilter: input.rowNameFilter
+	}), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: "127.0.0.1",
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge read_data_table failed (${response.error.code}): ${response.error.message}`);
+	return {
+		assetPath: response.assetPath,
+		columns: response.columns,
+		columnsTruncated: response.columnsTruncated,
+		nextCursor: response.nextCursor,
+		projectId: entry.projectId,
+		rows: response.rows,
+		rowStructName: response.rowStructName,
+		rowStructPath: response.rowStructPath,
+		totalRowCount: response.totalRowCount,
+		truncated: response.truncated,
+		valueTruncated: response.valueTruncated
+	};
+}
+async function writeDataTableRow(input, dependencies) {
+	const normalizedProjectId = projectIdSchema.parse(input.projectId);
+	const entry = dependencies.registry.getProject(normalizedProjectId);
+	if (!entry) throw new Error(`No registered Unreal engine was found for projectId '${normalizedProjectId}'.`);
+	const response = await sendBridgeWriteDataTableRowRequest(createBridgeWriteDataTableRowRequest(input.assetPath, input.rowName, input.operation, {
+		dryRun: input.dryRun,
+		values: input.values
+	}), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: "127.0.0.1",
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge write_data_table_row failed (${response.error.code}): ${response.error.message}`);
+	return {
+		applied: response.applied,
+		assetPath: response.assetPath,
+		created: response.created,
+		dryRun: response.dryRun,
+		message: response.message,
+		packageDirty: response.packageDirty,
+		projectId: entry.projectId,
+		rowExisted: response.rowExisted,
+		rowName: response.rowName,
+		state: response.state,
+		transactionTitle: response.transactionTitle
+	};
+}
+async function exportDataTable(input, dependencies) {
+	const normalizedProjectId = projectIdSchema.parse(input.projectId);
+	const entry = dependencies.registry.getProject(normalizedProjectId);
+	if (!entry) throw new Error(`No registered Unreal engine was found for projectId '${normalizedProjectId}'.`);
+	const response = await sendBridgeExportDataTableRequest(createBridgeExportDataTableRequest(input.assetPath, {
+		cursor: input.cursor,
+		format: input.format,
+		loadIfNeeded: input.loadIfNeeded
+	}), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: "127.0.0.1",
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge export_data_table failed (${response.error.code}): ${response.error.message}`);
+	return {
+		assetPath: response.assetPath,
+		content: response.content,
+		format: response.format,
+		nextCursor: response.nextCursor,
+		projectId: entry.projectId,
+		rowCount: response.rowCount,
+		totalChars: response.totalChars,
+		truncated: response.truncated
+	};
+}
+async function importDataTable(input, dependencies) {
+	const normalizedProjectId = projectIdSchema.parse(input.projectId);
+	const entry = dependencies.registry.getProject(normalizedProjectId);
+	if (!entry) throw new Error(`No registered Unreal engine was found for projectId '${normalizedProjectId}'.`);
+	const response = await sendBridgeImportDataTableRequest(createBridgeImportDataTableRequest(input.assetPath, input.content, {
+		dryRun: input.dryRun,
+		format: input.format
+	}), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: "127.0.0.1",
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge import_data_table failed (${response.error.code}): ${response.error.message}`);
+	return {
+		assetPath: response.assetPath,
+		dryRun: response.dryRun,
+		message: response.message,
+		packageDirty: response.packageDirty,
+		problemCount: response.problemCount,
+		problems: response.problems,
+		projectId: entry.projectId,
+		replacedRowCount: response.replacedRowCount,
+		rowCount: response.rowCount,
+		state: response.state,
+		transactionTitle: response.transactionTitle
+	};
+}
+async function createDataTable(input, dependencies) {
+	const normalizedProjectId = projectIdSchema.parse(input.projectId);
+	const entry = dependencies.registry.getProject(normalizedProjectId);
+	if (!entry) throw new Error(`No registered Unreal engine was found for projectId '${normalizedProjectId}'.`);
+	const response = await sendBridgeCreateDataTableRequest(createBridgeCreateDataTableRequest(input.assetPath, input.rowStructPath, { dryRun: input.dryRun }), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: "127.0.0.1",
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge create_data_table failed (${response.error.code}): ${response.error.message}`);
+	return {
+		assetPath: response.assetPath,
+		created: response.created,
+		dryRun: response.dryRun,
+		packageDirty: response.packageDirty,
+		projectId: entry.projectId,
+		rowStructPath: response.rowStructPath,
+		state: response.state
+	};
+}
+async function renameDataTable(input, dependencies) {
+	const normalizedProjectId = projectIdSchema.parse(input.projectId);
+	const entry = dependencies.registry.getProject(normalizedProjectId);
+	if (!entry) throw new Error(`No registered Unreal engine was found for projectId '${normalizedProjectId}'.`);
+	const response = await sendBridgeRenameDataTableRequest(createBridgeRenameDataTableRequest(input.assetPath, {
+		destinationPath: input.destinationPath,
+		dryRun: input.dryRun,
+		newName: input.newName
+	}), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: "127.0.0.1",
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge rename_data_table failed (${response.error.code}): ${response.error.message}`);
+	return {
+		assetPath: response.assetPath,
+		dryRun: response.dryRun,
+		leftRedirector: response.leftRedirector,
+		newAssetPath: response.newAssetPath,
+		packageDirty: response.packageDirty,
+		projectId: entry.projectId,
+		renamed: response.renamed,
+		state: response.state
+	};
+}
+async function deleteDataTable(input, dependencies) {
+	const normalizedProjectId = projectIdSchema.parse(input.projectId);
+	const entry = dependencies.registry.getProject(normalizedProjectId);
+	if (!entry) throw new Error(`No registered Unreal engine was found for projectId '${normalizedProjectId}'.`);
+	const response = await sendBridgeDeleteDataTableRequest(createBridgeDeleteDataTableRequest(input.assetPath, {
+		dryRun: input.dryRun,
+		force: input.force
+	}), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: "127.0.0.1",
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge delete_data_table failed (${response.error.code}): ${response.error.message}`);
+	return {
+		assetPath: response.assetPath,
+		deleted: response.deleted,
+		dryRun: response.dryRun,
+		forced: response.forced,
+		projectId: entry.projectId,
+		referencerCount: response.referencerCount,
+		referencers: response.referencers,
+		state: response.state
+	};
+}
+async function renameDataTableRow(input, dependencies) {
+	const normalizedProjectId = projectIdSchema.parse(input.projectId);
+	const entry = dependencies.registry.getProject(normalizedProjectId);
+	if (!entry) throw new Error(`No registered Unreal engine was found for projectId '${normalizedProjectId}'.`);
+	const response = await sendBridgeRenameDataTableRowRequest(createBridgeRenameDataTableRowRequest(input.assetPath, input.rowName, input.newRowName, { dryRun: input.dryRun }), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: "127.0.0.1",
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge rename_data_table_row failed (${response.error.code}): ${response.error.message}`);
+	return {
+		assetPath: response.assetPath,
+		dryRun: response.dryRun,
+		newRowName: response.newRowName,
+		packageDirty: response.packageDirty,
+		projectId: entry.projectId,
+		renamed: response.renamed,
+		rowName: response.rowName,
+		state: response.state,
+		transactionTitle: response.transactionTitle
+	};
+}
 async function getAssetDependencies(input, dependencies) {
 	const normalizedProjectId = projectIdSchema.parse(input.projectId);
 	const entry = dependencies.registry.getProject(normalizedProjectId);
@@ -8229,7 +8945,7 @@ function isMissingFileError(error) {
 //#endregion
 //#region src/server.ts
 const SERVER_NAME = "ue-mcp-server";
-const SERVER_VERSION = "1.0.0";
+const SERVER_VERSION = "1.1.0";
 const logger = createModuleLogger("bootstrap");
 const enginePingLogger = createModuleLogger("engine-ping");
 const httpApiLogger = createModuleLogger("http-api");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uemcp/server",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "MCP server for making Unreal Engine and C++ development easier",
   "type": "module",
   "main": "dist/index.mjs",