robloxstudio-mcp 2.4.0 → 2.5.0

package/studio-plugin/src/modules/Communication.ts

@@ -10,6 +10,7 @@ import MetadataHandlers from "./handlers/MetadataHandlers";
 import TestHandlers from "./handlers/TestHandlers";
 import BuildHandlers from "./handlers/BuildHandlers";
 import AssetHandlers from "./handlers/AssetHandlers";
+import CaptureHandlers from "./handlers/CaptureHandlers";
 import { Connection, RequestPayload, PollResponse } from "../types";
 
 type Handler = (data: Record<string, unknown>) => unknown;
@@ -71,6 +72,8 @@ const routeMap: Record<string, Handler> = {
 
 	"/api/insert-asset": AssetHandlers.insertAsset,
 	"/api/preview-asset": AssetHandlers.previewAsset,
+
+	"/api/capture-screenshot": CaptureHandlers.captureScreenshot,
 };
 
 function processRequest(request: RequestPayload): unknown {

package/studio-plugin/src/modules/Utils.ts

@@ -39,8 +39,8 @@ function getInstanceByPath(path: string): Instance | undefined {
 
 	let current: Instance | undefined = game;
 	for (const part of parts) {
-		current = current?.FindFirstChild(part);
 		if (!current) return undefined;
+		current = current.FindFirstChild(part);
 	}
 
 	return current;

package/studio-plugin/src/modules/handlers/AssetHandlers.ts

@@ -24,67 +24,69 @@ function insertAsset(requestData: Record<string, unknown>) {
 
 	const recordingId = beginRecording(`Insert asset ${assetId}`);
 
-	const [loadSuccess, wrapperModel] = pcall(() => {
-		return (AssetService as unknown as { LoadAssetAsync(id: number): Instance }).LoadAssetAsync(assetId);
-	});
-
-	if (!loadSuccess || !wrapperModel) {
-		finishRecording(recordingId, false);
-		return { error: `Failed to load asset ${assetId}: ${tostring(wrapperModel)}` };
-	}
+	let wrapperModel: Instance | undefined;
+	const [insertSuccess, insertResult] = pcall(() => {
+		const loadedWrapper = (AssetService as unknown as { LoadAssetAsync(id: number): Instance }).LoadAssetAsync(assetId);
+		wrapperModel = loadedWrapper;
 
-	const insertedInstances: Instance[] = [];
-	const children = (wrapperModel as Instance).GetChildren();
+		const insertedInstances: Instance[] = [];
+		const children = loadedWrapper.GetChildren();
 
-	for (const child of children) {
-		child.Parent = parentInstance;
-		insertedInstances.push(child);
-	}
+		for (const child of children) {
+			child.Parent = parentInstance;
+			insertedInstances.push(child);
+		}
 
-	// Apply position if provided
-	if (position) {
-		const pos = new Vector3(position.x ?? 0, position.y ?? 0, position.z ?? 0);
-		for (const inst of insertedInstances) {
-			if (inst.IsA("BasePart")) {
-				inst.Position = pos;
-			} else if (inst.IsA("Model")) {
-				if (inst.PrimaryPart) {
-					inst.PivotTo(new CFrame(pos));
-				} else {
-					// Find first BasePart descendant to pivot around
-					const firstPart = inst.FindFirstChildWhichIsA("BasePart", true);
-					if (firstPart) {
+		if (position) {
+			const pos = new Vector3(position.x ?? 0, position.y ?? 0, position.z ?? 0);
+			for (const inst of insertedInstances) {
+				if (inst.IsA("BasePart")) {
+					inst.Position = pos;
+				} else if (inst.IsA("Model")) {
+					if (inst.PrimaryPart) {
 						inst.PivotTo(new CFrame(pos));
+					} else {
+						const firstPart = inst.FindFirstChildWhichIsA("BasePart", true);
+						if (firstPart) {
+							inst.PivotTo(new CFrame(pos));
+						}
 					}
 				}
 			}
 		}
-	}
 
-	// Destroy the wrapper model
-	(wrapperModel as Instance).Destroy();
+		pcall(() => {
+			Selection.Set(insertedInstances);
+		});
+
+		const resultInstances = insertedInstances.map((inst) => ({
+			name: inst.Name,
+			className: inst.ClassName,
+			path: getInstancePath(inst),
+		}));
+
+		return {
+			success: true,
+			assetId,
+			parentPath,
+			insertedCount: insertedInstances.size(),
+			instances: resultInstances,
+		};
+	});
 
-	// Set undo waypoint
-	finishRecording(recordingId, true);
+	if (wrapperModel) {
+		pcall(() => {
+			wrapperModel!.Destroy();
+		});
+	}
 
-	// Select inserted instances
-	pcall(() => {
-		Selection.Set(insertedInstances);
-	});
+	finishRecording(recordingId, insertSuccess);
+
+	if (!insertSuccess) {
+		return { error: `Failed to insert asset ${assetId}: ${tostring(insertResult)}` };
+	}
 
-	const resultInstances = insertedInstances.map((inst) => ({
-		name: inst.Name,
-		className: inst.ClassName,
-		path: getInstancePath(inst),
-	}));
-
-	return {
-		success: true,
-		assetId,
-		parentPath,
-		insertedCount: insertedInstances.size(),
-		instances: resultInstances,
-	};
+	return insertResult;
 }
 
 function previewAsset(requestData: Record<string, unknown>) {
@@ -201,27 +203,36 @@ function previewAsset(requestData: Record<string, unknown>) {
 		return node;
 	}
 
-	const hierarchyRoots: Record<string, unknown>[] = [];
-	for (const child of (wrapperModel as Instance).GetChildren()) {
-		hierarchyRoots.push(buildHierarchy(child, 0));
+	const [previewSuccess, previewResult] = pcall(() => {
+		const hierarchyRoots: Record<string, unknown>[] = [];
+		for (const child of (wrapperModel as Instance).GetChildren()) {
+			hierarchyRoots.push(buildHierarchy(child, 0));
+		}
+
+		return {
+			success: true,
+			assetId,
+			hierarchy: hierarchyRoots,
+			summary: {
+				totalInstances,
+				classCounts,
+				hasScripts,
+				hasAnimations,
+				hasSounds,
+				hasParticles,
+			},
+		};
+	});
+
+	pcall(() => {
+		(wrapperModel as Instance).Destroy();
+	});
+
+	if (!previewSuccess) {
+		return { error: `Failed to preview asset ${assetId}: ${tostring(previewResult)}` };
 	}
 
-	// CRITICAL: Destroy wrapper to prevent memory leak
-	(wrapperModel as Instance).Destroy();
-
-	return {
-		success: true,
-		assetId,
-		hierarchy: hierarchyRoots,
-		summary: {
-			totalInstances,
-			classCounts,
-			hasScripts,
-			hasAnimations,
-			hasSounds,
-			hasParticles,
-		},
-	};
+	return previewResult;
 }
 
 export = {

package/studio-plugin/src/modules/handlers/BuildHandlers.ts

@@ -6,30 +6,10 @@ const MaterialService = game.GetService("MaterialService");
 const { getInstancePath, getInstanceByPath } = Utils;
 const { beginRecording, finishRecording } = Recording;
 
-// Material name lookup table
-const MATERIAL_NAMES: Record<string, Enum.Material> = {
-	Plastic: Enum.Material.Plastic,
-	Wood: Enum.Material.Wood,
-	WoodPlanks: Enum.Material.WoodPlanks,
-	Slate: Enum.Material.Slate,
-	Concrete: Enum.Material.Concrete,
-	CorrodedMetal: Enum.Material.CorrodedMetal,
-	DiamondPlate: Enum.Material.DiamondPlate,
-	Foil: Enum.Material.Foil,
-	Grass: Enum.Material.Grass,
-	Ice: Enum.Material.Ice,
-	Marble: Enum.Material.Marble,
-	Granite: Enum.Material.Granite,
-	Brick: Enum.Material.Brick,
-	Pebble: Enum.Material.Pebble,
-	Sand: Enum.Material.Sand,
-	Fabric: Enum.Material.Fabric,
-	SmoothPlastic: Enum.Material.SmoothPlastic,
-	Metal: Enum.Material.Metal,
-	Neon: Enum.Material.Neon,
-	Glass: Enum.Material.Glass,
-	Cobblestone: Enum.Material.Cobblestone,
-};
+const MATERIAL_BY_NAME = new Map<string, Enum.Material>();
+for (const enumItem of Enum.Material.GetEnumItems()) {
+	MATERIAL_BY_NAME.set(enumItem.Name, enumItem as unknown as Enum.Material);
+}
 
 // Shape class mapping
 const SHAPE_CLASSES: Record<string, string> = {
@@ -47,6 +27,30 @@ function roundTo(n: number, decimals: number): number {
 	return math.round(n * mult) / mult;
 }
 
+function encodePaletteKey(index: number): string {
+	const base = PALETTE_KEYS.size();
+	let value = math.floor(index) + 1;
+	let encoded = "";
+	while (value > 0) {
+		value -= 1;
+		const digit = value % base;
+		encoded = PALETTE_KEYS.sub(digit + 1, digit + 1) + encoded;
+		value = math.floor(value / base);
+	}
+	return encoded;
+}
+
+function getVariantName(part: BasePart): string {
+	let variantName = part.MaterialVariant;
+	if (variantName === "") {
+		const [ok, variantAttr] = pcall(() => part.GetAttribute("MaterialVariant"));
+		if (ok && type(variantAttr) === "string") {
+			variantName = variantAttr as string;
+		}
+	}
+	return variantName;
+}
+
 function exportBuild(requestData: Record<string, unknown>) {
 	const instancePath = requestData.instancePath as string;
 	const outputId = requestData.outputId as string;
@@ -113,11 +117,11 @@ function exportBuild(requestData: Record<string, unknown>) {
 		for (const part of baseParts) {
 			const colorName = part.BrickColor.Name;
 			const materialName = part.Material.Name;
-			const variantName = part.MaterialVariant;
+			const variantName = getVariantName(part);
 			const combo = variantName !== "" ? `${colorName}|${materialName}|${variantName}` : `${colorName}|${materialName}`;
 
 			if (!paletteMap.has(combo)) {
-				const key = PALETTE_KEYS.sub(keyIndex + 1, keyIndex + 1);
+				const key = encodePaletteKey(keyIndex);
 				keyIndex++;
 				paletteMap.set(combo, key);
 				if (variantName !== "") {
@@ -136,7 +140,8 @@ function exportBuild(requestData: Record<string, unknown>) {
 			const sz = part.Size;
 			const colorName = part.BrickColor.Name;
 			const materialName = part.Material.Name;
-			const combo = `${colorName}|${materialName}`;
+			const variantName = getVariantName(part);
+			const combo = variantName !== "" ? `${colorName}|${materialName}|${variantName}` : `${colorName}|${materialName}`;
 			const paletteKey = paletteMap.get(combo) ?? "a";
 
 			// Relative position to center
@@ -270,8 +275,8 @@ function importBuild(requestData: Record<string, unknown>) {
 					part.BrickColor = new BrickColor(colorName as unknown as number);
 				});
 				pcall(() => {
-					const mat = MATERIAL_NAMES[materialName];
-					if (mat) {
+					const mat = MATERIAL_BY_NAME.get(materialName);
+					if (mat !== undefined) {
 						part.Material = mat;
 					}
 				});
@@ -389,8 +394,8 @@ function importScene(requestData: Record<string, unknown>) {
 						part.BrickColor = new BrickColor(colorName as unknown as number);
 					});
 					pcall(() => {
-						const mat = MATERIAL_NAMES[materialName];
-						if (mat) {
+						const mat = MATERIAL_BY_NAME.get(materialName);
+						if (mat !== undefined) {
 							part.Material = mat;
 						}
 					});

package/studio-plugin/src/modules/handlers/CaptureHandlers.ts

@@ -0,0 +1,118 @@
+const CaptureService = game.GetService("CaptureService");
+const AssetService = game.GetService("AssetService");
+
+const MAX_TILE_SIZE = 1024;
+const BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+function encodeBase64(buf: buffer): string {
+	const len = buffer.len(buf);
+	const parts: string[] = [];
+	let i = 0;
+
+	while (i + 2 < len) {
+		const b0 = buffer.readu8(buf, i);
+		const b1 = buffer.readu8(buf, i + 1);
+		const b2 = buffer.readu8(buf, i + 2);
+		const triplet = bit32.lshift(b0, 16) + bit32.lshift(b1, 8) + b2;
+		parts.push(
+			string.sub(BASE64_CHARS, bit32.rshift(triplet, 18) + 1, bit32.rshift(triplet, 18) + 1) +
+			string.sub(BASE64_CHARS, bit32.band(bit32.rshift(triplet, 12), 63) + 1, bit32.band(bit32.rshift(triplet, 12), 63) + 1) +
+			string.sub(BASE64_CHARS, bit32.band(bit32.rshift(triplet, 6), 63) + 1, bit32.band(bit32.rshift(triplet, 6), 63) + 1) +
+			string.sub(BASE64_CHARS, bit32.band(triplet, 63) + 1, bit32.band(triplet, 63) + 1),
+		);
+		i += 3;
+	}
+
+	const remaining = len - i;
+	if (remaining === 2) {
+		const b0 = buffer.readu8(buf, i);
+		const b1 = buffer.readu8(buf, i + 1);
+		const triplet = bit32.lshift(b0, 16) + bit32.lshift(b1, 8);
+		parts.push(
+			string.sub(BASE64_CHARS, bit32.rshift(triplet, 18) + 1, bit32.rshift(triplet, 18) + 1) +
+			string.sub(BASE64_CHARS, bit32.band(bit32.rshift(triplet, 12), 63) + 1, bit32.band(bit32.rshift(triplet, 12), 63) + 1) +
+			string.sub(BASE64_CHARS, bit32.band(bit32.rshift(triplet, 6), 63) + 1, bit32.band(bit32.rshift(triplet, 6), 63) + 1) +
+			"=",
+		);
+	} else if (remaining === 1) {
+		const b0 = buffer.readu8(buf, i);
+		const triplet = bit32.lshift(b0, 16);
+		parts.push(
+			string.sub(BASE64_CHARS, bit32.rshift(triplet, 18) + 1, bit32.rshift(triplet, 18) + 1) +
+			string.sub(BASE64_CHARS, bit32.band(bit32.rshift(triplet, 12), 63) + 1, bit32.band(bit32.rshift(triplet, 12), 63) + 1) +
+			"==",
+		);
+	}
+
+	return parts.join("");
+}
+
+function readPixelsTiled(img: EditableImage, w: number, h: number): buffer {
+	const BYTES_PER_PIXEL = 4;
+	const fullBuf = buffer.create(w * h * BYTES_PER_PIXEL);
+	const fullRowBytes = w * BYTES_PER_PIXEL;
+
+	for (let ty = 0; ty < h; ty += MAX_TILE_SIZE) {
+		const tileH = math.min(MAX_TILE_SIZE, h - ty);
+		for (let tx = 0; tx < w; tx += MAX_TILE_SIZE) {
+			const tileW = math.min(MAX_TILE_SIZE, w - tx);
+			const tileBuf = img.ReadPixelsBuffer(new Vector2(tx, ty), new Vector2(tileW, tileH));
+			const tileRowBytes = tileW * BYTES_PER_PIXEL;
+			for (let row = 0; row < tileH; row++) {
+				buffer.copy(fullBuf, (ty + row) * fullRowBytes + tx * BYTES_PER_PIXEL, tileBuf, row * tileRowBytes, tileRowBytes);
+			}
+		}
+	}
+	return fullBuf;
+}
+
+function captureScreenshot(): unknown {
+	let contentId: string | undefined;
+
+	CaptureService.CaptureScreenshot((id: string) => {
+		contentId = id;
+	});
+
+	const startTime = tick();
+	while (contentId === undefined) {
+		if (tick() - startTime > 10) {
+			return {
+				error: "Screenshot capture timed out. Ensure the Studio viewport is visible and you are in Edit mode (not Play mode). Known Roblox bug: capture may fail if viewport renders a solid color.",
+			};
+		}
+		task.wait(0.1);
+	}
+
+	const [editableOk, editableResult] = pcall(() => {
+		return AssetService.CreateEditableImageAsync(Content.fromUri(contentId!));
+	});
+
+	if (!editableOk) {
+		return {
+			error: `Failed to create EditableImage from screenshot. Enable EditableImage API: Game Settings > Security > 'Allow Mesh / Image APIs'. (${tostring(editableResult)})`,
+		};
+	}
+
+	const editableImage = editableResult as EditableImage;
+	const imgSize = editableImage.Size;
+	const w = math.floor(imgSize.X);
+	const h = math.floor(imgSize.Y);
+
+	const [readOk, pixelBuffer] = pcall(() => {
+		return readPixelsTiled(editableImage, w, h);
+	});
+
+	editableImage.Destroy();
+
+	if (!readOk) {
+		return { error: `Failed to read pixel data: ${tostring(pixelBuffer)}` };
+	}
+
+	const base64Data = encodeBase64(pixelBuffer as buffer);
+
+	return { success: true, width: w, height: h, data: base64Data };
+}
+
+export = {
+	captureScreenshot,
+};

package/studio-plugin/src/modules/handlers/InstanceHandlers.ts

@@ -4,6 +4,86 @@ import Recording from "../Recording";
 const { getInstancePath, getInstanceByPath, convertPropertyValue } = Utils;
 const { beginRecording, finishRecording } = Recording;
 
+type ProcessedCreateResult =
+	| {
+		instance: Instance;
+		className: string;
+		parentPath: string;
+	}
+	| {
+		error: string;
+		className?: string;
+		parentPath?: string;
+	};
+
+type ProcessedBatchResult = {
+	results: Record<string, unknown>[];
+	successCount: number;
+	failureCount: number;
+};
+
+function processObjectEntries(
+	objects: Record<string, unknown>[],
+	createFn: (objData: Record<string, unknown>) => ProcessedCreateResult,
+): ProcessedBatchResult {
+	const results: Record<string, unknown>[] = [];
+	let successCount = 0;
+	let failureCount = 0;
+
+	const [loopSuccess, loopError] = pcall(() => {
+		for (const entry of objects) {
+			if (!typeIs(entry, "table")) {
+				failureCount++;
+				results.push({ success: false, error: "Each object entry must be a table" });
+				continue;
+			}
+
+			const objData = entry as Record<string, unknown>;
+			const className = objData.className as string;
+			const parentPath = objData.parent as string;
+
+			if (!className || !parentPath) {
+				failureCount++;
+				results.push({ success: false, error: "Class name and parent are required" });
+				continue;
+			}
+
+			const [entrySuccess, entryResult] = pcall(() => createFn(objData));
+			if (!entrySuccess) {
+				failureCount++;
+				results.push({ success: false, className, parent: parentPath, error: tostring(entryResult) });
+				continue;
+			}
+
+			if ("instance" in entryResult) {
+				successCount++;
+				results.push({
+					success: true,
+					className: entryResult.className,
+					parent: entryResult.parentPath,
+					instancePath: getInstancePath(entryResult.instance),
+					name: entryResult.instance.Name,
+				});
+			} else {
+				failureCount++;
+				results.push({
+					success: false,
+					className: entryResult.className ?? className,
+					parent: entryResult.parentPath ?? parentPath,
+					error: entryResult.error,
+				});
+			}
+		}
+	});
+
+	if (!loopSuccess) {
+		failureCount++;
+		results.push({ success: false, error: `Unexpected mass create failure: ${tostring(loopError)}` });
+	}
+
+	return { results, successCount, failureCount };
+}
+
 function createObject(requestData: Record<string, unknown>) {
 	const className = requestData.className as string;
 	const parentPath = requestData.parent as string;
@@ -77,46 +157,30 @@ function massCreateObjects(requestData: Record<string, unknown>) {
 		return { error: "Objects array is required" };
 	}
 
-	const results: Record<string, unknown>[] = [];
-	let successCount = 0;
-	let failureCount = 0;
 	const recordingId = beginRecording("Mass create objects");
 
-	for (const objData of objects) {
+	const { results, successCount, failureCount } = processObjectEntries(objects, (objData) => {
 		const className = objData.className as string;
 		const parentPath = objData.parent as string;
 		const name = objData.name as string | undefined;
+		const parentInstance = getInstanceByPath(parentPath);
+		if (!parentInstance) {
+			return { error: "Parent instance not found", className, parentPath };
+		}
 
-		if (className && parentPath) {
-			const parentInstance = getInstanceByPath(parentPath);
-			if (parentInstance) {
-				const [success, newInstance] = pcall(() => {
-					const instance = new Instance(className as keyof CreatableInstances);
-					if (name) instance.Name = name;
-					instance.Parent = parentInstance;
-					return instance;
-				});
+		const [success, newInstance] = pcall(() => {
+			const instance = new Instance(className as keyof CreatableInstances);
+			if (name) instance.Name = name;
+			instance.Parent = parentInstance;
+			return instance;
+		});
 
-				if (success && newInstance) {
-					successCount++;
-					results.push({
-						success: true, className, parent: parentPath,
-						instancePath: getInstancePath(newInstance as Instance),
-						name: (newInstance as Instance).Name,
-					});
-				} else {
-					failureCount++;
-					results.push({ success: false, className, parent: parentPath, error: tostring(newInstance) });
-				}
-			} else {
-				failureCount++;
-				results.push({ success: false, className, parent: parentPath, error: "Parent instance not found" });
-			}
-		} else {
-			failureCount++;
-			results.push({ success: false, error: "Class name and parent are required" });
+		if (!success || !newInstance) {
+			return { error: tostring(newInstance), className, parentPath };
 		}
-	}
+
+		return { instance: newInstance as Instance, className, parentPath };
+	});
 
 	finishRecording(recordingId, successCount > 0);
 	return { results, summary: { total: (objects as defined[]).size(), succeeded: successCount, failed: failureCount } };
@@ -128,56 +192,45 @@ function massCreateObjectsWithProperties(requestData: Record<string, unknown>) {
 		return { error: "Objects array is required" };
 	}
 
-	const results: Record<string, unknown>[] = [];
-	let successCount = 0;
-	let failureCount = 0;
 	const recordingId = beginRecording("Mass create objects with properties");
 
-	for (const objData of objects) {
+	const { results, successCount, failureCount } = processObjectEntries(objects, (objData) => {
 		const className = objData.className as string;
 		const parentPath = objData.parent as string;
 		const name = objData.name as string | undefined;
-		const properties = (objData.properties as Record<string, unknown>) ?? {};
-
-		if (className && parentPath) {
-			const parentInstance = getInstanceByPath(parentPath);
-			if (parentInstance) {
-				const [success, newInstance] = pcall(() => {
-					const instance = new Instance(className as keyof CreatableInstances);
-					if (name) instance.Name = name;
-					instance.Parent = parentInstance;
+		const propertiesRaw = objData.properties;
+		const properties = typeIs(propertiesRaw, "table")
+			? (propertiesRaw as Record<string, unknown>)
+			: ({} as Record<string, unknown>);
+
+		const parentInstance = getInstanceByPath(parentPath);
+		if (!parentInstance) {
+			return { error: "Parent instance not found", className, parentPath };
+		}
 
-					for (const [propName, propValue] of pairs(properties)) {
-						pcall(() => {
-							const converted = convertPropertyValue(instance, propName as string, propValue);
-							if (converted !== undefined) {
-								(instance as unknown as { [key: string]: unknown })[propName as string] = converted;
-							}
-						});
+		const [success, newInstance] = pcall(() => {
+			const instance = new Instance(className as keyof CreatableInstances);
+			if (name) instance.Name = name;
+			instance.Parent = parentInstance;
+
+			for (const [propName, propValue] of pairs(properties)) {
+				pcall(() => {
+					const propNameStr = tostring(propName);
+					const converted = convertPropertyValue(instance, propNameStr, propValue);
+					if (converted !== undefined) {
+						(instance as unknown as { [key: string]: unknown })[propNameStr] = converted;
 					}
-					return instance;
 				});
-
-				if (success && newInstance) {
-					successCount++;
-					results.push({
-						success: true, className, parent: parentPath,
-						instancePath: getInstancePath(newInstance as Instance),
-						name: (newInstance as Instance).Name,
-					});
-				} else {
-					failureCount++;
-					results.push({ success: false, className, parent: parentPath, error: tostring(newInstance) });
-				}
-			} else {
-				failureCount++;
-				results.push({ success: false, className, parent: parentPath, error: "Parent instance not found" });
 			}
-		} else {
-			failureCount++;
-			results.push({ success: false, error: "Class name and parent are required" });
+			return instance;
+		});
+
+		if (!success || !newInstance) {
+			return { error: tostring(newInstance), className, parentPath };
 		}
-	}
+
+		return { instance: newInstance as Instance, className, parentPath };
+	});
 
 	finishRecording(recordingId, successCount > 0);
 	return { results, summary: { total: (objects as defined[]).size(), succeeded: successCount, failed: failureCount } };