@uemcp/server 1.0.0 → 1.2.0

package/README.md

@@ -44,6 +44,10 @@ The MCP tool surface currently exposes:
 - `redo`
 - `open_level`
 - `get_open_level_status`
+- `get_source_control_status`
+- `refresh_source_control_status`
+- `checkout_assets`
+- `get_source_control_job_status`
 
 ## Project Identity
 
@@ -101,9 +105,9 @@ This is intended to let an MCP client resolve the canonical Unreal project ident
 ### `wait_for_job`
 
 - Blocks server-side until an async job reaches a terminal state, then returns the payload the matching `get_*_status` tool would have returned under `status`
-- Replaces a client-side poll loop for `kind` `compile` (`trigger_live_compile` / `trigger_hot_reload`), `create_class`, `test_run`, and `pie`; `kind` is required because job ids are bare GUIDs
+- Replaces a client-side poll loop for `kind` `compile` (`trigger_live_compile` / `trigger_hot_reload`), `create_class`, `test_run`, `pie`, and `source_control` (`checkout_assets` / `refresh_source_control_status`); `kind` is required because job ids are bare GUIDs
 - `outcome` is `completed`, `timed_out` (last observed status still returned), or `unknown_job` (unknown/expired/cancelled id, returned on the first poll)
-- Per-kind default budgets (compile 120s, create_class 60s, pie 30s, test_run 300s), clamped to 600s; polls back off from 250ms (1s for test runs) and a transient bridge read timeout or dropped socket is retried rather than failing the wait
+- Per-kind default budgets (compile 120s, create_class 60s, pie 30s, source_control 60s, test_run 300s), clamped to 600s; polls back off from 250ms (1s for test runs) and a transient bridge read timeout or dropped socket is retried rather than failing the wait
 - For `test_run`, `status.results` is the first page — page the rest with `get_test_run_status` and `nextCursor`
 
 ### `build_target` / `generate_project_files` / `clean_build`
@@ -182,6 +186,48 @@ 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
 
+### `get_source_control_status` / `refresh_source_control_status` / `checkout_assets` / `get_source_control_job_status`
+
+- The prerequisite for every asset write on a team project. Under Perforce or Git-LFS file locking a `.uasset` stays read-only until it is checked out, so a write that skips this fails later at save time — several tool calls away from its cause
+- `get_source_control_status` answers **inline**: it reads the provider's own state cache, which is a memory lookup rather than a server round trip. It reports the `provider` name, `enabled` (is source control configured at all), `available` (is it currently connected), and one entry per requested path with a `state` of `checked_out_by_me`, `checked_out_by_other` (plus `checkedOutBy` naming the holder), `marked_for_add`, `not_checked_out`, `not_in_depot`, or `unknown`
+- `enabled` is what separates "no source control configured" from "configured, and this file is simply not checked out". Those are never collapsed into one answer
+- A file the editor has never asked the server about reports `unknown`, **not** a guess. `refresh_source_control_status` is how it becomes a real answer. A path that resolves to no package on disk also reports `unknown`, but carries an `error` saying so — an unresolvable path never passes as a depot answer
+- `refresh_source_control_status` and `checkout_assets` talk to the source control server over the network, which runs far past the plugin's 5 s game-thread budget, so neither runs inline: each returns `state: 'accepted'` with a `sourceControlJobId`. Poll it with `get_source_control_job_status`, or wait with `wait_for_job` using `kind: 'source_control'`
+- The poll reports `successCount` / `failureCount` and one result per file with its post-operation `state`, so a checkout is confirmed without a second query. One asset the provider refuses does not abort the rest — it reports `ok: false` with its own `error`
+- Checkout only. Submitting is never done for you, and a checked-out asset stays checked out until a human submits or reverts it
+- A request against an editor with no provider configured is refused with `source_control_disabled`, and one against a configured-but-offline provider with `source_control_unavailable`. Neither degrades into a filesystem check
+- In a non-editor plugin build all four report `state: 'unsupported'` and schedule nothing
+
+### `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 rather than surfacing later as an unexplained save error. Where a provider is configured the answer comes from the provider itself — `source_control_checkout_required` for a file that is simply not checked out, `source_control_checked_out_by_other` naming the holder when someone else has it — and only where none is does it fall back to the on-disk read-only check. Fix either with `checkout_assets`
+- 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,45 @@ 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 BRIDGE_GET_SOURCE_CONTROL_STATUS_REQUEST_TYPE = "get_source_control_status";
+const BRIDGE_REFRESH_SOURCE_CONTROL_STATUS_REQUEST_TYPE = "refresh_source_control_status";
+const BRIDGE_CHECKOUT_ASSETS_REQUEST_TYPE = "checkout_assets";
+const BRIDGE_GET_SOURCE_CONTROL_JOB_STATUS_REQUEST_TYPE = "get_source_control_job_status";
+const BRIDGE_SOURCE_CONTROL_FILE_STATES = [
+	"checked_out_by_me",
+	"checked_out_by_other",
+	"marked_for_add",
+	"not_checked_out",
+	"not_in_depot",
+	"unknown"
+];
+const BRIDGE_SOURCE_CONTROL_STATUS_STATES = ["reported", "unsupported"];
+const BRIDGE_SOURCE_CONTROL_JOB_ACCEPT_STATES = ["accepted", "unsupported"];
+const BRIDGE_SOURCE_CONTROL_JOB_STATES = [
+	"running",
+	"succeeded",
+	"failed",
+	"unknown_job"
+];
+const BRIDGE_SOURCE_CONTROL_OPERATIONS = ["checkout", "refresh"];
 const requestIdSchema = z.string().trim().min(1);
 const nonEmptyStringSchema = z.string().trim().min(1);
 const boundedStringSchema = z.string().trim().max(512);
@@ -568,6 +607,22 @@ 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 sourceControlAssetPathBatchSchema = z.array(assetPathSchema).min(1).max(64);
+const sourceControlFileStateSchema = z.enum(BRIDGE_SOURCE_CONTROL_FILE_STATES);
+const sourceControlStatusStateSchema = z.enum(BRIDGE_SOURCE_CONTROL_STATUS_STATES);
+const sourceControlJobAcceptStateSchema = z.enum(BRIDGE_SOURCE_CONTROL_JOB_ACCEPT_STATES);
+const sourceControlJobStateSchema = z.enum(BRIDGE_SOURCE_CONTROL_JOB_STATES);
+const sourceControlOperationSchema = z.enum(BRIDGE_SOURCE_CONTROL_OPERATIONS);
+const sourceControlJobIdSchema = z.string().trim().min(1);
 const vectorInputSchema = z.object({
 	x: z.number().default(0),
 	y: z.number().default(0),
@@ -972,6 +1027,111 @@ 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 bridgeGetSourceControlStatusRequestSchema = z.object({
+	assetPaths: sourceControlAssetPathBatchSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_GET_SOURCE_CONTROL_STATUS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeRefreshSourceControlStatusRequestSchema = z.object({
+	assetPaths: sourceControlAssetPathBatchSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_REFRESH_SOURCE_CONTROL_STATUS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeCheckoutAssetsRequestSchema = z.object({
+	assetPaths: sourceControlAssetPathBatchSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_CHECKOUT_ASSETS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeGetSourceControlJobStatusRequestSchema = z.object({
+	requestId: requestIdSchema,
+	sourceControlJobId: sourceControlJobIdSchema,
+	type: z.literal(BRIDGE_GET_SOURCE_CONTROL_JOB_STATUS_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 +1874,211 @@ 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 bridgeSourceControlFileStateSchema = z.object({
+	assetPath: z.string(),
+	checkedOutBy: z.string().trim().min(1).optional(),
+	error: z.string().optional(),
+	index: z.number().int().min(0),
+	state: sourceControlFileStateSchema
+});
+const bridgeGetSourceControlStatusSuccessResponseSchema = z.object({
+	available: z.boolean(),
+	enabled: z.boolean(),
+	files: z.array(bridgeSourceControlFileStateSchema).max(64),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	provider: z.string().trim().min(1),
+	requestId: requestIdSchema,
+	state: sourceControlStatusStateSchema,
+	type: z.literal(BRIDGE_GET_SOURCE_CONTROL_STATUS_REQUEST_TYPE),
+	version: z.literal(2)
+}).refine((value) => value.state === "reported" || value.files.length === 0, {
+	message: "An unsupported get_source_control_status response must carry no file entries.",
+	path: ["files"]
+});
+const sourceControlJobAcceptFields = {
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	sourceControlJobId: sourceControlJobIdSchema.optional(),
+	state: sourceControlJobAcceptStateSchema,
+	version: z.literal(2)
+};
+const sourceControlJobAcceptRefinement = {
+	message: "A source control response must carry sourceControlJobId exactly when state is 'accepted'.",
+	path: ["sourceControlJobId"]
+};
+function isSourceControlJobAcceptConsistent(value) {
+	return value.state === "accepted" === (value.sourceControlJobId !== void 0);
+}
+const bridgeRefreshSourceControlStatusSuccessResponseSchema = z.object({
+	...sourceControlJobAcceptFields,
+	type: z.literal(BRIDGE_REFRESH_SOURCE_CONTROL_STATUS_REQUEST_TYPE)
+}).refine(isSourceControlJobAcceptConsistent, sourceControlJobAcceptRefinement);
+const bridgeCheckoutAssetsSuccessResponseSchema = z.object({
+	...sourceControlJobAcceptFields,
+	type: z.literal(BRIDGE_CHECKOUT_ASSETS_REQUEST_TYPE)
+}).refine(isSourceControlJobAcceptConsistent, sourceControlJobAcceptRefinement);
+const bridgeSourceControlJobItemResultSchema = z.object({
+	assetPath: z.string(),
+	error: z.string().optional(),
+	index: z.number().int().min(0),
+	ok: z.boolean(),
+	state: sourceControlFileStateSchema
+});
+const bridgeGetSourceControlJobStatusSuccessResponseSchema = z.object({
+	durationMs: z.number().int().min(0).optional(),
+	failureCount: z.number().int().min(0),
+	finishedAt: nonEmptyStringSchema.optional(),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	operation: sourceControlOperationSchema.optional(),
+	requestId: requestIdSchema,
+	results: z.array(bridgeSourceControlJobItemResultSchema).max(64),
+	sourceControlJobId: sourceControlJobIdSchema,
+	state: sourceControlJobStateSchema,
+	successCount: z.number().int().min(0),
+	type: z.literal(BRIDGE_GET_SOURCE_CONTROL_JOB_STATUS_REQUEST_TYPE),
+	version: z.literal(2)
+}).superRefine((value, ctx) => {
+	if (value.state === "succeeded" || value.state === "failed") return;
+	if (value.durationMs !== void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "durationMs must be absent until the job finishes",
+		path: ["durationMs"]
+	});
+	if (value.finishedAt !== void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "finishedAt must be absent until the job finishes",
+		path: ["finishedAt"]
+	});
+	if (value.results.length > 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "results must be empty until the job finishes",
+		path: ["results"]
+	});
+});
 const bridgeAssetDependencySchema = z.object({
 	category: assetDependencyCategorySchema,
 	isHard: z.boolean(),
@@ -1991,6 +2356,18 @@ 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 bridgeGetSourceControlStatusResponseSchema = z.union([bridgeGetSourceControlStatusSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeRefreshSourceControlStatusResponseSchema = z.union([bridgeRefreshSourceControlStatusSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeCheckoutAssetsResponseSchema = z.union([bridgeCheckoutAssetsSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeGetSourceControlJobStatusResponseSchema = z.union([bridgeGetSourceControlJobStatusSuccessResponseSchema, bridgeErrorResponseSchema]);
 const bridgeFindAssetsResponseSchema = z.union([bridgeFindAssetsSuccessResponseSchema, bridgeErrorResponseSchema]);
 const bridgeGetAssetDependenciesResponseSchema = z.union([bridgeGetAssetDependenciesSuccessResponseSchema, bridgeErrorResponseSchema]);
 const bridgeFindBlueprintReferencesResponseSchema = z.union([bridgeFindBlueprintReferencesSuccessResponseSchema, bridgeErrorResponseSchema]);
@@ -2002,6 +2379,126 @@ 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 createBridgeGetSourceControlStatusRequest(assetPaths, requestId = randomUUID()) {
+	return bridgeGetSourceControlStatusRequestSchema.parse({
+		assetPaths,
+		requestId,
+		type: BRIDGE_GET_SOURCE_CONTROL_STATUS_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeRefreshSourceControlStatusRequest(assetPaths, requestId = randomUUID()) {
+	return bridgeRefreshSourceControlStatusRequestSchema.parse({
+		assetPaths,
+		requestId,
+		type: BRIDGE_REFRESH_SOURCE_CONTROL_STATUS_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeCheckoutAssetsRequest(assetPaths, requestId = randomUUID()) {
+	return bridgeCheckoutAssetsRequestSchema.parse({
+		assetPaths,
+		requestId,
+		type: BRIDGE_CHECKOUT_ASSETS_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeGetSourceControlJobStatusRequest(sourceControlJobId, requestId = randomUUID()) {
+	return bridgeGetSourceControlJobStatusRequestSchema.parse({
+		requestId,
+		sourceControlJobId,
+		type: BRIDGE_GET_SOURCE_CONTROL_JOB_STATUS_REQUEST_TYPE,
+		version: 2
+	});
+}
 function createBridgeFindAssetsRequest(options = {}, requestId = randomUUID()) {
 	return bridgeFindAssetsRequestSchema.parse({
 		classNames: options.classNames,
@@ -2569,6 +3066,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);
 }
@@ -2608,6 +3129,18 @@ async function sendBridgeOpenLevelRequest(request, options) {
 async function sendBridgeGetOpenLevelStatusRequest(request, options) {
 	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetOpenLevelStatusResponseSchema, request.requestId);
 }
+async function sendBridgeGetSourceControlStatusRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetSourceControlStatusResponseSchema, request.requestId);
+}
+async function sendBridgeRefreshSourceControlStatusRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeRefreshSourceControlStatusResponseSchema, request.requestId);
+}
+async function sendBridgeCheckoutAssetsRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeCheckoutAssetsResponseSchema, request.requestId);
+}
+async function sendBridgeGetSourceControlJobStatusRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetSourceControlJobStatusResponseSchema, request.requestId);
+}
 async function sendBridgeGetAssetDependenciesRequest(request, options) {
 	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetAssetDependenciesResponseSchema, request.requestId);
 }
@@ -4915,6 +5448,7 @@ const WAIT_FOR_JOB_KINDS = [
 	"compile",
 	"create_class",
 	"pie",
+	"source_control",
 	"test_run"
 ];
 const WAIT_FOR_JOB_MAX_TIMEOUT_MS = 6e5;
@@ -4922,6 +5456,7 @@ const WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS = {
 	compile: 12e4,
 	create_class: 6e4,
 	pie: 3e4,
+	source_control: 6e4,
 	test_run: 3e5
 };
 const WAIT_FOR_JOB_POLL_CADENCE_MS = {
@@ -4937,6 +5472,10 @@ const WAIT_FOR_JOB_POLL_CADENCE_MS = {
 		capMs: 2e3,
 		initialMs: 250
 	},
+	source_control: {
+		capMs: 2e3,
+		initialMs: 250
+	},
 	test_run: {
 		capMs: 5e3,
 		initialMs: 1e3
@@ -5044,7 +5583,7 @@ const waitForJobInputSchema = {
 	jobId: z.string().trim().min(1).max(512).describe("Job identifier to wait on: compileJobId (compile), createClassJobId (create_class), testRunId (test_run), or pieSessionId (pie)."),
 	kind: z.enum(WAIT_FOR_JOB_KINDS).describe("Which async job the id belongs to. Required — job ids are bare GUIDs and carry no type tag, so the kind cannot be inferred."),
 	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor owns the job."),
-	timeoutMs: z.number().int().min(1).optional().describe(`Wall-clock budget for the wait, clamped to ${String(WAIT_FOR_JOB_MAX_TIMEOUT_MS)}ms. Defaults per kind: compile ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.compile)}ms, create_class ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.create_class)}ms, pie ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.pie)}ms, test_run ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.test_run)}ms.`)
+	timeoutMs: z.number().int().min(1).optional().describe(`Wall-clock budget for the wait, clamped to ${String(WAIT_FOR_JOB_MAX_TIMEOUT_MS)}ms. Defaults per kind: compile ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.compile)}ms, create_class ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.create_class)}ms, pie ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.pie)}ms, source_control ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.source_control)}ms, test_run ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.test_run)}ms.`)
 };
 const getEditorStateInputSchema = { projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor should report its state.") };
 const saveDirtyPackagesInputSchema = {
@@ -5747,6 +6286,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."),
@@ -5803,6 +6398,22 @@ const getOpenLevelStatusInputSchema = {
 	openLevelJobId: bridgeGetOpenLevelStatusRequestSchema.shape.openLevelJobId.describe("openLevelJobId returned by open_level identifying the load job to poll."),
 	projectId: projectIdSchema
 };
+const getSourceControlStatusInputSchema = {
+	assetPaths: bridgeGetSourceControlStatusRequestSchema.shape.assetPaths.describe("Package names or object paths of the assets to report on (1-64), e.g. /Game/Data/DT_Weapons."),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor should query its source control provider.")
+};
+const refreshSourceControlStatusInputSchema = {
+	assetPaths: bridgeRefreshSourceControlStatusRequestSchema.shape.assetPaths.describe("Package names or object paths of the assets whose depot state should be re-read (1-64)."),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor should refresh its source control state.")
+};
+const checkoutAssetsInputSchema = {
+	assetPaths: bridgeCheckoutAssetsRequestSchema.shape.assetPaths.describe("Package names or object paths of the assets to check out (1-64), e.g. /Game/Data/DT_Weapons."),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor should check the assets out.")
+};
+const getSourceControlJobStatusInputSchema = {
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor owns the job."),
+	sourceControlJobId: bridgeGetSourceControlJobStatusRequestSchema.shape.sourceControlJobId.describe("sourceControlJobId returned by checkout_assets or refresh_source_control_status.")
+};
 const getAssetDependenciesInputSchema = {
 	assetPath: bridgeGetAssetDependenciesRequestSchema.shape.assetPath.describe("Package name or object path of the asset to inspect (e.g. /Game/BP/BP_Player or /Game/BP/BP_Player.BP_Player)."),
 	categories: bridgeGetAssetDependenciesRequestSchema.shape.categories.describe("Dependency categories to include: 'package' (default), 'searchable_name', 'manage'."),
@@ -6448,6 +7059,46 @@ function registerMcpTools(server, dependencies) {
 			projectId
 		}, dependencies));
 	});
+	server.registerTool("get_source_control_status", {
+		description: "Report the editor's source control provider and the per-file state of up to 64 assets. Answered from the provider's state cache, so it costs no network round trip and returns inline. enabled distinguishes 'no source control configured' from 'configured, and this file is simply not checked out'; per-file state is one of checked_out_by_me, checked_out_by_other (with checkedOutBy naming the holder), marked_for_add, not_checked_out, not_in_depot, unknown. A file the editor has never queried reports 'unknown' — call refresh_source_control_status to fetch its real state from the server. Call this before any asset write on a team project: under Perforce or Git-LFS file locking a .uasset stays read-only until checked out, and the write otherwise fails later at save time.",
+		inputSchema: getSourceControlStatusInputSchema,
+		title: "Get Source Control Status"
+	}, async ({ assetPaths, projectId }) => {
+		return toToolSuccess(await getSourceControlStatus({
+			assetPaths,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("refresh_source_control_status", {
+		description: "Re-read the depot state of up to 64 assets from the source control server, so a later get_source_control_status reports something better than 'unknown'. This is a network round trip to the provider and runs far past what a bridge request can wait for, so it only accepts the job: it returns state 'accepted' with a sourceControlJobId to poll with get_source_control_job_status (or wait_for_job with kind source_control).",
+		inputSchema: refreshSourceControlStatusInputSchema,
+		title: "Refresh Source Control Status"
+	}, async ({ assetPaths, projectId }) => {
+		return toToolSuccess(await refreshSourceControlStatus({
+			assetPaths,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("checkout_assets", {
+		description: "Check up to 64 assets out of source control so they become writable. This is a network round trip to the provider and runs far past what a bridge request can wait for, so it only accepts the job: it returns state 'accepted' with a sourceControlJobId to poll with get_source_control_job_status (or wait_for_job with kind source_control). The poll reports per-item results with successCount / failureCount — one asset the provider refuses does not abort the rest. This checks out only; it never submits, and a checked-out asset stays checked out until a human submits or reverts it.",
+		inputSchema: checkoutAssetsInputSchema,
+		title: "Checkout Assets"
+	}, async ({ assetPaths, projectId }) => {
+		return toToolSuccess(await checkoutAssets({
+			assetPaths,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("get_source_control_job_status", {
+		description: "Poll a source control job started by checkout_assets or refresh_source_control_status for a projectId; returns state (running, succeeded, failed, unknown_job), which operation it was, and once finished the per-file results with successCount / failureCount and timing. Poll until the state leaves 'running' before writing to any asset in the batch.",
+		inputSchema: getSourceControlJobStatusInputSchema,
+		title: "Get Source Control Job Status"
+	}, async ({ projectId, sourceControlJobId }) => {
+		return toToolSuccess(await getSourceControlJobStatus({
+			projectId,
+			sourceControlJobId
+		}, dependencies));
+	});
 	server.registerTool("find_assets", {
 		description: "Query a project's Unreal Asset Registry for assets by class and/or content path, without loading them; returns each match's name, class, package name, package path, and object path. Requires at least one of classNames or packagePaths — an unfiltered query would stall the editor enumerating every asset. Results are paged: pass the previous response nextCursor to fetch the next page (totalCount reports the full match count). scanning=true means the registry is still indexing, so an empty result does not prove the asset is absent.",
 		inputSchema: findAssetsInputSchema,
@@ -6464,6 +7115,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,
@@ -6836,6 +7591,91 @@ async function getOpenLevelStatus(input, dependencies) {
 	if (response.durationMs !== void 0) result.durationMs = response.durationMs;
 	return result;
 }
+async function getSourceControlStatus(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 sendBridgeGetSourceControlStatusRequest(createBridgeGetSourceControlStatusRequest(input.assetPaths), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: BRIDGE_LOOPBACK_HOST,
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge get_source_control_status failed (${response.error.code}): ${response.error.message}`);
+	const result = {
+		available: response.available,
+		enabled: response.enabled,
+		files: response.files,
+		projectId: entry.projectId,
+		provider: response.provider,
+		state: response.state
+	};
+	if (response.message !== void 0) result.message = response.message;
+	return result;
+}
+async function refreshSourceControlStatus(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 request = createBridgeRefreshSourceControlStatusRequest(input.assetPaths);
+	const response = await sendBridgeRefreshSourceControlStatusRequest(request, {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: BRIDGE_LOOPBACK_HOST,
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge refresh_source_control_status failed (${response.error.code}): ${response.error.message}`);
+	return buildSourceControlJobAcceptResult(response, request.assetPaths, entry.projectId);
+}
+async function checkoutAssets(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 request = createBridgeCheckoutAssetsRequest(input.assetPaths);
+	const response = await sendBridgeCheckoutAssetsRequest(request, {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: BRIDGE_LOOPBACK_HOST,
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge checkout_assets failed (${response.error.code}): ${response.error.message}`);
+	return buildSourceControlJobAcceptResult(response, request.assetPaths, entry.projectId);
+}
+function buildSourceControlJobAcceptResult(response, assetPaths, projectId) {
+	const result = {
+		assetPaths,
+		projectId,
+		state: response.state
+	};
+	if (response.sourceControlJobId !== void 0) result.sourceControlJobId = response.sourceControlJobId;
+	if (response.message !== void 0) result.message = response.message;
+	return result;
+}
+async function getSourceControlJobStatus(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 sendBridgeGetSourceControlJobStatusRequest(createBridgeGetSourceControlJobStatusRequest(input.sourceControlJobId), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: BRIDGE_LOOPBACK_HOST,
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge get_source_control_job_status failed (${response.error.code}): ${response.error.message}`);
+	const result = {
+		failureCount: response.failureCount,
+		projectId: entry.projectId,
+		results: response.results,
+		sourceControlJobId: response.sourceControlJobId,
+		state: response.state,
+		successCount: response.successCount
+	};
+	if (response.operation !== void 0) result.operation = response.operation;
+	if (response.message !== void 0) result.message = response.message;
+	if (response.finishedAt !== void 0) result.finishedAt = response.finishedAt;
+	if (response.durationMs !== void 0) result.durationMs = response.durationMs;
+	return result;
+}
 async function findAssets(input, dependencies) {
 	const normalizedProjectId = projectIdSchema.parse(input.projectId);
 	const entry = dependencies.registry.getProject(normalizedProjectId);
@@ -6864,6 +7704,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);
@@ -7962,6 +9009,10 @@ async function pollJobStatus(kind, jobId, projectId, dependencies) {
 			pieSessionId: jobId,
 			projectId
 		}, dependencies);
+		case "source_control": return await getSourceControlJobStatus({
+			projectId,
+			sourceControlJobId: jobId
+		}, dependencies);
 		case "test_run": return await getTestRunStatus({
 			projectId,
 			testRunId: jobId
@@ -7973,6 +9024,7 @@ function classifyJobStatus(kind, status) {
 		case "compile": return status.state === "compiling" ? "pending" : toTerminalOutcome(status.state === "unknown_job");
 		case "create_class": return status.state === "creating" ? "pending" : toTerminalOutcome(status.state === "unknown_job");
 		case "pie": return status.state === "starting" ? "pending" : "completed";
+		case "source_control": return status.state === "running" ? "pending" : toTerminalOutcome(status.state === "unknown_job");
 		case "test_run": return status.state === "running" ? "pending" : toTerminalOutcome(status.state === "unknown_run");
 	}
 }
@@ -8229,7 +9281,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.2.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.2.0",
   "description": "MCP server for making Unreal Engine and C++ development easier",
   "type": "module",
   "main": "dist/index.mjs",