kintone-migrator 0.23.0 → 0.24.1

package/dist/index.mjs

@@ -76,13 +76,15 @@ const FieldPermissionErrorCode = {
 //#region src/core/domain/formSchema/errorCode.ts
 const FormSchemaErrorCode = {
 	FsEmptyFieldCode: "FS_EMPTY_FIELD_CODE",
+	FsInvalidFieldCode: "FS_INVALID_FIELD_CODE",
 	FsEmptySchemaText: "FS_EMPTY_SCHEMA_TEXT",
 	FsInvalidSchemaFormat: "FS_INVALID_SCHEMA_FORMAT",
 	FsInvalidSchemaStructure: "FS_INVALID_SCHEMA_STRUCTURE",
 	FsDuplicateFieldCode: "FS_DUPLICATE_FIELD_CODE",
 	FsInvalidFieldType: "FS_INVALID_FIELD_TYPE",
 	FsInvalidLayoutStructure: "FS_INVALID_LAYOUT_STRUCTURE",
-	FsInvalidDecorationElement: "FS_INVALID_DECORATION_ELEMENT"
+	FsInvalidDecorationElement: "FS_INVALID_DECORATION_ELEMENT",
+	FsEmptyFields: "FS_EMPTY_FIELDS"
 };
 
 //#endregion
@@ -135,6 +137,7 @@ const ProjectConfigErrorCode = {
 	PcEmptyApps: "PC_EMPTY_APPS",
 	PcEmptyAppId: "PC_EMPTY_APP_ID",
 	PcEmptyAppName: "PC_EMPTY_APP_NAME",
+	PcInvalidAppName: "PC_INVALID_APP_NAME",
 	PcInvalidConfigStructure: "PC_INVALID_CONFIG_STRUCTURE",
 	PcInvalidAuthConfig: "PC_INVALID_AUTH_CONFIG"
 };
@@ -321,6 +324,18 @@ function isSystemError(error) {
 	return error instanceof SystemError;
 }
 
+//#endregion
+//#region src/lib/typeGuards.ts
+/**
+* Narrows `unknown` to a plain `Record<string, unknown>`.
+* Returns true when the value is a non-null, non-array plain object.
+* Excludes built-in types (Date, RegExp, Map, Set) that are technically
+* objects but should not be treated as string-keyed records.
+*/
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof RegExp) && !(value instanceof Map) && !(value instanceof Set);
+}
+
 //#endregion
 //#region src/core/domain/typeGuards.ts
 /**
@@ -328,32 +343,25 @@ function isSystemError(error) {
 * Use these functions instead of `as` casts when working with `unknown` values.
 */
 /**
-* Narrows `unknown` to `Record<string, unknown>`.
-* Returns true when the value is a non-null object (and not an array).
-*/
-function isRecord$1(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/**
 * Narrows `unknown` to `{ code: string }`.
 */
 function hasCode(value) {
-	return isRecord$1(value) && typeof value.code === "string";
+	return isRecord(value) && typeof value.code === "string";
 }
 /**
 * Narrows `unknown` to `{ value: Record<string, { value: unknown }> }`.
 * Used when processing kintone subtable rows.
 */
 function isKintoneSubtableRow(value) {
-	if (!isRecord$1(value)) return false;
-	if (!isRecord$1(value.value)) return false;
-	return Object.values(value.value).every((cell) => isRecord$1(cell) && "value" in cell);
+	if (!isRecord(value)) return false;
+	if (!isRecord(value.value)) return false;
+	return Object.values(value.value).every((cell) => isRecord(cell) && "value" in cell);
 }
 /**
 * Narrows `unknown` to `{ type?: string }`.
 */
 function hasOptionalType(value) {
-	if (!isRecord$1(value)) return false;
+	if (!isRecord(value)) return false;
 	return value.type === void 0 || typeof value.type === "string";
 }
 
@@ -369,7 +377,7 @@ const VALID_ENTITY_TYPES$10 = new Set([
 //#endregion
 //#region src/core/domain/action/services/configParser.ts
 function parseDestApp(raw, actionName) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" destApp must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" destApp must be an object`);
 	const obj = raw;
 	const result = {};
 	if (obj.app !== void 0 && obj.app !== null) result.app = String(obj.app);
@@ -377,7 +385,7 @@ function parseDestApp(raw, actionName) {
 	return result;
 }
 function parseMapping(raw, index, actionName) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" mapping at index ${index} must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" mapping at index ${index} must be an object`);
 	const obj = raw;
 	if (typeof obj.srcType !== "string" || !VALID_SRC_TYPES.has(obj.srcType)) throw new BusinessRuleError(ActionErrorCode.AcInvalidSrcType, `Action "${actionName}" mapping at index ${index} has invalid srcType: ${String(obj.srcType)}. Must be FIELD or RECORD_URL`);
 	if (typeof obj.destField !== "string" || obj.destField.length === 0) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" mapping at index ${index} must have a non-empty "destField" property`);
@@ -388,7 +396,7 @@ function parseMapping(raw, index, actionName) {
 	};
 }
 function parseEntity$4(raw, index, actionName) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" entity at index ${index} must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" entity at index ${index} must be an object`);
 	const obj = raw;
 	if (typeof obj.type !== "string" || !VALID_ENTITY_TYPES$10.has(obj.type)) throw new BusinessRuleError(ActionErrorCode.AcInvalidEntityType, `Action "${actionName}" entity at index ${index} has invalid type: ${String(obj.type)}. Must be USER, GROUP, or ORGANIZATION`);
 	if (typeof obj.code !== "string" || obj.code.length === 0) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" entity at index ${index} must have a non-empty "code" property`);
@@ -398,11 +406,11 @@ function parseEntity$4(raw, index, actionName) {
 	};
 }
 function parseActionConfig(raw, actionName) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" must be an object`);
 	const obj = raw;
 	if (actionName.length === 0) throw new BusinessRuleError(ActionErrorCode.AcEmptyActionName, "Action name (key) must not be empty");
 	if (typeof obj.index !== "number") throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" must have a numeric "index" property`);
-	if (!isRecord$1(obj.destApp)) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" must have a "destApp" object`);
+	if (!isRecord(obj.destApp)) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" must have a "destApp" object`);
 	const destApp = parseDestApp(obj.destApp, actionName);
 	if (!Array.isArray(obj.mappings)) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" must have a "mappings" array`);
 	const mappings = obj.mappings.map((item, i) => parseMapping(item, i, actionName));
@@ -426,9 +434,9 @@ const ActionConfigParser = { parse: (rawText) => {
 	} catch (error) {
 		throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigYaml, `Failed to parse YAML: ${error instanceof Error ? error.message : String(error)}`);
 	}
-	if (!isRecord$1(parsed)) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, "Config must be a YAML object");
+	if (!isRecord(parsed)) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, "Config must be a YAML object");
 	const obj = parsed;
-	if (!isRecord$1(obj.actions)) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, "Config must have an \"actions\" object");
+	if (!isRecord(obj.actions)) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, "Config must have an \"actions\" object");
 	const rawActions = obj.actions;
 	const actions = {};
 	for (const [key, value] of Object.entries(rawActions)) actions[key] = parseActionConfig(value, key);
@@ -786,10 +794,40 @@ var KintoneFileUploader = class {
 	}
 };
 
+//#endregion
+//#region src/lib/charValidation.ts
+/** Returns true if the string contains any control characters (0x00–0x1f or 0x7f). */
+function hasControlChars(s) {
+	for (let i = 0; i < s.length; i++) {
+		const ch = s.charCodeAt(i);
+		if (ch <= 31 || ch === 127) return true;
+	}
+	return false;
+}
+/** Replaces control characters (0x00–0x1f, 0x7f) with escaped `\\xNN` representation for safe display. */
+function sanitizeForDisplay(s) {
+	let result = "";
+	for (let i = 0; i < s.length; i++) {
+		const ch = s.charCodeAt(i);
+		if (ch <= 31 || ch === 127) result += `\\x${ch.toString(16).padStart(2, "0")}`;
+		else result += s[i];
+	}
+	return result;
+}
+
 //#endregion
 //#region src/core/domain/formSchema/valueObject.ts
+function hasInvalidFieldCodeChars(code) {
+	if (hasControlChars(code)) return true;
+	for (let i = 0; i < code.length; i++) {
+		const c = code[i];
+		if (c === "/" || c === "\\") return true;
+	}
+	return false;
+}
 const FieldCode = { create: (code) => {
 	if (code.length === 0) throw new BusinessRuleError(FormSchemaErrorCode.FsEmptyFieldCode, "Field code cannot be empty");
+	if (hasInvalidFieldCodeChars(code)) throw new BusinessRuleError(FormSchemaErrorCode.FsInvalidFieldCode, `Field code "${sanitizeForDisplay(code)}" contains invalid characters`);
 	return code;
 } };
 
@@ -1643,16 +1681,31 @@ async function executeMultiApp(plan, executor) {
 
 //#endregion
 //#region src/core/domain/projectConfig/valueObject.ts
+const INVALID_APP_NAME_CHARS = new Set([
+	"/",
+	"\\",
+	":",
+	"*",
+	"?",
+	"\"",
+	"<",
+	">",
+	"|"
+]);
+function hasInvalidAppNameChars(name) {
+	if (hasControlChars(name)) return true;
+	for (let i = 0; i < name.length; i++) if (INVALID_APP_NAME_CHARS.has(name[i])) return true;
+	return false;
+}
 const AppName = { create: (name) => {
 	if (name.length === 0) throw new BusinessRuleError(ProjectConfigErrorCode.PcEmptyAppName, "App name cannot be empty");
+	if (hasInvalidAppNameChars(name)) throw new BusinessRuleError(ProjectConfigErrorCode.PcInvalidAppName, `App name "${sanitizeForDisplay(name)}" contains invalid characters (path separators or control characters are not allowed)`);
+	if (name === "." || name === "..") throw new BusinessRuleError(ProjectConfigErrorCode.PcInvalidAppName, `App name "${name}" is not allowed (reserved path component)`);
 	return name;
 } };
 
 //#endregion
 //#region src/core/domain/projectConfig/services/configParser.ts
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function asOptionalString(value) {
 	return typeof value === "string" ? value : void 0;
 }
@@ -1726,19 +1779,21 @@ function parseAuth(raw) {
 	if (!raw) return void 0;
 	const apiToken = asOptionalString(raw.apiToken);
 	if (apiToken !== void 0) {
-		if (apiToken.trim().length === 0) throw new BusinessRuleError(ProjectConfigErrorCode.PcInvalidAuthConfig, "apiToken must not be empty");
+		const trimmed = apiToken.trim();
+		if (trimmed.length === 0) throw new BusinessRuleError(ProjectConfigErrorCode.PcInvalidAuthConfig, "apiToken must not be empty");
 		return {
 			type: "apiToken",
-			apiToken
+			apiToken: trimmed
 		};
 	}
 	const username = asOptionalString(raw.username);
 	const password = asOptionalString(raw.password);
 	if (username !== void 0 && password !== void 0) {
-		if (username.trim().length === 0 || password.trim().length === 0) throw new BusinessRuleError(ProjectConfigErrorCode.PcInvalidAuthConfig, "username and password must not be empty");
+		const trimmedUsername = username.trim();
+		if (trimmedUsername.length === 0 || password.length === 0) throw new BusinessRuleError(ProjectConfigErrorCode.PcInvalidAuthConfig, "username and password must not be empty");
 		return {
 			type: "password",
-			username,
+			username: trimmedUsername,
 			password
 		};
 	}
@@ -1799,7 +1854,8 @@ function resolveExecutionOrder(apps) {
 		queue.push(...nextBatch);
 	}
 	if (orderedNames.length !== apps.size) {
-		const cycleNodes = [...apps.keys()].filter((name) => !orderedNames.includes(name));
+		const orderedSet = new Set(orderedNames);
+		const cycleNodes = [...apps.keys()].filter((name) => !orderedSet.has(name));
 		throw new BusinessRuleError(ProjectConfigErrorCode.PcCircularDependency, `Circular dependency detected among: ${cycleNodes.join(", ")}`);
 	}
 	return { orderedApps: orderedNames.flatMap((name) => {
@@ -1964,42 +2020,73 @@ function colorizeDiffEntry(type) {
 		prefix: type === "added" ? "+" : type === "deleted" ? "-" : "~"
 	};
 }
-function printDiffResult(result) {
+function printGenericDiffResult(result, title, formatEntry) {
+	for (const w of result.warnings) p.log.warn(w);
 	if (result.isEmpty) {
 		p.log.info("No changes detected.");
 		return;
 	}
 	p.log.info(`Changes: ${formatDiffSummary(result.summary)}`);
-	if (result.hasLayoutChanges) p.log.info("Layout changes detected.");
 	const lines = result.entries.map((entry) => {
 		const { colorize, prefix } = colorizeDiffEntry(entry.type);
-		return `${colorize(prefix)} ${pc.dim("[")}${colorize(entry.fieldCode)}${pc.dim("]")} ${entry.fieldLabel}${pc.dim(":")} ${entry.details}`;
+		return formatEntry(entry, colorize, prefix);
 	});
-	p.note(lines.join("\n"), "Diff Details", { format: (v) => v });
+	p.note(lines.join("\n"), title, { format: (v) => v });
 }
-function printViewDiffResult(result) {
-	if (result.isEmpty) {
-		p.log.info("No changes detected.");
-		return;
-	}
-	p.log.info(`Changes: ${formatDiffSummary(result.summary)}`);
-	const lines = result.entries.map((entry) => {
-		const { colorize, prefix } = colorizeDiffEntry(entry.type);
-		return `${colorize(prefix)} ${colorize(entry.viewName)}${pc.dim(":")} ${entry.details}`;
+function printActionDiffResult(result) {
+	printGenericDiffResult(result, "Action Diff Details", (entry, colorize, prefix) => `${colorize(prefix)} ${colorize(entry.actionName)}${pc.dim(":")} ${entry.details}`);
+}
+function printAdminNotesDiffResult(result) {
+	printFieldDiffResult(result, "Admin Notes Diff Details");
+}
+function printAppPermissionDiffResult(result) {
+	printGenericDiffResult(result, "App Permission Diff Details", (entry, colorize, prefix) => `${colorize(prefix)} ${colorize(entry.entityKey)}${pc.dim(":")} ${entry.details}`);
+}
+function printCustomizationDiffResult(result) {
+	printGenericDiffResult(result, "Customization Diff Details", (entry, colorize, prefix) => {
+		const location = entry.platform === "config" ? entry.category : `${entry.platform}.${entry.category}`;
+		return `${colorize(prefix)} ${pc.dim("[")}${colorize(location)}${pc.dim("]")} ${entry.name}${pc.dim(":")} ${entry.details}`;
 	});
-	p.note(lines.join("\n"), "View Diff Details", { format: (v) => v });
 }
-function printProcessDiffResult(result) {
+function printDiffResult(result) {
 	if (result.isEmpty) {
 		p.log.info("No changes detected.");
 		return;
 	}
 	p.log.info(`Changes: ${formatDiffSummary(result.summary)}`);
+	if (result.hasLayoutChanges) p.log.info("Layout changes detected.");
 	const lines = result.entries.map((entry) => {
 		const { colorize, prefix } = colorizeDiffEntry(entry.type);
-		return `${colorize(prefix)} ${pc.dim("[")}${colorize(entry.category)}${pc.dim("]")} ${entry.name}${pc.dim(":")} ${entry.details}`;
+		return `${colorize(prefix)} ${pc.dim("[")}${colorize(entry.fieldCode)}${pc.dim("]")} ${entry.fieldLabel}${pc.dim(":")} ${entry.details}`;
 	});
-	p.note(lines.join("\n"), "Process Management Diff Details", { format: (v) => v });
+	p.note(lines.join("\n"), "Diff Details", { format: (v) => v });
+}
+function printFieldPermissionDiffResult(result) {
+	printGenericDiffResult(result, "Field Permission Diff Details", (entry, colorize, prefix) => `${colorize(prefix)} ${pc.dim("[")}${colorize(entry.fieldCode)}${pc.dim("]:")} ${entry.details}`);
+}
+function printGeneralSettingsDiffResult(result) {
+	printFieldDiffResult(result, "General Settings Diff Details");
+}
+function printNotificationDiffResult(result) {
+	printGenericDiffResult(result, "Notification Diff Details", (entry, colorize, prefix) => `${colorize(prefix)} ${pc.dim("[")}${colorize(entry.section)}${pc.dim("]")} ${entry.name}${pc.dim(":")} ${entry.details}`);
+}
+function printPluginDiffResult(result) {
+	printGenericDiffResult(result, "Plugin Diff Details", (entry, colorize, prefix) => `${colorize(prefix)} ${colorize(entry.pluginId)}${pc.dim(":")} ${entry.details}`);
+}
+function printProcessDiffResult(result) {
+	printGenericDiffResult(result, "Process Management Diff Details", (entry, colorize, prefix) => `${colorize(prefix)} ${pc.dim("[")}${colorize(entry.category)}${pc.dim("]")} ${entry.name}${pc.dim(":")} ${entry.details}`);
+}
+function printRecordPermissionDiffResult(result) {
+	printGenericDiffResult(result, "Record Permission Diff Details", (entry, colorize, prefix) => `${colorize(prefix)} ${pc.dim("[")}${colorize(entry.filterCond === "" ? "(all records)" : entry.filterCond)}${pc.dim("]:")} ${entry.details}`);
+}
+function printReportDiffResult(result) {
+	printGenericDiffResult(result, "Report Diff Details", (entry, colorize, prefix) => `${colorize(prefix)} ${colorize(entry.reportName)}${pc.dim(":")} ${entry.details}`);
+}
+function printViewDiffResult(result) {
+	printGenericDiffResult(result, "View Diff Details", (entry, colorize, prefix) => `${colorize(prefix)} ${colorize(entry.viewName)}${pc.dim(":")} ${entry.details}`);
+}
+function printFieldDiffResult(result, title) {
+	printGenericDiffResult(result, title, (entry, colorize, prefix) => `${colorize(prefix)} ${colorize(entry.field)}${pc.dim(":")} ${entry.details}`);
 }
 function printAppHeader(appName, appId) {
 	p.log.step(`\n=== [${pc.bold(appName)}] (app: ${appId}) ===`);
@@ -2051,8 +2138,13 @@ async function promptDeploy(container, skipConfirm) {
 	}
 	const ds = p.spinner();
 	ds.start("Deploying to production...");
-	await deployApp({ container });
-	ds.stop("Deployment complete.");
+	try {
+		await deployApp({ container });
+		ds.stop("Deployment complete.");
+	} catch (error) {
+		ds.stop("Deployment failed.");
+		throw error;
+	}
 	p.log.success("Deployed to production.");
 }
 
@@ -2321,7 +2413,7 @@ function serializeMapping(mapping) {
 	if (mapping.srcField !== void 0) result.srcField = mapping.srcField;
 	return result;
 }
-function serializeEntity$1(entity) {
+function serializeEntity$2(entity) {
 	return {
 		type: entity.type,
 		code: entity.code
@@ -2332,7 +2424,7 @@ function serializeActionConfig(config) {
 		index: config.index,
 		destApp: serializeDestApp(config.destApp),
 		mappings: config.mappings.map(serializeMapping),
-		entities: config.entities.map(serializeEntity$1),
+		entities: config.entities.map(serializeEntity$2),
 		filterCond: config.filterCond
 	};
 }
@@ -2407,6 +2499,238 @@ var capture_default$13 = define({
 	}
 });
 
+//#endregion
+//#region src/lib/deepEqual.ts
+function isArrayEqual(a, b, seen) {
+	if (!Array.isArray(b)) return false;
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (!deepEqualInner(a[i], b[i], seen)) return false;
+	return true;
+}
+function isRecordEqual(a, b, seen) {
+	const keysA = Object.keys(a);
+	const keysB = Object.keys(b);
+	if (keysA.length !== keysB.length) return false;
+	for (const key of keysA) {
+		if (!Object.hasOwn(b, key)) return false;
+		if (!deepEqualInner(a[key], b[key], seen)) return false;
+	}
+	return true;
+}
+function isMapEqual$1(a, b, seen) {
+	if (!(b instanceof Map)) return false;
+	if (a.size !== b.size) return false;
+	for (const [key, valA] of a) {
+		if (!b.has(key)) return false;
+		if (!deepEqualInner(valA, b.get(key), seen)) return false;
+	}
+	return true;
+}
+function isSetEqual(a, b, _seen) {
+	if (!(b instanceof Set)) return false;
+	if (a.size !== b.size) return false;
+	const remaining = [...b];
+	for (const valA of a) {
+		const idx = remaining.findIndex((valB) => deepEqualInner(valA, valB, /* @__PURE__ */ new WeakSet()));
+		if (idx === -1) return false;
+		remaining.splice(idx, 1);
+	}
+	return true;
+}
+function deepEqualInner(a, b, seen) {
+	if (a === b) return true;
+	if (a === null || b === null) return a === b;
+	if (typeof a !== typeof b) return false;
+	if (typeof a !== "object") return false;
+	const objA = a;
+	const objB = b;
+	if (seen.has(objA) || seen.has(objB)) return false;
+	seen.add(objA);
+	seen.add(objB);
+	if (Array.isArray(objA)) return isArrayEqual(objA, objB, seen);
+	if (objA instanceof Date && objB instanceof Date) return objA.getTime() === objB.getTime();
+	if (objA instanceof Date || objB instanceof Date) return false;
+	if (objA instanceof RegExp && objB instanceof RegExp) return String(objA) === String(objB);
+	if (objA instanceof RegExp || objB instanceof RegExp) return false;
+	if (objA instanceof Map) return isMapEqual$1(objA, objB, seen);
+	if (objB instanceof Map) return false;
+	if (objA instanceof Set) return isSetEqual(objA, objB, seen);
+	if (objB instanceof Set) return false;
+	if (isRecord(objA) && isRecord(objB)) return isRecordEqual(objA, objB, seen);
+	return false;
+}
+/**
+* Deep equality comparison for structured data.
+* Supports primitives, plain objects, arrays, Date, RegExp, Map, and Set.
+* Has circular reference protection via a WeakSet-based seen check (tracks both sides).
+*
+* Note: `{ a: undefined }` and `{}` are NOT considered equal. This differs from
+* JSON.stringify behavior but is intentional — explicit undefined properties are
+* semantically distinct from absent properties.
+*
+* Set comparison is order-independent: each element in one set is matched to an
+* element in the other using deep equality (O(n²)).
+*
+* NaN handling: `deepEqual(NaN, NaN)` returns `false` because the comparison
+* uses strict equality (`===`) for primitives, and `NaN !== NaN` in JavaScript.
+*
+* Circular reference limitation: objects already visited by the traversal are
+* treated as non-equal. This means structurally identical circular references
+* (e.g. `a.self = a` vs `b.self = b`) return `false`. This is a conservative
+* approach that prevents infinite recursion but may produce false negatives.
+*/
+function deepEqual(a, b) {
+	return deepEqualInner(a, b, /* @__PURE__ */ new WeakSet());
+}
+
+//#endregion
+//#region src/core/domain/diff.ts
+const typeOrder = {
+	added: 0,
+	modified: 1,
+	deleted: 2
+};
+function buildDiffResult(entries, warnings = []) {
+	const sorted = [...entries].sort((a, b) => typeOrder[a.type] - typeOrder[b.type]);
+	let added = 0;
+	let modified = 0;
+	let deleted = 0;
+	for (const e of sorted) if (e.type === "added") added++;
+	else if (e.type === "modified") modified++;
+	else deleted++;
+	return {
+		entries: sorted,
+		summary: {
+			added,
+			modified,
+			deleted,
+			total: sorted.length
+		},
+		isEmpty: sorted.length === 0,
+		warnings
+	};
+}
+
+//#endregion
+//#region src/core/domain/action/services/diffDetector.ts
+function compareActions$1(local, remote) {
+	const diffs = [];
+	if (local.index !== remote.index) diffs.push(`index: ${remote.index} -> ${local.index}`);
+	if (local.name !== remote.name) diffs.push(`name: "${remote.name}" -> "${local.name}"`);
+	if (!deepEqual(local.destApp, remote.destApp)) diffs.push("destApp changed");
+	if (local.filterCond !== remote.filterCond) diffs.push("filterCond changed");
+	if (!deepEqual(local.mappings, remote.mappings)) if (local.mappings.length !== remote.mappings.length) diffs.push(`mappings: ${remote.mappings.length} -> ${local.mappings.length}`);
+	else diffs.push("mappings changed");
+	if (!deepEqual(local.entities, remote.entities)) diffs.push("entities changed");
+	return diffs;
+}
+const ActionDiffDetector = { detect: (local, remote) => {
+	const entries = [];
+	for (const [name, localAction] of Object.entries(local.actions)) {
+		const remoteAction = remote.actions[name];
+		if (!remoteAction) entries.push({
+			type: "added",
+			actionName: name,
+			details: `dest: ${localAction.destApp.app ?? localAction.destApp.code ?? "(unspecified)"}`
+		});
+		else {
+			const diffs = compareActions$1(localAction, remoteAction);
+			if (diffs.length > 0) entries.push({
+				type: "modified",
+				actionName: name,
+				details: diffs.join(", ")
+			});
+		}
+	}
+	for (const [name, remoteAction] of Object.entries(remote.actions)) if (!local.actions[name]) entries.push({
+		type: "deleted",
+		actionName: name,
+		details: `dest: ${remoteAction.destApp.app ?? remoteAction.destApp.code ?? "(unspecified)"}`
+	});
+	return buildDiffResult(entries);
+} };
+
+//#endregion
+//#region src/core/application/detectDiffBase.ts
+async function detectDiffFromConfig(config) {
+	const [storageResult, remote] = await Promise.all([config.getStorage(), config.fetchRemote()]);
+	if (!storageResult.exists) throw new ValidationError(ValidationErrorCode.InvalidInput, config.notFoundMessage);
+	const local = config.parseConfig(storageResult.content);
+	return config.detect(local, remote);
+}
+
+//#endregion
+//#region src/core/application/action/detectActionDiff.ts
+async function detectActionDiff({ container }) {
+	return detectDiffFromConfig({
+		getStorage: () => container.actionStorage.get(),
+		fetchRemote: () => container.actionConfigurator.getActions(),
+		parseConfig: parseActionConfigText,
+		detect: (local, remote) => ActionDiffDetector.detect(local, { actions: remote.actions }),
+		notFoundMessage: "Action config file not found"
+	});
+}
+
+//#endregion
+//#region src/cli/commands/diffCommandFactory.ts
+function createDiffCommand(config) {
+	async function runDiff(containerConfig) {
+		const container = config.createContainer(containerConfig);
+		const s = p.spinner();
+		s.start(config.spinnerMessage);
+		let result;
+		try {
+			result = await config.detectDiff({ container });
+		} catch (error) {
+			s.stop("Comparison failed.");
+			throw error;
+		}
+		s.stop("Comparison complete.");
+		config.printResult(result);
+	}
+	return define({
+		name: "diff",
+		description: config.description,
+		args: config.args,
+		run: async (ctx) => {
+			try {
+				const values = ctx.values;
+				await routeMultiApp(values, {
+					singleLegacy: async () => {
+						await runDiff(config.resolveContainerConfig(values));
+					},
+					singleApp: async (app, projectConfig) => {
+						await runDiff(config.resolveAppContainerConfig(app, projectConfig, values));
+					},
+					multiApp: async (plan, projectConfig) => {
+						await runMultiAppWithFailCheck(plan, async (app) => {
+							const containerConfig = config.resolveAppContainerConfig(app, projectConfig, values);
+							printAppHeader(app.name, app.appId);
+							await runDiff(containerConfig);
+						}, config.multiAppSuccessMessage);
+					}
+				});
+			} catch (error) {
+				handleCliError(error);
+			}
+		}
+	});
+}
+
+//#endregion
+//#region src/cli/commands/action/diff.ts
+var diff_default$12 = createDiffCommand({
+	description: "Compare local action config with remote kintone app",
+	args: actionArgs,
+	spinnerMessage: "Comparing action settings...",
+	multiAppSuccessMessage: "All action diffs completed successfully.",
+	createContainer: createActionCliContainer,
+	detectDiff: detectActionDiff,
+	printResult: printActionDiffResult,
+	resolveContainerConfig: resolveActionContainerConfig,
+	resolveAppContainerConfig: resolveActionAppContainerConfig
+});
+
 //#endregion
 //#region src/cli/commands/action/index.ts
 var action_default = define({
@@ -2414,7 +2738,8 @@ var action_default = define({
 	description: "Manage kintone action settings",
 	subCommands: {
 		apply: apply_default$12,
-		capture: capture_default$13
+		capture: capture_default$13,
+		diff: diff_default$12
 	},
 	run: () => {}
 });
@@ -2429,7 +2754,7 @@ const AdminNotesConfigParser = { parse: (rawText) => {
 	} catch (error) {
 		throw new BusinessRuleError(AdminNotesErrorCode.AnInvalidConfigYaml, `Failed to parse YAML: ${error instanceof Error ? error.message : String(error)}`);
 	}
-	if (!isRecord$1(parsed)) throw new BusinessRuleError(AdminNotesErrorCode.AnInvalidConfigStructure, "Config must be a YAML object");
+	if (!isRecord(parsed)) throw new BusinessRuleError(AdminNotesErrorCode.AnInvalidConfigStructure, "Config must be a YAML object");
 	const obj = parsed;
 	if (typeof obj.content !== "string") throw new BusinessRuleError(AdminNotesErrorCode.AnInvalidConfigStructure, "Config must have a \"content\" string property");
 	if (typeof obj.includeInTemplateAndDuplicates !== "boolean") throw new BusinessRuleError(AdminNotesErrorCode.AnInvalidConfigStructure, "Config must have an \"includeInTemplateAndDuplicates\" boolean property");
@@ -2662,6 +2987,52 @@ var capture_default$12 = define({
 	}
 });
 
+//#endregion
+//#region src/core/domain/adminNotes/services/diffDetector.ts
+function compareConfigs$2(local, remote) {
+	const entries = [];
+	if (local.content !== remote.content) entries.push({
+		type: "modified",
+		field: "content",
+		details: "content changed"
+	});
+	if (local.includeInTemplateAndDuplicates !== remote.includeInTemplateAndDuplicates) entries.push({
+		type: "modified",
+		field: "includeInTemplateAndDuplicates",
+		details: `${String(remote.includeInTemplateAndDuplicates)} -> ${String(local.includeInTemplateAndDuplicates)}`
+	});
+	return entries;
+}
+const AdminNotesDiffDetector = { detect: (local, remote) => {
+	return buildDiffResult(compareConfigs$2(local, remote));
+} };
+
+//#endregion
+//#region src/core/application/adminNotes/detectAdminNotesDiff.ts
+async function detectAdminNotesDiff({ container }) {
+	return detectDiffFromConfig({
+		getStorage: () => container.adminNotesStorage.get(),
+		fetchRemote: () => container.adminNotesConfigurator.getAdminNotes(),
+		parseConfig: parseAdminNotesConfigText,
+		detect: (local, remote) => AdminNotesDiffDetector.detect(local, remote.config),
+		notFoundMessage: "Admin notes config file not found"
+	});
+}
+
+//#endregion
+//#region src/cli/commands/admin-notes/diff.ts
+var diff_default$11 = createDiffCommand({
+	description: "Compare local admin notes config with remote kintone app",
+	args: adminNotesArgs,
+	spinnerMessage: "Comparing admin notes...",
+	multiAppSuccessMessage: "All admin notes diffs completed successfully.",
+	createContainer: createAdminNotesCliContainer,
+	detectDiff: detectAdminNotesDiff,
+	printResult: printAdminNotesDiffResult,
+	resolveContainerConfig: resolveAdminNotesContainerConfig,
+	resolveAppContainerConfig: resolveAdminNotesAppContainerConfig
+});
+
 //#endregion
 //#region src/cli/commands/admin-notes/index.ts
 var admin_notes_default = define({
@@ -2669,7 +3040,8 @@ var admin_notes_default = define({
 	description: "Manage kintone admin notes",
 	subCommands: {
 		apply: apply_default$11,
-		capture: capture_default$12
+		capture: capture_default$12,
+		diff: diff_default$11
 	},
 	run: () => {}
 });
@@ -2683,7 +3055,7 @@ const VALID_ENTITY_TYPES$9 = new Set([
 	"CREATOR"
 ]);
 function parseEntity$3(raw, index) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(AppPermissionErrorCode.ApInvalidConfigStructure, `Entity at index ${index} must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(AppPermissionErrorCode.ApInvalidConfigStructure, `Entity at index ${index} must be an object`);
 	const obj = raw;
 	if (typeof obj.type !== "string" || !VALID_ENTITY_TYPES$9.has(obj.type)) throw new BusinessRuleError(AppPermissionErrorCode.ApInvalidEntityType, `Entity at index ${index} has invalid type: ${String(obj.type)}. Must be USER, GROUP, ORGANIZATION, or CREATOR`);
 	const type = obj.type;
@@ -2703,7 +3075,7 @@ function parseBooleanField$1(obj, field, index) {
 	return value;
 }
 function parseAppRight(raw, index) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(AppPermissionErrorCode.ApInvalidConfigStructure, `App right at index ${index} must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(AppPermissionErrorCode.ApInvalidConfigStructure, `App right at index ${index} must be an object`);
 	const obj = raw;
 	return {
 		entity: parseEntity$3(obj.entity, index),
@@ -2725,7 +3097,7 @@ const AppPermissionConfigParser = { parse: (rawText) => {
 	} catch (error) {
 		throw new BusinessRuleError(AppPermissionErrorCode.ApInvalidConfigYaml, `Failed to parse YAML: ${error instanceof Error ? error.message : String(error)}`);
 	}
-	if (!isRecord$1(parsed)) throw new BusinessRuleError(AppPermissionErrorCode.ApInvalidConfigStructure, "Config must be a YAML object");
+	if (!isRecord(parsed)) throw new BusinessRuleError(AppPermissionErrorCode.ApInvalidConfigStructure, "Config must be a YAML object");
 	const obj = parsed;
 	if (!Array.isArray(obj.rights)) throw new BusinessRuleError(AppPermissionErrorCode.ApInvalidConfigStructure, "Config must have a \"rights\" array");
 	const rights = obj.rights.map((item, i) => parseAppRight(item, i));
@@ -3016,6 +3388,84 @@ var capture_default$11 = define({
 	}
 });
 
+//#endregion
+//#region src/core/domain/appPermission/services/diffDetector.ts
+const BOOLEAN_FLAGS = [
+	"includeSubs",
+	"appEditable",
+	"recordViewable",
+	"recordAddable",
+	"recordEditable",
+	"recordDeletable",
+	"recordImportable",
+	"recordExportable"
+];
+function entityKey(right) {
+	return `${right.entity.type}:${right.entity.code}`;
+}
+function describeRight$1(right) {
+	const flags = BOOLEAN_FLAGS.filter((f) => f !== "includeSubs" && right[f]);
+	return flags.length > 0 ? flags.join(", ") : "no permissions";
+}
+function compareRights(local, remote) {
+	const diffs = [];
+	for (const flag of BOOLEAN_FLAGS) if (local[flag] !== remote[flag]) diffs.push(`${flag}: ${String(remote[flag])} -> ${String(local[flag])}`);
+	return diffs;
+}
+const AppPermissionDiffDetector = { detect: (local, remote) => {
+	const entries = [];
+	const localMap = new Map(local.rights.map((r) => [entityKey(r), r]));
+	const remoteMap = new Map(remote.rights.map((r) => [entityKey(r), r]));
+	for (const [key, localRight] of localMap) {
+		const remoteRight = remoteMap.get(key);
+		if (!remoteRight) entries.push({
+			type: "added",
+			entityKey: key,
+			details: describeRight$1(localRight)
+		});
+		else {
+			const diffs = compareRights(localRight, remoteRight);
+			if (diffs.length > 0) entries.push({
+				type: "modified",
+				entityKey: key,
+				details: diffs.join(", ")
+			});
+		}
+	}
+	for (const [key, remoteRight] of remoteMap) if (!localMap.has(key)) entries.push({
+		type: "deleted",
+		entityKey: key,
+		details: describeRight$1(remoteRight)
+	});
+	return buildDiffResult(entries);
+} };
+
+//#endregion
+//#region src/core/application/appPermission/detectAppPermissionDiff.ts
+async function detectAppPermissionDiff({ container }) {
+	return detectDiffFromConfig({
+		getStorage: () => container.appPermissionStorage.get(),
+		fetchRemote: () => container.appPermissionConfigurator.getAppPermissions(),
+		parseConfig: parseAppPermissionConfigText,
+		detect: (local, remote) => AppPermissionDiffDetector.detect(local, { rights: remote.rights }),
+		notFoundMessage: "App permission config file not found"
+	});
+}
+
+//#endregion
+//#region src/cli/commands/app-acl/diff.ts
+var diff_default$10 = createDiffCommand({
+	description: "Compare local app permission config with remote kintone app",
+	args: appAclArgs,
+	spinnerMessage: "Comparing app permissions...",
+	multiAppSuccessMessage: "All app permission diffs completed successfully.",
+	createContainer: createAppPermissionCliContainer,
+	detectDiff: detectAppPermissionDiff,
+	printResult: printAppPermissionDiffResult,
+	resolveContainerConfig: resolveAppAclContainerConfig,
+	resolveAppContainerConfig: resolveAppAclAppContainerConfig
+});
+
 //#endregion
 //#region src/cli/commands/app-acl/index.ts
 var app_acl_default = define({
@@ -3023,7 +3473,8 @@ var app_acl_default = define({
 	description: "Manage kintone app access permissions",
 	subCommands: {
 		apply: apply_default$10,
-		capture: capture_default$11
+		capture: capture_default$11,
+		diff: diff_default$10
 	},
 	run: () => {}
 });
@@ -3065,7 +3516,7 @@ const VALID_SCOPES = new Set([
 ]);
 const VALID_RESOURCE_TYPES = new Set(["FILE", "URL"]);
 function parseResource(raw, index) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(CustomizationErrorCode.CzInvalidConfigStructure, `Resource at index ${index} must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(CustomizationErrorCode.CzInvalidConfigStructure, `Resource at index ${index} must be an object`);
 	const obj = raw;
 	const type = obj.type;
 	if (typeof type !== "string" || !VALID_RESOURCE_TYPES.has(type)) throw new BusinessRuleError(CustomizationErrorCode.CzInvalidResourceType, `Resource at index ${index} has invalid type: ${String(type)}. Must be FILE or URL`);
@@ -3087,7 +3538,7 @@ function parseResourceList(raw) {
 	return raw.map((item, index) => parseResource(item, index));
 }
 function parsePlatform(raw) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(CustomizationErrorCode.CzInvalidConfigStructure, "Platform configuration must be an object");
+	if (!isRecord(raw)) throw new BusinessRuleError(CustomizationErrorCode.CzInvalidConfigStructure, "Platform configuration must be an object");
 	const obj = raw;
 	return {
 		js: obj.js === void 0 || obj.js === null ? [] : parseResourceList(obj.js),
@@ -3102,7 +3553,7 @@ const ConfigParser = { parse: (rawText) => {
 	} catch (error) {
 		throw new BusinessRuleError(CustomizationErrorCode.CzInvalidConfigYaml, `Failed to parse YAML: ${error instanceof Error ? error.message : String(error)}`);
 	}
-	if (!isRecord$1(parsed)) throw new BusinessRuleError(CustomizationErrorCode.CzInvalidConfigStructure, "Config must be a YAML object");
+	if (!isRecord(parsed)) throw new BusinessRuleError(CustomizationErrorCode.CzInvalidConfigStructure, "Config must be a YAML object");
 	const obj = parsed;
 	let scope;
 	if (obj.scope !== void 0 && obj.scope !== null) {
@@ -3499,6 +3950,105 @@ var apply_default$9 = define({
 	}
 });
 
+//#endregion
+//#region src/core/domain/customization/valueObject.ts
+const DEFAULT_CUSTOMIZATION_SCOPE = "ALL";
+
+//#endregion
+//#region src/core/domain/customization/services/diffDetector.ts
+function resourceName(resource) {
+	if (resource.type === "URL") return resource.url;
+	const parts = resource.path.replace(/\\/g, "/").split("/");
+	return parts[parts.length - 1];
+}
+function remoteResourceName(resource) {
+	if (resource.type === "URL") return resource.url;
+	return resource.file.name;
+}
+function compareResourceLists(localResources, remoteResources, platform, resourceType, warnings) {
+	const entries = [];
+	const localNames = localResources.map(resourceName);
+	const remoteNames = remoteResources.map(remoteResourceName);
+	const localNameSet = new Set(localNames);
+	const remoteNameSet = new Set(remoteNames);
+	const hasDuplicates = localNames.length !== localNameSet.size || remoteNames.length !== remoteNameSet.size;
+	if (hasDuplicates) warnings.push(`[${platform}.${resourceType}] duplicate basenames detected; diff results may be inaccurate for FILE resources`);
+	for (const name of localNameSet) if (!remoteNameSet.has(name)) entries.push({
+		type: "added",
+		platform,
+		category: resourceType,
+		name,
+		details: "new resource"
+	});
+	for (const name of remoteNameSet) if (!localNameSet.has(name)) entries.push({
+		type: "deleted",
+		platform,
+		category: resourceType,
+		name,
+		details: "removed"
+	});
+	const matchedFiles = [...localNameSet].filter((n) => remoteNameSet.has(n));
+	const hasLocalFiles = localResources.some((r) => r.type === "FILE");
+	const hasRemoteFiles = remoteResources.some((r) => r.type === "FILE");
+	if (matchedFiles.length > 0 && hasLocalFiles && hasRemoteFiles) warnings.push(`[${platform}.${resourceType}] FILE resources are compared by name only; content changes are not detected`);
+	if (!hasDuplicates) {
+		const localShared = localNames.filter((n) => remoteNameSet.has(n));
+		const remoteShared = remoteNames.filter((n) => localNameSet.has(n));
+		if (localShared.length > 1 && localShared.length === remoteShared.length && localShared.some((n, i) => n !== remoteShared[i])) entries.push({
+			type: "modified",
+			platform,
+			category: resourceType,
+			name: "(order)",
+			details: "resource load order changed"
+		});
+	}
+	return entries;
+}
+function comparePlatform(localJs, localCss, remote, platform, warnings) {
+	return [...compareResourceLists(localJs, remote.js, platform, "js", warnings), ...compareResourceLists(localCss, remote.css, platform, "css", warnings)];
+}
+const CustomizationDiffDetector = { detect: (local, remote) => {
+	const entries = [];
+	const warnings = [];
+	const localScope = local.scope ?? DEFAULT_CUSTOMIZATION_SCOPE;
+	if (localScope !== remote.scope) entries.push({
+		type: "modified",
+		platform: "config",
+		category: "scope",
+		name: "scope",
+		details: `${remote.scope} -> ${localScope}`
+	});
+	entries.push(...comparePlatform(local.desktop.js, local.desktop.css, remote.desktop, "desktop", warnings));
+	entries.push(...comparePlatform(local.mobile.js, local.mobile.css, remote.mobile, "mobile", warnings));
+	return buildDiffResult(entries, warnings);
+} };
+
+//#endregion
+//#region src/core/application/customization/detectCustomizationDiff.ts
+async function detectCustomizationDiff({ container }) {
+	return detectDiffFromConfig({
+		getStorage: () => container.customizationStorage.get(),
+		fetchRemote: () => container.customizationConfigurator.getCustomization(),
+		parseConfig: (content) => parseConfigText(content),
+		detect: (local, remote) => CustomizationDiffDetector.detect(local, remote),
+		notFoundMessage: "Customization config file not found"
+	});
+}
+
+//#endregion
+//#region src/cli/commands/customize/diff.ts
+var diff_default$9 = createDiffCommand({
+	description: "Compare local customization config with remote kintone app",
+	args: customizeArgs,
+	spinnerMessage: "Comparing customization settings...",
+	multiAppSuccessMessage: "All customization diffs completed successfully.",
+	createContainer: createCustomizationCliContainer,
+	detectDiff: detectCustomizationDiff,
+	printResult: printCustomizationDiffResult,
+	resolveContainerConfig: resolveCustomizeConfig,
+	resolveAppContainerConfig: resolveCustomizeAppConfig
+});
+
 //#endregion
 //#region src/cli/commands/customize/index.ts
 var customize_default = define({
@@ -3506,7 +4056,8 @@ var customize_default = define({
 	description: "Manage kintone JS/CSS customizations",
 	subCommands: {
 		apply: apply_default$9,
-		capture: capture_default$10
+		capture: capture_default$10,
+		diff: diff_default$9
 	},
 	run: () => {}
 });
@@ -3635,7 +4186,7 @@ const VALID_ENTITY_TYPES$6 = new Set([
 	"FIELD_ENTITY"
 ]);
 function parseEntity$2(raw, index) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(FieldPermissionErrorCode.FpInvalidConfigStructure, `Entity at index ${index} must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(FieldPermissionErrorCode.FpInvalidConfigStructure, `Entity at index ${index} must be an object`);
 	const obj = raw;
 	if (typeof obj.type !== "string" || !VALID_ENTITY_TYPES$6.has(obj.type)) throw new BusinessRuleError(FieldPermissionErrorCode.FpInvalidEntityType, `Entity at index ${index} has invalid type: ${String(obj.type)}. Must be USER, GROUP, ORGANIZATION, or FIELD_ENTITY`);
 	if (typeof obj.code !== "string" || obj.code.length === 0) throw new BusinessRuleError(FieldPermissionErrorCode.FpEmptyEntityCode, `Entity at index ${index} must have a non-empty "code" property`);
@@ -3645,7 +4196,7 @@ function parseEntity$2(raw, index) {
 	};
 }
 function parseFieldRightEntity(raw, index) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(FieldPermissionErrorCode.FpInvalidConfigStructure, `Field right entity at index ${index} must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(FieldPermissionErrorCode.FpInvalidConfigStructure, `Field right entity at index ${index} must be an object`);
 	const obj = raw;
 	if (typeof obj.accessibility !== "string" || !VALID_ACCESSIBILITIES.has(obj.accessibility)) throw new BusinessRuleError(FieldPermissionErrorCode.FpInvalidAccessibility, `Field right entity at index ${index} has invalid accessibility: ${String(obj.accessibility)}. Must be READ, WRITE, or NONE`);
 	const entity = parseEntity$2(obj.entity, index);
@@ -3660,7 +4211,7 @@ function parseFieldRightEntity(raw, index) {
 	return result;
 }
 function parseFieldRight(raw, index) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(FieldPermissionErrorCode.FpInvalidConfigStructure, `Field right at index ${index} must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(FieldPermissionErrorCode.FpInvalidConfigStructure, `Field right at index ${index} must be an object`);
 	const obj = raw;
 	if (typeof obj.code !== "string" || obj.code.length === 0) throw new BusinessRuleError(FieldPermissionErrorCode.FpEmptyFieldCode, `Field right at index ${index} must have a non-empty "code" property`);
 	if (!Array.isArray(obj.entities)) throw new BusinessRuleError(FieldPermissionErrorCode.FpInvalidConfigStructure, `Field right at index ${index} must have an "entities" array`);
@@ -3678,7 +4229,7 @@ const FieldPermissionConfigParser = { parse: (rawText) => {
 	} catch (error) {
 		throw new BusinessRuleError(FieldPermissionErrorCode.FpInvalidConfigYaml, `Failed to parse YAML: ${error instanceof Error ? error.message : String(error)}`);
 	}
-	if (!isRecord$1(parsed)) throw new BusinessRuleError(FieldPermissionErrorCode.FpInvalidConfigStructure, "Config must be a YAML object");
+	if (!isRecord(parsed)) throw new BusinessRuleError(FieldPermissionErrorCode.FpInvalidConfigStructure, "Config must be a YAML object");
 	const obj = parsed;
 	if (!Array.isArray(obj.rights)) throw new BusinessRuleError(FieldPermissionErrorCode.FpInvalidConfigStructure, "Config must have a \"rights\" array");
 	const rights = obj.rights.map((item, i) => parseFieldRight(item, i));
@@ -3860,6 +4411,72 @@ var capture_default$9 = define({
 	}
 });
 
+//#endregion
+//#region src/core/domain/fieldPermission/services/diffDetector.ts
+function areEntitiesEqual(a, b) {
+	return deepEqual(a.entities.map((e) => ({
+		accessibility: e.accessibility,
+		type: e.entity.type,
+		code: e.entity.code,
+		includeSubs: e.includeSubs ?? false
+	})), b.entities.map((e) => ({
+		accessibility: e.accessibility,
+		type: e.entity.type,
+		code: e.entity.code,
+		includeSubs: e.includeSubs ?? false
+	})));
+}
+const FieldPermissionDiffDetector = { detect: (local, remote) => {
+	const entries = [];
+	const localMap = new Map(local.rights.map((r) => [r.code, r]));
+	const remoteMap = new Map(remote.rights.map((r) => [r.code, r]));
+	for (const [code, localRight] of localMap) {
+		const remoteRight = remoteMap.get(code);
+		if (!remoteRight) entries.push({
+			type: "added",
+			fieldCode: code,
+			details: `${localRight.entities.length} entities`
+		});
+		else if (!areEntitiesEqual(localRight, remoteRight)) entries.push({
+			type: "modified",
+			fieldCode: code,
+			details: "entities changed"
+		});
+	}
+	for (const code of remoteMap.keys()) if (!localMap.has(code)) entries.push({
+		type: "deleted",
+		fieldCode: code,
+		details: "removed"
+	});
+	return buildDiffResult(entries);
+} };
+
+//#endregion
+//#region src/core/application/fieldPermission/detectFieldPermissionDiff.ts
+async function detectFieldPermissionDiff({ container }) {
+	return detectDiffFromConfig({
+		getStorage: () => container.fieldPermissionStorage.get(),
+		fetchRemote: () => container.fieldPermissionConfigurator.getFieldPermissions(),
+		parseConfig: parseFieldPermissionConfigText,
+		detect: (local, remote) => FieldPermissionDiffDetector.detect(local, { rights: remote.rights }),
+		notFoundMessage: "Field permission config file not found"
+	});
+}
+
+//#endregion
+//#region src/cli/commands/field-acl/diff.ts
+var diff_default$8 = createDiffCommand({
+	description: "Compare local field permission config with remote kintone app",
+	args: fieldAclArgs,
+	spinnerMessage: "Comparing field permissions...",
+	multiAppSuccessMessage: "All field permission diffs completed successfully.",
+	createContainer: createFieldPermissionCliContainer,
+	detectDiff: detectFieldPermissionDiff,
+	printResult: printFieldPermissionDiffResult,
+	resolveContainerConfig: resolveFieldAclContainerConfig,
+	resolveAppContainerConfig: resolveFieldAclAppContainerConfig
+});
+
 //#endregion
 //#region src/cli/commands/field-acl/index.ts
 var field_acl_default = define({
@@ -3867,7 +4484,8 @@ var field_acl_default = define({
 	description: "Manage kintone field access permissions",
 	subCommands: {
 		apply: apply_default$8,
-		capture: capture_default$9
+		capture: capture_default$9,
+		diff: diff_default$8
 	},
 	run: () => {}
 });
@@ -5322,7 +5940,7 @@ async function saveGeneralSettings({ container, input }) {
 
 //#endregion
 //#region src/core/domain/notification/services/configSerializer.ts
-function serializeEntity(entity) {
+function serializeEntity$1(entity) {
 	return {
 		type: entity.type,
 		code: entity.code
@@ -5330,7 +5948,7 @@ function serializeEntity(entity) {
 }
 function serializeGeneralNotification(notification) {
 	const result = {
-		entity: serializeEntity(notification.entity),
+		entity: serializeEntity$1(notification.entity),
 		recordAdded: notification.recordAdded,
 		recordEdited: notification.recordEdited,
 		commentAdded: notification.commentAdded,
@@ -5341,7 +5959,7 @@ function serializeGeneralNotification(notification) {
 	return result;
 }
 function serializePerRecordTarget(target) {
-	const result = { entity: serializeEntity(target.entity) };
+	const result = { entity: serializeEntity$1(target.entity) };
 	if (target.includeSubs !== void 0) result.includeSubs = target.includeSubs;
 	return result;
 }
@@ -5353,7 +5971,7 @@ function serializePerRecordNotification(notification) {
 	};
 }
 function serializeReminderTarget(target) {
-	const result = { entity: serializeEntity(target.entity) };
+	const result = { entity: serializeEntity$1(target.entity) };
 	if (target.includeSubs !== void 0) result.includeSubs = target.includeSubs;
 	return result;
 }
@@ -5619,11 +6237,7 @@ async function saveReport({ container, input }) {
 //#endregion
 //#region src/core/domain/seedData/services/seedSerializer.ts
 const SeedSerializer = { serialize: (seedData) => {
-	const records = seedData.records.map((record) => {
-		const plain = {};
-		for (const [key, value] of Object.entries(record)) plain[key] = value;
-		return plain;
-	});
+	const records = seedData.records.map((record) => ({ ...record }));
 	return stringify(seedData.key !== null ? {
 		key: seedData.key,
 		records
@@ -6053,7 +6667,7 @@ const VALID_ENTITY_TYPES$2 = new Set([
 	"FIELD_ENTITY"
 ]);
 function parseEntity$1(raw, context) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, `${context}: entity must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, `${context}: entity must be an object`);
 	const obj = raw;
 	if (typeof obj.type !== "string" || !VALID_ENTITY_TYPES$2.has(obj.type)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidEntityType, `${context}: entity has invalid type: ${String(obj.type)}. Must be USER, GROUP, ORGANIZATION, or FIELD_ENTITY`);
 	if (typeof obj.code !== "string" || obj.code.length === 0) throw new BusinessRuleError(NotificationErrorCode.NtEmptyEntityCode, `${context}: entity must have a non-empty "code" property`);
@@ -6063,7 +6677,7 @@ function parseEntity$1(raw, context) {
 	};
 }
 function parseGeneralNotification(raw, index) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, `General notification at index ${index} must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, `General notification at index ${index} must be an object`);
 	const obj = raw;
 	const result = {
 		entity: parseEntity$1(obj.entity, `General notification at index ${index}`),
@@ -6080,7 +6694,7 @@ function parseGeneralNotification(raw, index) {
 	return result;
 }
 function parseGeneralConfig(raw) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, "\"general\" must be an object");
+	if (!isRecord(raw)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, "\"general\" must be an object");
 	const obj = raw;
 	if (!Array.isArray(obj.notifications)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, "\"general\" must have a \"notifications\" array");
 	const notifications = obj.notifications.map((item, i) => parseGeneralNotification(item, i));
@@ -6090,7 +6704,7 @@ function parseGeneralConfig(raw) {
 	};
 }
 function parsePerRecordTarget(raw, index) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, `Per-record target at index ${index} must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, `Per-record target at index ${index} must be an object`);
 	const obj = raw;
 	const result = { entity: parseEntity$1(obj.entity, `Per-record target at index ${index}`) };
 	if (obj.includeSubs !== void 0 && obj.includeSubs !== null) return {
@@ -6100,7 +6714,7 @@ function parsePerRecordTarget(raw, index) {
 	return result;
 }
 function parsePerRecordNotification(raw, index) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, `Per-record notification at index ${index} must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, `Per-record notification at index ${index} must be an object`);
 	const obj = raw;
 	if (!Array.isArray(obj.targets)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, `Per-record notification at index ${index} must have a "targets" array`);
 	const targets = obj.targets.map((item, i) => parsePerRecordTarget(item, i));
@@ -6116,7 +6730,7 @@ function parsePerRecordConfig(raw) {
 	return raw.map((item, i) => parsePerRecordNotification(item, i));
 }
 function parseReminderTarget(raw, index) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, `Reminder target at index ${index} must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, `Reminder target at index ${index} must be an object`);
 	const obj = raw;
 	const result = { entity: parseEntity$1(obj.entity, `Reminder target at index ${index}`) };
 	if (obj.includeSubs !== void 0 && obj.includeSubs !== null) return {
@@ -6126,7 +6740,7 @@ function parseReminderTarget(raw, index) {
 	return result;
 }
 function parseReminderNotification(raw, index) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, `Reminder notification at index ${index} must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, `Reminder notification at index ${index} must be an object`);
 	const obj = raw;
 	if (typeof obj.code !== "string" || obj.code.length === 0) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, `Reminder notification at index ${index} must have a non-empty "code" property`);
 	if (!Array.isArray(obj.targets)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, `Reminder notification at index ${index} must have a "targets" array`);
@@ -6153,7 +6767,7 @@ function parseReminderNotification(raw, index) {
 	return result;
 }
 function parseReminderConfig(raw) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, "\"reminder\" must be an object");
+	if (!isRecord(raw)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, "\"reminder\" must be an object");
 	const obj = raw;
 	if (!Array.isArray(obj.notifications)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, "\"reminder\" must have a \"notifications\" array");
 	const notifications = obj.notifications.map((item, i) => parseReminderNotification(item, i));
@@ -6170,7 +6784,7 @@ const NotificationConfigParser = { parse: (rawText) => {
 	} catch (error) {
 		throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigYaml, `Failed to parse YAML: ${error instanceof Error ? error.message : String(error)}`);
 	}
-	if (!isRecord$1(parsed)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, "Config must be a YAML object");
+	if (!isRecord(parsed)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, "Config must be a YAML object");
 	const obj = parsed;
 	const config = {};
 	if (obj.general !== void 0) config.general = parseGeneralConfig(obj.general);
@@ -6328,13 +6942,260 @@ var capture_default$8 = define({
 });
 
 //#endregion
-//#region src/cli/commands/notification/index.ts
-var notification_default = define({
-	name: "notification",
-	description: "Manage kintone notification settings",
-	subCommands: {
+//#region src/lib/groupByKey.ts
+/**
+* Groups items by a key function into a Map where each key maps to an array of items.
+* Multiple items can share the same key, producing a multimap structure.
+*/
+function groupByKey(items, keyFn) {
+	const map = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const key = keyFn(item);
+		const existing = map.get(key);
+		if (existing) existing.push(item);
+		else map.set(key, [item]);
+	}
+	return map;
+}
+
+//#endregion
+//#region src/core/domain/notification/services/diffDetector.ts
+function serializeEntity(entity) {
+	return `${entity.type}:${entity.code}`;
+}
+const GENERAL_BOOLEAN_FLAGS = [
+	"recordAdded",
+	"recordEdited",
+	"commentAdded",
+	"statusChanged",
+	"fileImported"
+];
+function compareGeneralNotification(local, remote) {
+	const diffs = [];
+	if ((local.includeSubs ?? false) !== (remote.includeSubs ?? false)) diffs.push(`includeSubs: ${String(remote.includeSubs ?? false)} -> ${String(local.includeSubs ?? false)}`);
+	for (const flag of GENERAL_BOOLEAN_FLAGS) if (local[flag] !== remote[flag]) diffs.push(`${flag}: ${String(remote[flag])} -> ${String(local[flag])}`);
+	return diffs;
+}
+function compareGeneralSection(local, remote) {
+	const entries = [];
+	if (local.notifyToCommenter !== remote.notifyToCommenter) entries.push({
+		type: "modified",
+		section: "general",
+		name: "notifyToCommenter",
+		details: `${String(remote.notifyToCommenter)} -> ${String(local.notifyToCommenter)}`
+	});
+	const localMap = new Map(local.notifications.map((n) => [serializeEntity(n.entity), n]));
+	const remoteMap = new Map(remote.notifications.map((n) => [serializeEntity(n.entity), n]));
+	for (const [key, localNotif] of localMap) {
+		const remoteNotif = remoteMap.get(key);
+		if (!remoteNotif) entries.push({
+			type: "added",
+			section: "general",
+			name: key,
+			details: "new notification"
+		});
+		else {
+			const diffs = compareGeneralNotification(localNotif, remoteNotif);
+			if (diffs.length > 0) entries.push({
+				type: "modified",
+				section: "general",
+				name: key,
+				details: diffs.join(", ")
+			});
+		}
+	}
+	for (const key of remoteMap.keys()) if (!localMap.has(key)) entries.push({
+		type: "deleted",
+		section: "general",
+		name: key,
+		details: "removed"
+	});
+	return entries;
+}
+/**
+* Groups per-record notifications by filterCond. Multiple notifications can share
+* the same filterCond, so notifications within a group are compared by position
+* (index-based matching).
+*/
+function buildPerRecordMultiMap(notifications) {
+	return groupByKey(notifications, (n) => n.filterCond);
+}
+function perRecordLabel(notif) {
+	return notif.title || notif.filterCond || "(empty filter)";
+}
+function describePerRecordChanges(local, remote) {
+	const diffs = [];
+	if (local.title !== remote.title) diffs.push("title changed");
+	if (!deepEqual(local.targets, remote.targets)) diffs.push("targets changed");
+	return diffs.length > 0 ? diffs.join(", ") : "changed";
+}
+function describeReminderChanges(local, remote) {
+	const diffs = [];
+	if (local.title !== remote.title) diffs.push("title changed");
+	if (local.daysLater !== remote.daysLater) diffs.push("daysLater changed");
+	if ((local.hoursLater ?? 0) !== (remote.hoursLater ?? 0)) diffs.push("hoursLater changed");
+	if ((local.time ?? "") !== (remote.time ?? "")) diffs.push("time changed");
+	if (local.filterCond !== remote.filterCond) diffs.push("filterCond changed");
+	if (!deepEqual(local.targets, remote.targets)) diffs.push("targets changed");
+	return diffs.length > 0 ? diffs.join(", ") : "changed";
+}
+function comparePerRecordSection(local, remote) {
+	const entries = [];
+	const localMulti = buildPerRecordMultiMap(local);
+	const remoteMulti = buildPerRecordMultiMap(remote);
+	for (const [key, localNotifs] of localMulti) {
+		const remoteNotifs = remoteMulti.get(key) ?? [];
+		const maxLen = Math.max(localNotifs.length, remoteNotifs.length);
+		for (let i = 0; i < maxLen; i++) {
+			const localNotif = localNotifs[i];
+			const remoteNotif = remoteNotifs[i];
+			if (localNotif && !remoteNotif) entries.push({
+				type: "added",
+				section: "perRecord",
+				name: perRecordLabel(localNotif),
+				details: "new notification"
+			});
+			else if (!localNotif && remoteNotif) entries.push({
+				type: "deleted",
+				section: "perRecord",
+				name: perRecordLabel(remoteNotif),
+				details: "removed"
+			});
+			else if (localNotif && remoteNotif && !deepEqual(localNotif, remoteNotif)) {
+				const diffs = describePerRecordChanges(localNotif, remoteNotif);
+				entries.push({
+					type: "modified",
+					section: "perRecord",
+					name: perRecordLabel(localNotif),
+					details: diffs
+				});
+			}
+		}
+	}
+	for (const [key, remoteNotifs] of remoteMulti) if (!localMulti.has(key)) for (const remoteNotif of remoteNotifs) entries.push({
+		type: "deleted",
+		section: "perRecord",
+		name: perRecordLabel(remoteNotif),
+		details: "removed"
+	});
+	return entries;
+}
+function compareReminderSection(local, remote) {
+	const entries = [];
+	const localMap = new Map(local.map((n) => [n.code, n]));
+	const remoteMap = new Map(remote.map((n) => [n.code, n]));
+	for (const [code, localNotif] of localMap) {
+		const remoteNotif = remoteMap.get(code);
+		if (!remoteNotif) entries.push({
+			type: "added",
+			section: "reminder",
+			name: code,
+			details: `"${localNotif.title}"`
+		});
+		else if (!deepEqual(localNotif, remoteNotif)) entries.push({
+			type: "modified",
+			section: "reminder",
+			name: code,
+			details: describeReminderChanges(localNotif, remoteNotif)
+		});
+	}
+	for (const code of remoteMap.keys()) if (!localMap.has(code)) entries.push({
+		type: "deleted",
+		section: "reminder",
+		name: code,
+		details: "removed"
+	});
+	return entries;
+}
+const NotificationDiffDetector = { detect: (local, remote) => {
+	const entries = [];
+	if (local.general && remote.general) entries.push(...compareGeneralSection(local.general, remote.general));
+	else if (local.general && !remote.general) entries.push({
+		type: "added",
+		section: "general",
+		name: "general",
+		details: "added general notifications section"
+	});
+	else if (!local.general && remote.general) entries.push({
+		type: "deleted",
+		section: "general",
+		name: "general",
+		details: "removed general notifications section"
+	});
+	const localPerRecord = local.perRecord ?? [];
+	const remotePerRecord = remote.perRecord ?? [];
+	entries.push(...comparePerRecordSection(localPerRecord, remotePerRecord));
+	if (local.reminder && remote.reminder) {
+		entries.push(...compareReminderSection(local.reminder.notifications, remote.reminder.notifications));
+		if (local.reminder.timezone !== remote.reminder.timezone) entries.push({
+			type: "modified",
+			section: "reminder",
+			name: "timezone",
+			details: `${remote.reminder.timezone} -> ${local.reminder.timezone}`
+		});
+	} else if (local.reminder && !remote.reminder) entries.push({
+		type: "added",
+		section: "reminder",
+		name: "reminder",
+		details: "added reminder notifications section"
+	});
+	else if (!local.reminder && remote.reminder) entries.push({
+		type: "deleted",
+		section: "reminder",
+		name: "reminder",
+		details: "removed reminder notifications section"
+	});
+	return buildDiffResult(entries);
+} };
+
+//#endregion
+//#region src/core/application/notification/detectNotificationDiff.ts
+async function detectNotificationDiff({ container }) {
+	const [storageResult, generalResult, perRecordResult, reminderResult] = await Promise.all([
+		container.notificationStorage.get(),
+		container.notificationConfigurator.getGeneralNotifications(),
+		container.notificationConfigurator.getPerRecordNotifications(),
+		container.notificationConfigurator.getReminderNotifications()
+	]);
+	if (!storageResult.exists) throw new ValidationError(ValidationErrorCode.InvalidInput, "Notification config file not found");
+	const localConfig = parseNotificationConfigText(storageResult.content);
+	const remoteConfig = {
+		general: {
+			notifyToCommenter: generalResult.notifyToCommenter,
+			notifications: generalResult.notifications
+		},
+		perRecord: perRecordResult.notifications,
+		reminder: {
+			timezone: reminderResult.timezone,
+			notifications: reminderResult.notifications
+		}
+	};
+	return NotificationDiffDetector.detect(localConfig, remoteConfig);
+}
+
+//#endregion
+//#region src/cli/commands/notification/diff.ts
+var diff_default$7 = createDiffCommand({
+	description: "Compare local notification config with remote kintone app",
+	args: notificationArgs,
+	spinnerMessage: "Comparing notification settings...",
+	multiAppSuccessMessage: "All notification diffs completed successfully.",
+	createContainer: createNotificationCliContainer,
+	detectDiff: detectNotificationDiff,
+	printResult: printNotificationDiffResult,
+	resolveContainerConfig: resolveNotificationContainerConfig,
+	resolveAppContainerConfig: resolveNotificationAppContainerConfig
+});
+
+//#endregion
+//#region src/cli/commands/notification/index.ts
+var notification_default = define({
+	name: "notification",
+	description: "Manage kintone notification settings",
+	subCommands: {
 		apply: apply_default$7,
-		capture: capture_default$8
+		capture: capture_default$8,
+		diff: diff_default$7
 	},
 	run: () => {}
 });
@@ -6342,7 +7203,7 @@ var notification_default = define({
 //#endregion
 //#region src/core/domain/plugin/services/configParser.ts
 function parsePluginEntry(raw, index) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(PluginErrorCode.PlInvalidConfigStructure, `Plugin at index ${index} must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(PluginErrorCode.PlInvalidConfigStructure, `Plugin at index ${index} must be an object`);
 	const obj = raw;
 	if (typeof obj.id !== "string" || obj.id.length === 0) throw new BusinessRuleError(PluginErrorCode.PlEmptyPluginId, `Plugin at index ${index} must have a non-empty "id" property`);
 	return {
@@ -6359,7 +7220,7 @@ const PluginConfigParser = { parse: (rawText) => {
 	} catch (error) {
 		throw new BusinessRuleError(PluginErrorCode.PlInvalidConfigYaml, `Failed to parse YAML: ${error instanceof Error ? error.message : String(error)}`);
 	}
-	if (!isRecord$1(parsed)) throw new BusinessRuleError(PluginErrorCode.PlInvalidConfigStructure, "Config must be a YAML object");
+	if (!isRecord(parsed)) throw new BusinessRuleError(PluginErrorCode.PlInvalidConfigStructure, "Config must be a YAML object");
 	const obj = parsed;
 	if (!Array.isArray(obj.plugins)) throw new BusinessRuleError(PluginErrorCode.PlInvalidConfigStructure, "Config must have a \"plugins\" array");
 	return { plugins: obj.plugins.map((item, i) => parsePluginEntry(item, i)) };
@@ -6497,6 +7358,64 @@ var capture_default$7 = define({
 	}
 });
 
+//#endregion
+//#region src/core/domain/plugin/services/diffDetector.ts
+const PluginDiffDetector = { detect: (local, remote) => {
+	const entries = [];
+	const localMap = new Map(local.plugins.map((p) => [p.id, p]));
+	const remoteMap = new Map(remote.plugins.map((p) => [p.id, p]));
+	for (const [id, localPlugin] of localMap) {
+		const remotePlugin = remoteMap.get(id);
+		if (!remotePlugin) entries.push({
+			type: "added",
+			pluginId: id,
+			details: `"${localPlugin.name}"`
+		});
+		else {
+			const diffs = [];
+			if (localPlugin.name !== remotePlugin.name) diffs.push(`name: "${remotePlugin.name}" -> "${localPlugin.name}"`);
+			if (localPlugin.enabled !== remotePlugin.enabled) diffs.push(`enabled: ${String(remotePlugin.enabled)} -> ${String(localPlugin.enabled)}`);
+			if (diffs.length > 0) entries.push({
+				type: "modified",
+				pluginId: id,
+				details: diffs.join(", ")
+			});
+		}
+	}
+	for (const [id, remotePlugin] of remoteMap) if (!localMap.has(id)) entries.push({
+		type: "deleted",
+		pluginId: id,
+		details: `"${remotePlugin.name}"`
+	});
+	return buildDiffResult(entries);
+} };
+
+//#endregion
+//#region src/core/application/plugin/detectPluginDiff.ts
+async function detectPluginDiff({ container }) {
+	return detectDiffFromConfig({
+		getStorage: () => container.pluginStorage.get(),
+		fetchRemote: () => container.pluginConfigurator.getPlugins(),
+		parseConfig: parsePluginConfigText,
+		detect: (local, remote) => PluginDiffDetector.detect(local, { plugins: remote.plugins }),
+		notFoundMessage: "Plugin config file not found"
+	});
+}
+
+//#endregion
+//#region src/cli/commands/plugin/diff.ts
+var diff_default$6 = createDiffCommand({
+	description: "Compare local plugin config with remote kintone app",
+	args: pluginArgs,
+	spinnerMessage: "Comparing plugin settings...",
+	multiAppSuccessMessage: "All plugin diffs completed successfully.",
+	createContainer: createPluginCliContainer,
+	detectDiff: detectPluginDiff,
+	printResult: printPluginDiffResult,
+	resolveContainerConfig: resolvePluginContainerConfig,
+	resolveAppContainerConfig: resolvePluginAppContainerConfig
+});
+
 //#endregion
 //#region src/cli/commands/plugin/index.ts
 var plugin_default = define({
@@ -6504,7 +7423,8 @@ var plugin_default = define({
 	description: "Manage kintone plugins",
 	subCommands: {
 		apply: apply_default$6,
-		capture: capture_default$7
+		capture: capture_default$7,
+		diff: diff_default$6
 	},
 	run: () => {}
 });
@@ -6526,7 +7446,7 @@ const VALID_ENTITY_TYPES$1 = new Set([
 ]);
 const VALID_ACTION_TYPES = new Set(["PRIMARY", "SECONDARY"]);
 function parseProcessEntity(raw, index) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `Entity at index ${index} must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `Entity at index ${index} must be an object`);
 	const obj = raw;
 	if (typeof obj.type !== "string" || !VALID_ENTITY_TYPES$1.has(obj.type)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidEntityType, `Entity at index ${index} has invalid type: ${String(obj.type)}. Must be USER, GROUP, ORGANIZATION, FIELD_ENTITY, CREATOR, or CUSTOM_FIELD`);
 	const result = { type: obj.type };
@@ -6541,7 +7461,7 @@ function parseProcessEntity(raw, index) {
 	return withCode;
 }
 function parseAssignee(raw, stateName) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `Assignee for state "${stateName}" must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `Assignee for state "${stateName}" must be an object`);
 	const obj = raw;
 	if (typeof obj.type !== "string" || !VALID_ASSIGNEE_TYPES.has(obj.type)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidAssigneeType, `Assignee for state "${stateName}" has invalid type: ${String(obj.type)}. Must be ONE, ALL, or ANY`);
 	if (!Array.isArray(obj.entities)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `Assignee for state "${stateName}" must have an "entities" array`);
@@ -6552,7 +7472,7 @@ function parseAssignee(raw, stateName) {
 	};
 }
 function parseState(raw, stateName) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `State "${stateName}" must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `State "${stateName}" must be an object`);
 	const obj = raw;
 	if (typeof obj.index !== "number") throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `State "${stateName}" must have a numeric "index" property`);
 	if (obj.assignee === void 0 || obj.assignee === null) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `State "${stateName}" must have an "assignee" property`);
@@ -6563,13 +7483,13 @@ function parseState(raw, stateName) {
 	};
 }
 function parseExecutableUser(raw, actionIndex) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `Action at index ${actionIndex}: executableUser must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `Action at index ${actionIndex}: executableUser must be an object`);
 	const obj = raw;
 	if (!Array.isArray(obj.entities)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `Action at index ${actionIndex}: executableUser must have an "entities" array`);
 	return { entities: obj.entities.map((item, i) => parseProcessEntity(item, i)) };
 }
 function parseAction(raw, index) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `Action at index ${index} must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `Action at index ${index} must be an object`);
 	const obj = raw;
 	if (typeof obj.name !== "string") throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `Action at index ${index} must have a "name" string property`);
 	if (typeof obj.from !== "string") throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `Action at index ${index} must have a "from" string property`);
@@ -6597,11 +7517,11 @@ const ProcessManagementConfigParser = { parse: (rawText) => {
 	} catch (error) {
 		throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigYaml, `Failed to parse YAML: ${error instanceof Error ? error.message : String(error)}`);
 	}
-	if (!isRecord$1(parsed)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, "Config must be a YAML object");
+	if (!isRecord(parsed)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, "Config must be a YAML object");
 	const obj = parsed;
 	const enable = obj.enable !== void 0 && obj.enable !== null ? Boolean(obj.enable) : false;
-	if (obj.states !== void 0 && obj.states !== null && !isRecord$1(obj.states)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, "Config \"states\" must be an object (map of state name to state definition)");
-	const rawStates = isRecord$1(obj.states) ? obj.states : {};
+	if (obj.states !== void 0 && obj.states !== null && !isRecord(obj.states)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, "Config \"states\" must be an object (map of state name to state definition)");
+	const rawStates = isRecord(obj.states) ? obj.states : {};
 	const states = {};
 	for (const [name, value] of Object.entries(rawStates)) states[name] = parseState(value, name);
 	if (!Array.isArray(obj.actions) && obj.actions !== void 0) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, "Config \"actions\" must be an array");
@@ -6781,7 +7701,7 @@ function compareActions(localAction, remoteAction) {
 	if (!isExecutableUserEqual(localAction.executableUser, remoteAction.executableUser)) diffs.push("executableUser changed");
 	return diffs;
 }
-function compareConfigs(local, remote) {
+function compareConfigs$1(local, remote) {
 	const entries = [];
 	if (local.enable !== remote.enable) entries.push({
 		type: "modified",
@@ -6846,68 +7766,33 @@ function compareConfigs(local, remote) {
 	return entries;
 }
 const ProcessManagementDiffDetector = { detect: (local, remote) => {
-	const entries = compareConfigs(local, remote);
-	const added = entries.filter((e) => e.type === "added").length;
-	const modified = entries.filter((e) => e.type === "modified").length;
-	const deleted = entries.filter((e) => e.type === "deleted").length;
-	return {
-		entries,
-		summary: {
-			added,
-			modified,
-			deleted,
-			total: added + modified + deleted
-		},
-		isEmpty: entries.length === 0
-	};
+	return buildDiffResult(compareConfigs$1(local, remote));
 } };
 
 //#endregion
 //#region src/core/application/processManagement/detectProcessManagementDiff.ts
 async function detectProcessManagementDiff({ container }) {
-	const result = await container.processManagementStorage.get();
-	if (!result.exists) throw new ValidationError(ValidationErrorCode.InvalidInput, "Process management config file not found");
-	const localConfig = parseProcessManagementConfigText(result.content);
-	const { config: remoteConfig } = await container.processManagementConfigurator.getProcessManagement();
-	return ProcessManagementDiffDetector.detect(localConfig, remoteConfig);
+	return detectDiffFromConfig({
+		getStorage: () => container.processManagementStorage.get(),
+		fetchRemote: () => container.processManagementConfigurator.getProcessManagement(),
+		parseConfig: parseProcessManagementConfigText,
+		detect: (local, remote) => ProcessManagementDiffDetector.detect(local, remote.config),
+		notFoundMessage: "Process management config file not found"
+	});
 }
 
 //#endregion
 //#region src/cli/commands/process/diff.ts
-async function runDiffProcess(config) {
-	const container = createProcessManagementCliContainer(config);
-	const s = p.spinner();
-	s.start("Comparing process management settings...");
-	const result = await detectProcessManagementDiff({ container });
-	s.stop("Comparison complete.");
-	printProcessDiffResult(result);
-}
-var diff_default$2 = define({
-	name: "diff",
+var diff_default$5 = createDiffCommand({
 	description: "Compare local process management settings with remote kintone app",
 	args: processArgs,
-	run: async (ctx) => {
-		try {
-			const values = ctx.values;
-			await routeMultiApp(values, {
-				singleLegacy: async () => {
-					await runDiffProcess(resolveProcessContainerConfig(values));
-				},
-				singleApp: async (app, projectConfig) => {
-					await runDiffProcess(resolveProcessAppContainerConfig(app, projectConfig, values));
-				},
-				multiApp: async (plan, projectConfig) => {
-					await runMultiAppWithFailCheck(plan, async (app) => {
-						const config = resolveProcessAppContainerConfig(app, projectConfig, values);
-						printAppHeader(app.name, app.appId);
-						await runDiffProcess(config);
-					}, "All process management diffs completed successfully.");
-				}
-			});
-		} catch (error) {
-			handleCliError(error);
-		}
-	}
+	spinnerMessage: "Comparing process management settings...",
+	multiAppSuccessMessage: "All process management diffs completed successfully.",
+	createContainer: createProcessManagementCliContainer,
+	detectDiff: detectProcessManagementDiff,
+	printResult: printProcessDiffResult,
+	resolveContainerConfig: resolveProcessContainerConfig,
+	resolveAppContainerConfig: resolveProcessAppContainerConfig
 });
 
 //#endregion
@@ -6918,7 +7803,7 @@ var process_default = define({
 	subCommands: {
 		apply: apply_default$5,
 		capture: capture_default$6,
-		diff: diff_default$2
+		diff: diff_default$5
 	},
 	run: () => {}
 });
@@ -6937,7 +7822,7 @@ function parseBooleanField(value, fieldName, context) {
 	throw new BusinessRuleError(RecordPermissionErrorCode.RpInvalidPermissionValue, `${context} has invalid "${fieldName}" value: ${String(value)}. Must be a boolean`);
 }
 function parseEntity(raw, index) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(RecordPermissionErrorCode.RpInvalidConfigStructure, `Entity at index ${index} must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(RecordPermissionErrorCode.RpInvalidConfigStructure, `Entity at index ${index} must be an object`);
 	const obj = raw;
 	if (typeof obj.type !== "string" || !VALID_ENTITY_TYPES.has(obj.type)) throw new BusinessRuleError(RecordPermissionErrorCode.RpInvalidEntityType, `Entity at index ${index} has invalid type: ${String(obj.type)}. Must be USER, GROUP, ORGANIZATION, or FIELD_ENTITY`);
 	if (typeof obj.code !== "string" || obj.code.length === 0) throw new BusinessRuleError(RecordPermissionErrorCode.RpEmptyEntityCode, `Entity at index ${index} must have a non-empty "code" property`);
@@ -6947,7 +7832,7 @@ function parseEntity(raw, index) {
 	};
 }
 function parseRecordRightEntity(raw, index) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(RecordPermissionErrorCode.RpInvalidConfigStructure, `Record right entity at index ${index} must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(RecordPermissionErrorCode.RpInvalidConfigStructure, `Record right entity at index ${index} must be an object`);
 	const obj = raw;
 	const entity = parseEntity(obj.entity, index);
 	const context = `Record right entity at index ${index}`;
@@ -6960,7 +7845,7 @@ function parseRecordRightEntity(raw, index) {
 	};
 }
 function parseRecordRight(raw, index) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(RecordPermissionErrorCode.RpInvalidConfigStructure, `Record right at index ${index} must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(RecordPermissionErrorCode.RpInvalidConfigStructure, `Record right at index ${index} must be an object`);
 	const obj = raw;
 	if (!Array.isArray(obj.entities)) throw new BusinessRuleError(RecordPermissionErrorCode.RpInvalidConfigStructure, `Record right at index ${index} must have an "entities" array`);
 	const entities = obj.entities.map((item, i) => parseRecordRightEntity(item, i));
@@ -6977,7 +7862,7 @@ const RecordPermissionConfigParser = { parse: (rawText) => {
 	} catch (error) {
 		throw new BusinessRuleError(RecordPermissionErrorCode.RpInvalidConfigYaml, `Failed to parse YAML: ${error instanceof Error ? error.message : String(error)}`);
 	}
-	if (!isRecord$1(parsed)) throw new BusinessRuleError(RecordPermissionErrorCode.RpInvalidConfigStructure, "Config must be a YAML object");
+	if (!isRecord(parsed)) throw new BusinessRuleError(RecordPermissionErrorCode.RpInvalidConfigStructure, "Config must be a YAML object");
 	const obj = parsed;
 	if (!Array.isArray(obj.rights)) throw new BusinessRuleError(RecordPermissionErrorCode.RpInvalidConfigStructure, "Config must have a \"rights\" array");
 	return { rights: obj.rights.map((item, i) => parseRecordRight(item, i)) };
@@ -7113,6 +7998,104 @@ var capture_default$5 = define({
 	}
 });
 
+//#endregion
+//#region src/core/domain/recordPermission/services/diffDetector.ts
+function areRightsEqual(a, b) {
+	return deepEqual(a.entities.map((e) => ({
+		type: e.entity.type,
+		code: e.entity.code,
+		viewable: e.viewable,
+		editable: e.editable,
+		deletable: e.deletable,
+		includeSubs: e.includeSubs
+	})), b.entities.map((e) => ({
+		type: e.entity.type,
+		code: e.entity.code,
+		viewable: e.viewable,
+		editable: e.editable,
+		deletable: e.deletable,
+		includeSubs: e.includeSubs
+	})));
+}
+function describeRight(right) {
+	const perEntity = right.entities.map((e) => {
+		const perms = [
+			e.viewable ? "view" : null,
+			e.editable ? "edit" : null,
+			e.deletable ? "delete" : null
+		].filter(Boolean).join("/");
+		return `${e.entity.type}:${e.entity.code}(${perms || "none"})`;
+	});
+	return perEntity.length > 0 ? perEntity.join(", ") : "no entities";
+}
+const RecordPermissionDiffDetector = { detect: (local, remote) => {
+	const entries = [];
+	const localMulti = groupByKey(local.rights, (r) => r.filterCond);
+	const remoteMulti = groupByKey(remote.rights, (r) => r.filterCond);
+	for (const [filterCond, localRights] of localMulti) {
+		const remoteRights = remoteMulti.get(filterCond) ?? [];
+		const maxLen = Math.max(localRights.length, remoteRights.length);
+		for (let i = 0; i < maxLen; i++) {
+			const localRight = localRights[i];
+			const remoteRight = remoteRights[i];
+			if (localRight && !remoteRight) entries.push({
+				type: "added",
+				filterCond,
+				details: describeRight(localRight)
+			});
+			else if (!localRight && remoteRight) entries.push({
+				type: "deleted",
+				filterCond,
+				details: describeRight(remoteRight)
+			});
+			else if (localRight && remoteRight) {
+				if (!areRightsEqual(localRight, remoteRight)) {
+					const diffs = [];
+					if (localRight.entities.length !== remoteRight.entities.length) diffs.push(`entities: ${remoteRight.entities.length} -> ${localRight.entities.length}`);
+					else diffs.push("entities changed");
+					entries.push({
+						type: "modified",
+						filterCond,
+						details: diffs.join(", ")
+					});
+				}
+			}
+		}
+	}
+	for (const [filterCond, remoteRights] of remoteMulti) if (!localMulti.has(filterCond)) for (const remoteRight of remoteRights) entries.push({
+		type: "deleted",
+		filterCond,
+		details: describeRight(remoteRight)
+	});
+	return buildDiffResult(entries);
+} };
+
+//#endregion
+//#region src/core/application/recordPermission/detectRecordPermissionDiff.ts
+async function detectRecordPermissionDiff({ container }) {
+	return detectDiffFromConfig({
+		getStorage: () => container.recordPermissionStorage.get(),
+		fetchRemote: () => container.recordPermissionConfigurator.getRecordPermissions(),
+		parseConfig: parseRecordPermissionConfigText,
+		detect: (local, remote) => RecordPermissionDiffDetector.detect(local, { rights: remote.rights }),
+		notFoundMessage: "Record permission config file not found"
+	});
+}
+
+//#endregion
+//#region src/cli/commands/record-acl/diff.ts
+var diff_default$4 = createDiffCommand({
+	description: "Compare local record permission config with remote kintone app",
+	args: recordAclArgs,
+	spinnerMessage: "Comparing record permissions...",
+	multiAppSuccessMessage: "All record permission diffs completed successfully.",
+	createContainer: createRecordPermissionCliContainer,
+	detectDiff: detectRecordPermissionDiff,
+	printResult: printRecordPermissionDiffResult,
+	resolveContainerConfig: resolveRecordAclContainerConfig,
+	resolveAppContainerConfig: resolveRecordAclAppContainerConfig
+});
+
 //#endregion
 //#region src/cli/commands/record-acl/index.ts
 var record_acl_default = define({
@@ -7120,7 +8103,8 @@ var record_acl_default = define({
 	description: "Manage kintone record access permissions",
 	subCommands: {
 		apply: apply_default$4,
-		capture: capture_default$5
+		capture: capture_default$5,
+		diff: diff_default$4
 	},
 	run: () => {}
 });
@@ -7189,7 +8173,7 @@ const VALID_PERIODIC_EVERY = new Set([
 	"HOUR"
 ]);
 function parseGroup(raw, index) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Group at index ${index} must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Group at index ${index} must be an object`);
 	const obj = raw;
 	if (typeof obj.code !== "string" || obj.code.length === 0) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Group at index ${index} must have a non-empty "code" property`);
 	const result = { code: obj.code };
@@ -7203,7 +8187,7 @@ function parseGroup(raw, index) {
 	return result;
 }
 function parseAggregation(raw, index) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Aggregation at index ${index} must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Aggregation at index ${index} must be an object`);
 	const obj = raw;
 	if (typeof obj.type !== "string" || !VALID_AGGREGATION_TYPES.has(obj.type)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Aggregation at index ${index} has invalid type: ${String(obj.type)}. Must be COUNT, SUM, AVERAGE, MAX, or MIN`);
 	const result = { type: obj.type };
@@ -7217,7 +8201,7 @@ function parseAggregation(raw, index) {
 	return result;
 }
 function parseSort(raw, index) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Sort at index ${index} must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Sort at index ${index} must be an object`);
 	const obj = raw;
 	if (typeof obj.by !== "string" || !VALID_SORT_BY.has(obj.by)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Sort at index ${index} has invalid by: ${String(obj.by)}. Must be TOTAL, GROUP1, GROUP2, or GROUP3`);
 	if (typeof obj.order !== "string" || !VALID_SORT_ORDER.has(obj.order)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Sort at index ${index} has invalid order: ${String(obj.order)}. Must be ASC or DESC`);
@@ -7227,7 +8211,7 @@ function parseSort(raw, index) {
 	};
 }
 function parsePeriodicReportPeriod(raw) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, "periodicReport.period must be an object");
+	if (!isRecord(raw)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, "periodicReport.period must be an object");
 	const obj = raw;
 	if (typeof obj.every !== "string" || !VALID_PERIODIC_EVERY.has(obj.every)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `periodicReport.period has invalid every: ${String(obj.every)}. Must be YEAR, QUARTER, MONTH, WEEK, DAY, or HOUR`);
 	const every = obj.every;
@@ -7274,7 +8258,7 @@ function parsePeriodicReportPeriod(raw) {
 	};
 }
 function parsePeriodicReport(raw) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, "periodicReport must be an object");
+	if (!isRecord(raw)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, "periodicReport must be an object");
 	const obj = raw;
 	if (typeof obj.active !== "boolean") throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, "periodicReport.active must be a boolean");
 	const period = parsePeriodicReportPeriod(obj.period);
@@ -7284,7 +8268,7 @@ function parsePeriodicReport(raw) {
 	};
 }
 function parseReportConfig(raw, reportName) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Report "${reportName}" must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Report "${reportName}" must be an object`);
 	const obj = raw;
 	if (typeof obj.chartType !== "string" || !VALID_CHART_TYPES.has(obj.chartType)) throw new BusinessRuleError(ReportErrorCode.RtInvalidChartType, `Report "${reportName}" has invalid chartType: ${String(obj.chartType)}. Must be BAR, COLUMN, PIE, LINE, PIVOT_TABLE, TABLE, AREA, SPLINE, or SPLINE_AREA`);
 	let chartMode;
@@ -7323,9 +8307,9 @@ const ReportConfigParser = { parse: (rawText) => {
 	} catch (error) {
 		throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigYaml, `Failed to parse YAML: ${error instanceof Error ? error.message : String(error)}`);
 	}
-	if (!isRecord$1(parsed)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, "Config must be a YAML object");
+	if (!isRecord(parsed)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, "Config must be a YAML object");
 	const obj = parsed;
-	if (!isRecord$1(obj.reports)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, "Config must have a \"reports\" object");
+	if (!isRecord(obj.reports)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, "Config must have a \"reports\" object");
 	const rawReports = obj.reports;
 	const reports = {};
 	for (const [name, value] of Object.entries(rawReports)) reports[name] = parseReportConfig(value, name);
@@ -7462,6 +8446,73 @@ var capture_default$4 = define({
 	}
 });
 
+//#endregion
+//#region src/core/domain/report/services/diffDetector.ts
+function compareReports(local, remote) {
+	const diffs = [];
+	if (local.name !== remote.name) diffs.push(`name: "${remote.name}" -> "${local.name}"`);
+	if (local.chartType !== remote.chartType) diffs.push(`chartType: ${remote.chartType} -> ${local.chartType}`);
+	if ((local.chartMode ?? "") !== (remote.chartMode ?? "")) diffs.push(`chartMode: ${remote.chartMode ?? "(unset)"} -> ${local.chartMode ?? "(unset)"}`);
+	if (local.index !== remote.index) diffs.push(`index: ${remote.index} -> ${local.index}`);
+	if (local.filterCond !== remote.filterCond) diffs.push("filterCond changed");
+	if (!deepEqual(local.groups, remote.groups)) diffs.push("groups changed");
+	if (!deepEqual(local.aggregations, remote.aggregations)) diffs.push("aggregations changed");
+	if (!deepEqual(local.sorts, remote.sorts)) diffs.push("sorts changed");
+	if (!deepEqual(local.periodicReport ?? null, remote.periodicReport ?? null)) diffs.push("periodicReport changed");
+	return diffs;
+}
+const ReportDiffDetector = { detect: (local, remote) => {
+	const entries = [];
+	for (const [name, localReport] of Object.entries(local.reports)) {
+		const remoteReport = remote.reports[name];
+		if (!remoteReport) entries.push({
+			type: "added",
+			reportName: name,
+			details: `chartType: ${localReport.chartType}`
+		});
+		else {
+			const diffs = compareReports(localReport, remoteReport);
+			if (diffs.length > 0) entries.push({
+				type: "modified",
+				reportName: name,
+				details: diffs.join(", ")
+			});
+		}
+	}
+	for (const [name, remoteReport] of Object.entries(remote.reports)) if (!local.reports[name]) entries.push({
+		type: "deleted",
+		reportName: name,
+		details: `chartType: ${remoteReport.chartType}`
+	});
+	return buildDiffResult(entries);
+} };
+
+//#endregion
+//#region src/core/application/report/detectReportDiff.ts
+async function detectReportDiff({ container }) {
+	return detectDiffFromConfig({
+		getStorage: () => container.reportStorage.get(),
+		fetchRemote: () => container.reportConfigurator.getReports(),
+		parseConfig: parseReportConfigText,
+		detect: (local, remote) => ReportDiffDetector.detect(local, { reports: remote.reports }),
+		notFoundMessage: "Report config file not found"
+	});
+}
+
+//#endregion
+//#region src/cli/commands/report/diff.ts
+var diff_default$3 = createDiffCommand({
+	description: "Compare local report config with remote kintone app",
+	args: reportArgs,
+	spinnerMessage: "Comparing report settings...",
+	multiAppSuccessMessage: "All report diffs completed successfully.",
+	createContainer: createReportCliContainer,
+	detectDiff: detectReportDiff,
+	printResult: printReportDiffResult,
+	resolveContainerConfig: resolveReportContainerConfig,
+	resolveAppContainerConfig: resolveReportAppContainerConfig
+});
+
 //#endregion
 //#region src/cli/commands/report/index.ts
 var report_default = define({
@@ -7469,7 +8520,8 @@ var report_default = define({
 	description: "Manage kintone report settings",
 	subCommands: {
 		apply: apply_default$3,
-		capture: capture_default$4
+		capture: capture_default$4,
+		diff: diff_default$3
 	},
 	run: () => {}
 });
@@ -7521,53 +8573,8 @@ var capture_default$3 = define({
 	}
 });
 
-//#endregion
-//#region src/core/domain/formSchema/entity.ts
-const FormDiff = { create: (entries) => {
-	const summary = {
-		added: entries.filter((e) => e.type === "added").length,
-		modified: entries.filter((e) => e.type === "modified").length,
-		deleted: entries.filter((e) => e.type === "deleted").length,
-		total: entries.length
-	};
-	const sortOrder = {
-		added: 0,
-		modified: 1,
-		deleted: 2
-	};
-	return {
-		entries: [...entries].sort((a, b) => sortOrder[a.type] - sortOrder[b.type]),
-		summary,
-		isEmpty: entries.length === 0
-	};
-} };
-
 //#endregion
 //#region src/core/domain/formSchema/services/diffDetector.ts
-function isArrayEqual$1(a, b) {
-	if (!Array.isArray(a) || !Array.isArray(b)) return false;
-	if (a.length !== b.length) return false;
-	for (let i = 0; i < a.length; i++) if (!isValueEqual(a[i], b[i])) return false;
-	return true;
-}
-function isRecordEqual(a, b) {
-	const keysA = Object.keys(a);
-	const keysB = Object.keys(b);
-	if (keysA.length !== keysB.length) return false;
-	for (const key of keysA) {
-		if (!Object.hasOwn(b, key)) return false;
-		if (!isValueEqual(a[key], b[key])) return false;
-	}
-	return true;
-}
-function isValueEqual(a, b) {
-	if (a === b) return true;
-	if (a === null || b === null) return a === b;
-	if (typeof a !== typeof b) return false;
-	if (Array.isArray(a)) return isArrayEqual$1(a, b);
-	if (isRecord$1(a) && isRecord$1(b)) return isRecordEqual(a, b);
-	return false;
-}
 function isMapEqual(a, b) {
 	if (a.size !== b.size) return false;
 	for (const [key, valA] of a) {
@@ -7579,51 +8586,26 @@ function isMapEqual(a, b) {
 }
 function isPropertiesEqual(a, b) {
 	if (a.type === "SUBTABLE" && b.type === "SUBTABLE") return isMapEqual(a.properties.fields, b.properties.fields);
-	if (a.type === "REFERENCE_TABLE" && b.type === "REFERENCE_TABLE") {
-		const refA = a.properties.referenceTable;
-		const refB = b.properties.referenceTable;
-		return isValueEqual({
-			...refA,
-			displayFields: [...refA.displayFields]
-		}, {
-			...refB,
-			displayFields: [...refB.displayFields]
-		});
-	}
-	return isValueEqual(a.properties, b.properties);
+	if (a.type === "REFERENCE_TABLE" && b.type === "REFERENCE_TABLE") return deepEqual(a.properties.referenceTable, b.properties.referenceTable);
+	return deepEqual(a.properties, b.properties);
 }
 function isFieldEqual(a, b) {
 	if (a.type !== b.type) return false;
 	if (a.label !== b.label) return false;
 	if (a.code !== b.code) return false;
-	if (Boolean(a.noLabel) !== Boolean(b.noLabel)) return false;
+	if ((a.noLabel ?? false) !== (b.noLabel ?? false)) return false;
 	return isPropertiesEqual(a, b);
 }
-function hasPropertiesChanged(before, after) {
-	if (before.type === "SUBTABLE" && after.type === "SUBTABLE") return !isMapEqual(before.properties.fields, after.properties.fields);
-	if (before.type === "REFERENCE_TABLE" && after.type === "REFERENCE_TABLE") {
-		const refB = before.properties.referenceTable;
-		const refA = after.properties.referenceTable;
-		return !isValueEqual({
-			...refB,
-			displayFields: [...refB.displayFields]
-		}, {
-			...refA,
-			displayFields: [...refA.displayFields]
-		});
-	}
-	return !isValueEqual(before.properties, after.properties);
-}
 function describeChanges$1(before, after) {
 	const changes = [];
 	if (before.type !== after.type) changes.push(`type: ${before.type} -> ${after.type}`);
 	if (before.label !== after.label) changes.push(`label: ${before.label} -> ${after.label}`);
-	if (Boolean(before.noLabel) !== Boolean(after.noLabel)) changes.push(`noLabel: ${before.noLabel ?? false} -> ${after.noLabel ?? false}`);
-	if (hasPropertiesChanged(before, after)) changes.push("properties changed");
+	if ((before.noLabel ?? false) !== (after.noLabel ?? false)) changes.push(`noLabel: ${before.noLabel ?? false} -> ${after.noLabel ?? false}`);
+	if (!isPropertiesEqual(before, after)) changes.push("properties changed");
 	return changes.length > 0 ? changes.join(", ") : "no visible changes";
 }
 function isLayoutEqual(a, b) {
-	return isValueEqual(a, b);
+	return deepEqual(a, b);
 }
 const DiffDetector = {
 	detectLayoutChanges: (schemaLayout, currentLayout) => {
@@ -7653,13 +8635,23 @@ const DiffDetector = {
 			type: "deleted",
 			fieldCode,
 			fieldLabel: currentDef.label,
-			details: "deleted",
+			details: "removed",
 			before: currentDef
 		});
-		return FormDiff.create(entries);
+		return buildDiffResult(entries);
 	}
 };
 
+//#endregion
+//#region src/core/domain/formSchema/entity.ts
+const Schema = { create: (fields, layout) => {
+	if (fields.size === 0) throw new BusinessRuleError(FormSchemaErrorCode.FsEmptyFields, "Schema must have at least one field");
+	return {
+		fields,
+		layout
+	};
+} };
+
 //#endregion
 //#region src/core/domain/formSchema/services/schemaParser.ts
 const VALID_UNIT_POSITIONS = new Set(["BEFORE", "AFTER"]);
@@ -7679,7 +8671,7 @@ const VALID_LINK_PROTOCOLS = new Set([
 	"MAIL"
 ]);
 function validateEnumProperty(fieldCode, propName, value, validValues) {
-	if (value !== void 0 && !validValues.has(value)) throw new BusinessRuleError(FormSchemaErrorCode.FsInvalidSchemaStructure, `Invalid ${propName} "${String(value)}" for field "${fieldCode}". Expected one of: ${[...validValues].join(", ")}`);
+	if (value !== void 0 && (typeof value !== "string" || !validValues.has(value))) throw new BusinessRuleError(FormSchemaErrorCode.FsInvalidSchemaStructure, `Invalid ${propName} "${String(value)}" for field "${fieldCode}". Expected one of: ${[...validValues].join(", ")}`);
 }
 function validateFieldProperties(code, fieldType, properties) {
 	switch (fieldType) {
@@ -7748,17 +8740,38 @@ const LAYOUT_ATTRIBUTES = new Set(["size"]);
 const DECORATION_ATTRIBUTES = new Set(["elementId"]);
 const GROUP_ATTRIBUTES = new Set(["openGroup", "layout"]);
 const SUBTABLE_ATTRIBUTES = new Set(["fields"]);
+/**
+* Parses a raw size object into an ElementSize.
+* Returns undefined when no size properties are present, treating an empty
+* object the same as absent — layout elements without explicit sizing should
+* not carry a redundant empty size object.
+*/
 function parseSize(raw) {
-	if (!isRecord$1(raw)) return void 0;
+	if (!isRecord(raw)) return void 0;
 	const obj = raw;
+	if (obj.width === void 0 && obj.height === void 0 && obj.innerHeight === void 0) return;
 	return {
 		...obj.width !== void 0 ? { width: String(obj.width) } : {},
 		...obj.height !== void 0 ? { height: String(obj.height) } : {},
 		...obj.innerHeight !== void 0 ? { innerHeight: String(obj.innerHeight) } : {}
 	};
 }
-function normalizePropertyValue(value) {
+const BOOLEAN_PROPERTIES = new Set([
+	"required",
+	"unique",
+	"digit",
+	"hideExpression",
+	"defaultNowValue",
+	"openGroup"
+]);
+function normalizePropertyValue(key, value) {
+	if (typeof value === "boolean") return value;
 	if (typeof value === "number") return String(value);
+	if (BOOLEAN_PROPERTIES.has(key) && typeof value === "string") {
+		if (value === "true") return true;
+		if (value === "false") return false;
+		throw new BusinessRuleError(FormSchemaErrorCode.FsInvalidSchemaStructure, `Invalid boolean string "${value}" for property "${key}". Expected "true" or "false"`);
+	}
 	return value;
 }
 function extractProperties(raw) {
@@ -7769,7 +8782,7 @@ function extractProperties(raw) {
 		if (DECORATION_ATTRIBUTES.has(key)) continue;
 		if (GROUP_ATTRIBUTES.has(key)) continue;
 		if (SUBTABLE_ATTRIBUTES.has(key)) continue;
-		properties[key] = normalizePropertyValue(value);
+		properties[key] = normalizePropertyValue(key, value);
 	}
 	return properties;
 }
@@ -7887,10 +8900,10 @@ function parseFieldDefinitionFromFlat(raw) {
 		};
 	}
 	if (fieldType === "REFERENCE_TABLE") {
-		if (!isRecord$1(raw.referenceTable)) throw new BusinessRuleError(FormSchemaErrorCode.FsInvalidSchemaStructure, `Field "${code}" of type REFERENCE_TABLE must have a "referenceTable" property`);
+		if (!isRecord(raw.referenceTable)) throw new BusinessRuleError(FormSchemaErrorCode.FsInvalidSchemaStructure, `Field "${code}" of type REFERENCE_TABLE must have a "referenceTable" property`);
 		const refTable = raw.referenceTable;
-		if (!isRecord$1(refTable.relatedApp)) throw new BusinessRuleError(FormSchemaErrorCode.FsInvalidSchemaStructure, `Field "${code}" of type REFERENCE_TABLE must have "referenceTable.relatedApp"`);
-		if (!isRecord$1(refTable.condition)) throw new BusinessRuleError(FormSchemaErrorCode.FsInvalidSchemaStructure, `Field "${code}" of type REFERENCE_TABLE must have "referenceTable.condition"`);
+		if (!isRecord(refTable.relatedApp)) throw new BusinessRuleError(FormSchemaErrorCode.FsInvalidSchemaStructure, `Field "${code}" of type REFERENCE_TABLE must have "referenceTable.relatedApp"`);
+		if (!isRecord(refTable.condition)) throw new BusinessRuleError(FormSchemaErrorCode.FsInvalidSchemaStructure, `Field "${code}" of type REFERENCE_TABLE must have "referenceTable.condition"`);
 		if (!Array.isArray(refTable.displayFields)) throw new BusinessRuleError(FormSchemaErrorCode.FsInvalidSchemaStructure, `Field "${code}" of type REFERENCE_TABLE must have "referenceTable.displayFields" array`);
 		const condition = refTable.condition;
 		const displayFields = refTable.displayFields.map((f) => FieldCode.create(f));
@@ -7965,6 +8978,7 @@ function parseLayoutElement(raw) {
 }
 function parseLayoutRow(raw) {
 	if (raw.type !== "ROW") throw new BusinessRuleError(FormSchemaErrorCode.FsInvalidLayoutStructure, `Expected layout row type "ROW", got "${String(raw.type)}"`);
+	if (raw.fields !== void 0 && !Array.isArray(raw.fields)) throw new BusinessRuleError(FormSchemaErrorCode.FsInvalidLayoutStructure, `ROW "fields" must be an array, got ${typeof raw.fields}`);
 	return {
 		type: "ROW",
 		fields: (Array.isArray(raw.fields) ? raw.fields : []).map(parseLayoutElement)
@@ -8004,7 +9018,7 @@ function parseLayoutItem(raw) {
 			const label = String(raw.label ?? "");
 			const noLabel = typeof raw.noLabel === "boolean" ? raw.noLabel : void 0;
 			const openGroup = typeof raw.openGroup === "boolean" ? raw.openGroup : void 0;
-			const rawLayout = Array.isArray(raw.layout) ? raw.layout.filter(isRecord$1) : [];
+			const rawLayout = Array.isArray(raw.layout) ? raw.layout.filter(isRecord) : [];
 			let groupFields = /* @__PURE__ */ new Map();
 			const layout = [];
 			for (const r of rawLayout) {
@@ -8089,22 +9103,21 @@ const SchemaParser = { parse: (rawText) => {
 	} catch {
 		throw new BusinessRuleError(FormSchemaErrorCode.FsInvalidSchemaFormat, "Schema text is not valid YAML/JSON");
 	}
-	if (!isRecord$1(parsed)) throw new BusinessRuleError(FormSchemaErrorCode.FsInvalidSchemaStructure, "Schema must be an object");
+	if (!isRecord(parsed)) throw new BusinessRuleError(FormSchemaErrorCode.FsInvalidSchemaStructure, "Schema must be an object");
 	const obj = parsed;
 	if ("fields" in obj && !("layout" in obj)) throw new BusinessRuleError(FormSchemaErrorCode.FsInvalidSchemaStructure, "\"fields\" key detected. Schema format has changed. Please use \"capture\" to generate a new format schema.");
 	if (!("layout" in obj) || !Array.isArray(obj.layout)) throw new BusinessRuleError(FormSchemaErrorCode.FsInvalidLayoutStructure, "Schema must have a \"layout\" array");
-	const rawLayout = obj.layout.filter(isRecord$1);
+	const rawLayout = obj.layout;
 	let fieldMap = /* @__PURE__ */ new Map();
 	const layout = [];
-	for (const rawItem of rawLayout) {
+	for (let i = 0; i < rawLayout.length; i++) {
+		const rawItem = rawLayout[i];
+		if (!isRecord(rawItem)) throw new BusinessRuleError(FormSchemaErrorCode.FsInvalidLayoutStructure, `Layout item at index ${i} must be an object`);
 		const result = parseLayoutItem(rawItem);
 		layout.push(result.item);
 		fieldMap = mergeFieldMaps(fieldMap, result.fields);
 	}
-	return {
-		fields: fieldMap,
-		layout
-	};
+	return Schema.create(fieldMap, layout);
 } };
 
 //#endregion
@@ -8153,14 +9166,20 @@ async function detectDiff({ container }) {
 
 //#endregion
 //#region src/cli/commands/schema/diff.ts
-async function runDiff$1(container) {
+async function runDiff(container) {
 	const s = p.spinner();
 	s.start("Fetching form schema...");
-	const result = await detectDiff({ container });
+	let result;
+	try {
+		result = await detectDiff({ container });
+	} catch (error) {
+		s.stop("Comparison failed.");
+		throw error;
+	}
 	s.stop("Form schema fetched.");
 	printDiffResult(result);
 }
-var diff_default$1 = define({
+var diff_default$2 = define({
 	name: "diff",
 	description: "Detect differences between schema file and current kintone form",
 	args: {
@@ -8171,17 +9190,17 @@ var diff_default$1 = define({
 		try {
 			await routeMultiApp(ctx.values, {
 				singleLegacy: async () => {
-					await runDiff$1(createCliContainer(resolveConfig(ctx.values)));
+					await runDiff(createCliContainer(resolveConfig(ctx.values)));
 				},
 				singleApp: async (app, projectConfig) => {
-					await runDiff$1(createCliContainer(resolveAppCliConfig(app, projectConfig, ctx.values)));
+					await runDiff(createCliContainer(resolveAppCliConfig(app, projectConfig, ctx.values)));
 				},
 				multiApp: async (plan, projectConfig) => {
 					await runMultiAppWithFailCheck(plan, async (app) => {
 						const container = createCliContainer(resolveAppCliConfig(app, projectConfig, ctx.values));
 						printAppHeader(app.name, app.appId);
-						await runDiff$1(container);
-					});
+						await runDiff(container);
+					}, "All schema diffs completed successfully.");
 				}
 			});
 		} catch (error) {
@@ -8899,7 +9918,7 @@ var schema_default = define({
 	name: "schema",
 	description: "Manage kintone form schemas",
 	subCommands: {
-		diff: diff_default$1,
+		diff: diff_default$2,
 		migrate: migrate_default,
 		override: override_default,
 		capture: capture_default$3,
@@ -8922,17 +9941,17 @@ function normalizeValue(value) {
 		if (typeof first === "string") return value;
 		if (typeof first === "number") return value.map(String);
 		if (typeof first === "object" && first !== null && "code" in first && Object.keys(first).length === 1) return value;
-		return value.filter(isRecord$1).map((row) => {
+		return value.filter(isRecord).map((row) => {
 			const normalized = {};
 			for (const [k, v] of Object.entries(row)) if (Array.isArray(v)) normalized[k] = v.map(String);
 			else normalized[k] = v === null || v === void 0 ? "" : String(v);
 			return normalized;
 		});
 	}
-	return String(value);
+	throw new BusinessRuleError(SeedDataErrorCode.SdInvalidSeedStructure, `Unsupported value type: ${typeof value}`);
 }
 function parseRecord(raw, index) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(SeedDataErrorCode.SdInvalidSeedStructure, `Record at index ${index} must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(SeedDataErrorCode.SdInvalidSeedStructure, `Record at index ${index} must be an object`);
 	const record = {};
 	for (const [key, value] of Object.entries(raw)) record[key] = normalizeValue(value);
 	return record;
@@ -8945,7 +9964,7 @@ const SeedParser = { parse: (rawText) => {
 	} catch {
 		throw new BusinessRuleError(SeedDataErrorCode.SdInvalidSeedYaml, "Seed text is not valid YAML");
 	}
-	if (!isRecord$1(parsed)) throw new BusinessRuleError(SeedDataErrorCode.SdInvalidSeedStructure, "Seed data must be an object");
+	if (!isRecord(parsed)) throw new BusinessRuleError(SeedDataErrorCode.SdInvalidSeedStructure, "Seed data must be an object");
 	const obj = parsed;
 	const key = "key" in obj && typeof obj.key === "string" ? UpsertKey.create(obj.key) : null;
 	if (!("records" in obj) || !Array.isArray(obj.records)) throw new BusinessRuleError(SeedDataErrorCode.SdInvalidSeedStructure, "Seed data must have a \"records\" array");
@@ -8954,8 +9973,9 @@ const SeedParser = { parse: (rawText) => {
 	for (let i = 0; i < obj.records.length; i++) {
 		const record = parseRecord(obj.records[i], i);
 		if (key !== null) {
-			if (!(key in record)) throw new BusinessRuleError(SeedDataErrorCode.SdMissingKeyField, `Record at index ${i} is missing key field "${key}"`);
-			const keyValue = record[key];
+			const keyField = key;
+			if (!(keyField in record)) throw new BusinessRuleError(SeedDataErrorCode.SdMissingKeyField, `Record at index ${i} is missing key field "${key}"`);
+			const keyValue = record[keyField];
 			if (typeof keyValue !== "string") throw new BusinessRuleError(SeedDataErrorCode.SdInvalidSeedStructure, `Key field "${key}" value at index ${i} must be a string`);
 			if (seenKeys.has(keyValue)) throw new BusinessRuleError(SeedDataErrorCode.SdDuplicateKeyValue, `Duplicate key value "${keyValue}" at index ${i}`);
 			seenKeys.add(keyValue);
@@ -8970,30 +9990,6 @@ const SeedParser = { parse: (rawText) => {
 
 //#endregion
 //#region src/core/domain/seedData/services/upsertPlanner.ts
-function deepEqual(a, b) {
-	if (typeof a === "string" && typeof b === "string") return a === b;
-	if (Array.isArray(a) && Array.isArray(b)) {
-		if (a.length !== b.length) return false;
-		for (let i = 0; i < a.length; i++) {
-			const itemA = a[i];
-			const itemB = b[i];
-			if (typeof itemA === "string" && typeof itemB === "string") {
-				if (itemA !== itemB) return false;
-				continue;
-			}
-			if (isRecord$1(itemA) && isRecord$1(itemB)) {
-				const keysA = Object.keys(itemA);
-				const keysB = Object.keys(itemB);
-				if (keysA.length !== keysB.length) return false;
-				for (const key of keysA) if (String(itemA[key] ?? "") !== String(itemB[key] ?? "")) return false;
-				continue;
-			}
-			if (String(itemA) !== String(itemB)) return false;
-		}
-		return true;
-	}
-	return String(a) === String(b);
-}
 function recordsEqual(seed, existing, keyField) {
 	const seedKeys = Object.keys(seed).filter((k) => k !== keyField);
 	for (const key of seedKeys) {
@@ -9269,7 +10265,7 @@ const VALID_ROUNDING_MODES = new Set([
 	"DOWN"
 ]);
 function parseIcon(raw) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "icon must be an object with \"type\" and \"key\" properties");
+	if (!isRecord(raw)) throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "icon must be an object with \"type\" and \"key\" properties");
 	const obj = raw;
 	if (typeof obj.type !== "string" || !VALID_ICON_TYPES.has(obj.type)) throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidIconType, `icon.type must be PRESET or FILE, got: ${String(obj.type)}`);
 	if (typeof obj.key !== "string" || obj.key.length === 0) throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "icon must have a non-empty \"key\" property");
@@ -9279,7 +10275,7 @@ function parseIcon(raw) {
 	};
 }
 function parseTitleField(raw) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "titleField must be an object with \"selectionMode\" property");
+	if (!isRecord(raw)) throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "titleField must be an object with \"selectionMode\" property");
 	const obj = raw;
 	if (typeof obj.selectionMode !== "string" || !VALID_SELECTION_MODES.has(obj.selectionMode)) throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, `titleField.selectionMode must be AUTO or MANUAL, got: ${String(obj.selectionMode)}`);
 	const result = { selectionMode: obj.selectionMode };
@@ -9293,7 +10289,7 @@ function parseTitleField(raw) {
 	return result;
 }
 function parseNumberPrecision(raw) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "numberPrecision must be an object");
+	if (!isRecord(raw)) throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "numberPrecision must be an object");
 	const obj = raw;
 	if (typeof obj.digits !== "number") throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "numberPrecision.digits must be a number");
 	if (typeof obj.decimalPlaces !== "number") throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "numberPrecision.decimalPlaces must be a number");
@@ -9312,7 +10308,7 @@ const GeneralSettingsConfigParser = { parse: (rawText) => {
 	} catch (error) {
 		throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigYaml, `Failed to parse YAML: ${error instanceof Error ? error.message : String(error)}`);
 	}
-	if (!isRecord$1(parsed)) throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "Config must be a YAML object");
+	if (!isRecord(parsed)) throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "Config must be a YAML object");
 	const obj = parsed;
 	let name;
 	if (obj.name !== void 0 && obj.name !== null) {
@@ -9497,6 +10493,91 @@ var capture_default$1 = define({
 	}
 });
 
+//#endregion
+//#region src/core/domain/generalSettings/services/diffDetector.ts
+const DEFAULT_STRING = "";
+const DEFAULT_BOOLEAN = false;
+const DEFAULT_FIRST_MONTH = 1;
+function compareConfigs(local, remote) {
+	const entries = [];
+	function compareString(field, l, r, defaultValue, suppressValues = false) {
+		const lv = l ?? defaultValue;
+		const rv = r ?? defaultValue;
+		if (lv !== rv) entries.push({
+			type: "modified",
+			field,
+			details: suppressValues ? `${field} changed` : `"${rv}" -> "${lv}"`
+		});
+	}
+	function compareBoolean(field, l, r, defaultValue) {
+		const lv = l ?? defaultValue;
+		const rv = r ?? defaultValue;
+		if (lv !== rv) entries.push({
+			type: "modified",
+			field,
+			details: `${String(rv)} -> ${String(lv)}`
+		});
+	}
+	function compareNumber(field, l, r, defaultValue) {
+		const lv = l ?? defaultValue;
+		const rv = r ?? defaultValue;
+		if (lv !== rv) entries.push({
+			type: "modified",
+			field,
+			details: `${rv} -> ${lv}`
+		});
+	}
+	function compareDeepEqual(field, l, r) {
+		if (!deepEqual(l, r)) entries.push({
+			type: "modified",
+			field,
+			details: `${field} changed`
+		});
+	}
+	compareString("name", local.name, remote.name, DEFAULT_STRING);
+	compareString("description", local.description, remote.description, DEFAULT_STRING, true);
+	compareDeepEqual("icon", local.icon, remote.icon);
+	compareString("theme", local.theme, remote.theme, DEFAULT_STRING);
+	compareDeepEqual("titleField", local.titleField, remote.titleField);
+	compareBoolean("enableThumbnails", local.enableThumbnails, remote.enableThumbnails, DEFAULT_BOOLEAN);
+	compareBoolean("enableBulkDeletion", local.enableBulkDeletion, remote.enableBulkDeletion, DEFAULT_BOOLEAN);
+	compareBoolean("enableComments", local.enableComments, remote.enableComments, DEFAULT_BOOLEAN);
+	compareBoolean("enableDuplicateRecord", local.enableDuplicateRecord, remote.enableDuplicateRecord, DEFAULT_BOOLEAN);
+	compareBoolean("enableInlineRecordEditing", local.enableInlineRecordEditing, remote.enableInlineRecordEditing, DEFAULT_BOOLEAN);
+	compareDeepEqual("numberPrecision", local.numberPrecision, remote.numberPrecision);
+	compareNumber("firstMonthOfFiscalYear", local.firstMonthOfFiscalYear, remote.firstMonthOfFiscalYear, DEFAULT_FIRST_MONTH);
+	return entries;
+}
+const GeneralSettingsDiffDetector = { detect: (local, remote) => {
+	return buildDiffResult(compareConfigs(local, remote));
+} };
+
+//#endregion
+//#region src/core/application/generalSettings/detectGeneralSettingsDiff.ts
+async function detectGeneralSettingsDiff({ container }) {
+	return detectDiffFromConfig({
+		getStorage: () => container.generalSettingsStorage.get(),
+		fetchRemote: () => container.generalSettingsConfigurator.getGeneralSettings(),
+		parseConfig: parseGeneralSettingsConfigText,
+		detect: (local, remote) => GeneralSettingsDiffDetector.detect(local, remote.config),
+		notFoundMessage: "General settings config file not found"
+	});
+}
+
+//#endregion
+//#region src/cli/commands/settings/diff.ts
+var diff_default$1 = createDiffCommand({
+	description: "Compare local general settings config with remote kintone app",
+	args: settingsArgs,
+	spinnerMessage: "Comparing general settings...",
+	multiAppSuccessMessage: "All general settings diffs completed successfully.",
+	createContainer: createGeneralSettingsCliContainer,
+	detectDiff: detectGeneralSettingsDiff,
+	printResult: printGeneralSettingsDiffResult,
+	resolveContainerConfig: resolveSettingsContainerConfig,
+	resolveAppContainerConfig: resolveSettingsAppContainerConfig
+});
+
 //#endregion
 //#region src/cli/commands/settings/index.ts
 var settings_default = define({
@@ -9504,7 +10585,8 @@ var settings_default = define({
 	description: "Manage kintone general settings",
 	subCommands: {
 		apply: apply_default$1,
-		capture: capture_default$1
+		capture: capture_default$1,
+		diff: diff_default$1
 	},
 	run: () => {}
 });
@@ -9512,7 +10594,7 @@ var settings_default = define({
 //#endregion
 //#region src/core/domain/view/services/configParser.ts
 function parseViewConfig(name, raw) {
-	if (!isRecord$1(raw)) throw new BusinessRuleError(ViewErrorCode.VwInvalidConfigStructure, `View "${name}" must be an object`);
+	if (!isRecord(raw)) throw new BusinessRuleError(ViewErrorCode.VwInvalidConfigStructure, `View "${name}" must be an object`);
 	const obj = raw;
 	if (typeof obj.type !== "string" || !VALID_VIEW_TYPES.has(obj.type)) throw new BusinessRuleError(ViewErrorCode.VwInvalidViewType, `View "${name}" has invalid type: ${String(obj.type)}. Must be LIST, CALENDAR, or CUSTOM`);
 	return {
@@ -9542,9 +10624,9 @@ const ViewConfigParser = { parse: (rawText) => {
 	} catch (error) {
 		throw new BusinessRuleError(ViewErrorCode.VwInvalidConfigYaml, `Failed to parse YAML: ${error instanceof Error ? error.message : String(error)}`);
 	}
-	if (!isRecord$1(parsed)) throw new BusinessRuleError(ViewErrorCode.VwInvalidConfigStructure, "Config must be a YAML object");
+	if (!isRecord(parsed)) throw new BusinessRuleError(ViewErrorCode.VwInvalidConfigStructure, "Config must be a YAML object");
 	const obj = parsed;
-	if (!isRecord$1(obj.views)) throw new BusinessRuleError(ViewErrorCode.VwInvalidConfigStructure, "Config must have a \"views\" object");
+	if (!isRecord(obj.views)) throw new BusinessRuleError(ViewErrorCode.VwInvalidConfigStructure, "Config must have a \"views\" object");
 	const viewsObj = obj.views;
 	const views = {};
 	for (const [name, value] of Object.entries(viewsObj)) {
@@ -9693,37 +10775,21 @@ var capture_default = define({
 
 //#endregion
 //#region src/core/domain/view/services/diffDetector.ts
-function isArrayEqual(a, b) {
-	if (a.length !== b.length) return false;
-	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
-	return true;
-}
 function describeChanges(local, remote) {
 	const changes = [];
+	if (local.name !== remote.name) changes.push(`name: "${remote.name}" -> "${local.name}"`);
 	if (local.type !== remote.type) changes.push(`type: ${remote.type} -> ${local.type}`);
+	if ((local.builtinType ?? "") !== (remote.builtinType ?? "")) changes.push("builtinType changed");
 	if (local.index !== remote.index) changes.push(`index: ${remote.index} -> ${local.index}`);
 	if ((local.filterCond ?? "") !== (remote.filterCond ?? "")) changes.push("filterCond changed");
 	if ((local.sort ?? "") !== (remote.sort ?? "")) changes.push("sort changed");
 	if ((local.date ?? "") !== (remote.date ?? "")) changes.push("date changed");
 	if ((local.title ?? "") !== (remote.title ?? "")) changes.push("title changed");
 	if ((local.html ?? "") !== (remote.html ?? "")) changes.push("html changed");
-	if (local.pager !== remote.pager) changes.push(`pager: ${String(remote.pager ?? "undefined")} -> ${String(local.pager ?? "undefined")}`);
+	if ((local.pager ?? false) !== (remote.pager ?? false)) changes.push(`pager: ${String(remote.pager ?? false)} -> ${String(local.pager ?? false)}`);
 	if ((local.device ?? "") !== (remote.device ?? "")) changes.push("device changed");
-	if (!isArrayEqual(local.fields ?? [], remote.fields ?? [])) changes.push("fields changed");
-	return changes.length > 0 ? changes.join(", ") : "no visible changes";
-}
-function isViewEqual(local, remote) {
-	if (local.type !== remote.type) return false;
-	if (local.index !== remote.index) return false;
-	if ((local.filterCond ?? "") !== (remote.filterCond ?? "")) return false;
-	if ((local.sort ?? "") !== (remote.sort ?? "")) return false;
-	if ((local.date ?? "") !== (remote.date ?? "")) return false;
-	if ((local.title ?? "") !== (remote.title ?? "")) return false;
-	if ((local.html ?? "") !== (remote.html ?? "")) return false;
-	if (local.pager !== remote.pager) return false;
-	if ((local.device ?? "") !== (remote.device ?? "")) return false;
-	if (!isArrayEqual(local.fields ?? [], remote.fields ?? [])) return false;
-	return true;
+	if (!deepEqual(local.fields ?? [], remote.fields ?? [])) changes.push("fields changed");
+	return changes;
 }
 const ViewDiffDetector = { detect: (localViews, remoteViews) => {
 	const entries = [];
@@ -9734,83 +10800,47 @@ const ViewDiffDetector = { detect: (localViews, remoteViews) => {
 			viewName: name,
 			details: "new view"
 		});
-		else if (!isViewEqual(localView, remoteView)) entries.push({
-			type: "modified",
-			viewName: name,
-			details: describeChanges(localView, remoteView)
-		});
+		else {
+			const changes = describeChanges(localView, remoteView);
+			if (changes.length > 0) entries.push({
+				type: "modified",
+				viewName: name,
+				details: changes.join(", ")
+			});
+		}
 	}
 	for (const name of Object.keys(remoteViews)) if (localViews[name] === void 0) entries.push({
 		type: "deleted",
 		viewName: name,
-		details: "deleted"
+		details: "removed"
 	});
-	const added = entries.filter((e) => e.type === "added").length;
-	const modified = entries.filter((e) => e.type === "modified").length;
-	const deleted = entries.filter((e) => e.type === "deleted").length;
-	return {
-		entries,
-		summary: {
-			added,
-			modified,
-			deleted,
-			total: added + modified + deleted
-		},
-		isEmpty: entries.length === 0
-	};
+	return buildDiffResult(entries);
 } };
 
 //#endregion
 //#region src/core/application/view/detectViewDiff.ts
 async function detectViewDiff({ container }) {
-	const result = await container.viewStorage.get();
-	if (!result.exists) throw new ValidationError(ValidationErrorCode.InvalidInput, "View config file not found");
-	const config = parseViewConfigText(result.content);
-	const { views: remoteViews } = await container.viewConfigurator.getViews();
-	const diff = ViewDiffDetector.detect(config.views, remoteViews);
-	return {
-		entries: diff.entries,
-		summary: diff.summary,
-		isEmpty: diff.isEmpty
-	};
+	return detectDiffFromConfig({
+		getStorage: () => container.viewStorage.get(),
+		fetchRemote: () => container.viewConfigurator.getViews(),
+		parseConfig: (content) => parseViewConfigText(content).views,
+		detect: (views, remote) => ViewDiffDetector.detect(views, remote.views),
+		notFoundMessage: "View config file not found"
+	});
 }
 
 //#endregion
 //#region src/cli/commands/view/diff.ts
-async function runDiff(config) {
-	const container = createViewCliContainer(config);
-	const s = p.spinner();
-	s.start("Fetching views...");
-	const result = await detectViewDiff({ container });
-	s.stop("Views fetched.");
-	printViewDiffResult(result);
-}
-var diff_default = define({
-	name: "diff",
-	description: "Detect differences between view config file and current kintone views",
+var diff_default = createDiffCommand({
+	description: "Compare local view config with remote kintone app",
 	args: viewArgs,
-	run: async (ctx) => {
-		try {
-			const values = ctx.values;
-			await routeMultiApp(values, {
-				singleLegacy: async () => {
-					await runDiff(resolveViewContainerConfig(values));
-				},
-				singleApp: async (app, projectConfig) => {
-					await runDiff(resolveViewAppContainerConfig(app, projectConfig, values));
-				},
-				multiApp: async (plan, projectConfig) => {
-					await runMultiAppWithFailCheck(plan, async (app) => {
-						const config = resolveViewAppContainerConfig(app, projectConfig, values);
-						printAppHeader(app.name, app.appId);
-						await runDiff(config);
-					});
-				}
-			});
-		} catch (error) {
-			handleCliError(error);
-		}
-	}
+	spinnerMessage: "Comparing view settings...",
+	multiAppSuccessMessage: "All view diffs completed successfully.",
+	createContainer: createViewCliContainer,
+	detectDiff: detectViewDiff,
+	printResult: printViewDiffResult,
+	resolveContainerConfig: resolveViewContainerConfig,
+	resolveAppContainerConfig: resolveViewAppContainerConfig
 });
 
 //#endregion