kintone-migrator 0.24.7 → 0.24.8

package/dist/index.mjs

@@ -2,13 +2,13 @@
 import { createRequire } from "node:module";
 import "dotenv/config";
 import { cli, define } from "gunshi";
-import * as p from "@clack/prompts";
-import { parse, stringify } from "yaml";
 import { KintoneRestAPIClient, KintoneRestAPIError } from "@kintone/rest-api-client";
 import { access, mkdir, readFile, writeFile } from "node:fs/promises";
 import { basename, dirname, extname, join, resolve } from "node:path";
+import { parse, stringify } from "yaml";
 import { realpathSync } from "node:fs";
 import * as v from "valibot";
+import * as p from "@clack/prompts";
 import pc from "picocolors";
 //#region src/lib/error.ts
 var AnyError = class extends Error {
@@ -20,8 +20,6 @@ var AnyError = class extends Error {
 //#endregion
 //#region src/core/domain/action/errorCode.ts
 const ActionErrorCode = {
-	AcEmptyConfigText: "AC_EMPTY_CONFIG_TEXT",
-	AcInvalidConfigYaml: "AC_INVALID_CONFIG_YAML",
 	AcInvalidConfigStructure: "AC_INVALID_CONFIG_STRUCTURE",
 	AcInvalidSrcType: "AC_INVALID_SRC_TYPE",
 	AcInvalidEntityType: "AC_INVALID_ENTITY_TYPE",
@@ -30,16 +28,10 @@ const ActionErrorCode = {
 };
 //#endregion
 //#region src/core/domain/adminNotes/errorCode.ts
-const AdminNotesErrorCode = {
-	AnEmptyConfigText: "AN_EMPTY_CONFIG_TEXT",
-	AnInvalidConfigYaml: "AN_INVALID_CONFIG_YAML",
-	AnInvalidConfigStructure: "AN_INVALID_CONFIG_STRUCTURE"
-};
+const AdminNotesErrorCode = { AnInvalidConfigStructure: "AN_INVALID_CONFIG_STRUCTURE" };
 //#endregion
 //#region src/core/domain/appPermission/errorCode.ts
 const AppPermissionErrorCode = {
-	ApEmptyConfigText: "AP_EMPTY_CONFIG_TEXT",
-	ApInvalidConfigYaml: "AP_INVALID_CONFIG_YAML",
 	ApInvalidConfigStructure: "AP_INVALID_CONFIG_STRUCTURE",
 	ApInvalidEntityType: "AP_INVALID_ENTITY_TYPE",
 	ApInvalidBooleanField: "AP_INVALID_BOOLEAN_FIELD",
@@ -49,8 +41,6 @@ const AppPermissionErrorCode = {
 //#endregion
 //#region src/core/domain/customization/errorCode.ts
 const CustomizationErrorCode = {
-	CzEmptyConfigText: "CZ_EMPTY_CONFIG_TEXT",
-	CzInvalidConfigYaml: "CZ_INVALID_CONFIG_YAML",
 	CzInvalidConfigStructure: "CZ_INVALID_CONFIG_STRUCTURE",
 	CzInvalidScope: "CZ_INVALID_SCOPE",
 	CzInvalidResourceType: "CZ_INVALID_RESOURCE_TYPE",
@@ -59,8 +49,6 @@ const CustomizationErrorCode = {
 //#endregion
 //#region src/core/domain/fieldPermission/errorCode.ts
 const FieldPermissionErrorCode = {
-	FpEmptyConfigText: "FP_EMPTY_CONFIG_TEXT",
-	FpInvalidConfigYaml: "FP_INVALID_CONFIG_YAML",
 	FpInvalidConfigStructure: "FP_INVALID_CONFIG_STRUCTURE",
 	FpInvalidAccessibility: "FP_INVALID_ACCESSIBILITY",
 	FpInvalidEntityType: "FP_INVALID_ENTITY_TYPE",
@@ -74,8 +62,6 @@ const FieldPermissionErrorCode = {
 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",
@@ -86,8 +72,6 @@ const FormSchemaErrorCode = {
 //#endregion
 //#region src/core/domain/generalSettings/errorCode.ts
 const GeneralSettingsErrorCode = {
-	GsEmptyConfigText: "GS_EMPTY_CONFIG_TEXT",
-	GsInvalidConfigYaml: "GS_INVALID_CONFIG_YAML",
 	GsInvalidConfigStructure: "GS_INVALID_CONFIG_STRUCTURE",
 	GsInvalidTheme: "GS_INVALID_THEME",
 	GsInvalidIconType: "GS_INVALID_ICON_TYPE",
@@ -97,8 +81,6 @@ const GeneralSettingsErrorCode = {
 //#endregion
 //#region src/core/domain/notification/errorCode.ts
 const NotificationErrorCode = {
-	NtEmptyConfigText: "NT_EMPTY_CONFIG_TEXT",
-	NtInvalidConfigYaml: "NT_INVALID_CONFIG_YAML",
 	NtInvalidConfigStructure: "NT_INVALID_CONFIG_STRUCTURE",
 	NtInvalidEntityType: "NT_INVALID_ENTITY_TYPE",
 	NtEmptyEntityCode: "NT_EMPTY_ENTITY_CODE",
@@ -110,8 +92,6 @@ const NotificationErrorCode = {
 //#endregion
 //#region src/core/domain/plugin/errorCode.ts
 const PluginErrorCode = {
-	PlEmptyConfigText: "PL_EMPTY_CONFIG_TEXT",
-	PlInvalidConfigYaml: "PL_INVALID_CONFIG_YAML",
 	PlInvalidConfigStructure: "PL_INVALID_CONFIG_STRUCTURE",
 	PlEmptyPluginId: "PL_EMPTY_PLUGIN_ID",
 	PlDuplicatePluginId: "PL_DUPLICATE_PLUGIN_ID"
@@ -119,8 +99,6 @@ const PluginErrorCode = {
 //#endregion
 //#region src/core/domain/processManagement/errorCode.ts
 const ProcessManagementErrorCode = {
-	PmEmptyConfigText: "PM_EMPTY_CONFIG_TEXT",
-	PmInvalidConfigYaml: "PM_INVALID_CONFIG_YAML",
 	PmInvalidConfigStructure: "PM_INVALID_CONFIG_STRUCTURE",
 	PmInvalidAssigneeType: "PM_INVALID_ASSIGNEE_TYPE",
 	PmInvalidEntityType: "PM_INVALID_ENTITY_TYPE",
@@ -143,8 +121,6 @@ const ProjectConfigErrorCode = {
 //#endregion
 //#region src/core/domain/recordPermission/errorCode.ts
 const RecordPermissionErrorCode = {
-	RpEmptyConfigText: "RP_EMPTY_CONFIG_TEXT",
-	RpInvalidConfigYaml: "RP_INVALID_CONFIG_YAML",
 	RpInvalidConfigStructure: "RP_INVALID_CONFIG_STRUCTURE",
 	RpInvalidEntityType: "RP_INVALID_ENTITY_TYPE",
 	RpEmptyEntityCode: "RP_EMPTY_ENTITY_CODE",
@@ -154,8 +130,6 @@ const RecordPermissionErrorCode = {
 //#endregion
 //#region src/core/domain/report/errorCode.ts
 const ReportErrorCode = {
-	RtEmptyConfigText: "RT_EMPTY_CONFIG_TEXT",
-	RtInvalidConfigYaml: "RT_INVALID_CONFIG_YAML",
 	RtInvalidConfigStructure: "RT_INVALID_CONFIG_STRUCTURE",
 	RtInvalidChartType: "RT_INVALID_CHART_TYPE",
 	RtInvalidChartMode: "RT_INVALID_CHART_MODE",
@@ -165,21 +139,14 @@ const ReportErrorCode = {
 //#region src/core/domain/seedData/errorCode.ts
 const SeedDataErrorCode = {
 	SdEmptyUpsertKey: "SD_EMPTY_UPSERT_KEY",
-	SdEmptySeedText: "SD_EMPTY_SEED_TEXT",
-	SdInvalidSeedYaml: "SD_INVALID_SEED_YAML",
 	SdInvalidSeedStructure: "SD_INVALID_SEED_STRUCTURE",
 	SdDuplicateKeyValue: "SD_DUPLICATE_KEY_VALUE",
 	SdMissingKeyField: "SD_MISSING_KEY_FIELD",
 	SdInvalidKeyFieldValue: "SD_INVALID_KEY_FIELD_VALUE"
 };
 //#endregion
-//#region src/core/domain/services/errorCode.ts
-const DomainServiceErrorCode = { YamlSerializationFailed: "DS_YAML_SERIALIZATION_FAILED" };
-//#endregion
 //#region src/core/domain/view/errorCode.ts
 const ViewErrorCode = {
-	VwEmptyConfigText: "VW_EMPTY_CONFIG_TEXT",
-	VwInvalidConfigYaml: "VW_INVALID_CONFIG_YAML",
 	VwInvalidConfigStructure: "VW_INVALID_CONFIG_STRUCTURE",
 	VwInvalidViewType: "VW_INVALID_VIEW_TYPE",
 	VwInvalidDeviceType: "VW_INVALID_DEVICE_TYPE",
@@ -201,7 +168,6 @@ const ViewErrorCode = {
 	...RecordPermissionErrorCode,
 	...ReportErrorCode,
 	...SeedDataErrorCode,
-	...DomainServiceErrorCode,
 	...ViewErrorCode
 });
 /**
@@ -414,16 +380,9 @@ function parseEntityBase(raw, index, validTypes, errorCodes, options) {
 	};
 }
 //#endregion
-//#region src/core/domain/services/yamlConfigParser.ts
-function parseYamlConfig(rawText, errorCodes, domainLabel) {
-	if (rawText.trim().length === 0) throw new BusinessRuleError(errorCodes.emptyConfigText, `${domainLabel} config text is empty`);
-	let parsed;
-	try {
-		parsed = parse(rawText);
-	} catch (error) {
-		throw new BusinessRuleError(errorCodes.invalidConfigYaml, `Failed to parse ${domainLabel} YAML: ${error instanceof Error ? error.message : String(error)}`, error);
-	}
-	if (!isRecord(parsed)) throw new BusinessRuleError(errorCodes.invalidConfigStructure, `${domainLabel} config must be a YAML object`);
+//#region src/core/domain/services/configValidator.ts
+function validateParsedConfig(parsed, invalidConfigStructure, domainLabel) {
+	if (!isRecord(parsed)) throw new BusinessRuleError(invalidConfigStructure, `${domainLabel} config must be an object`);
 	return parsed;
 }
 const VALID_SRC_TYPES = new Set(["FIELD", "RECORD_URL"]);
@@ -489,12 +448,8 @@ function parseActionConfig(raw, actionName) {
 		filterCond
 	};
 }
-const ActionConfigParser = { parse: (rawText) => {
-	const obj = parseYamlConfig(rawText, {
-		emptyConfigText: ActionErrorCode.AcEmptyConfigText,
-		invalidConfigYaml: ActionErrorCode.AcInvalidConfigYaml,
-		invalidConfigStructure: ActionErrorCode.AcInvalidConfigStructure
-	}, "Action");
+const ActionConfigParser = { parse: (parsed) => {
+	const obj = validateParsedConfig(parsed, ActionErrorCode.AcInvalidConfigStructure, "Action");
 	if (!isRecord(obj.actions)) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, "Config must have an \"actions\" object");
 	const rawActions = obj.actions;
 	const actions = {};
@@ -507,16 +462,30 @@ const ActionConfigParser = { parse: (rawText) => {
 	return { actions };
 } };
 //#endregion
+//#region src/core/application/parseConfigText.ts
+function parseConfigText(codec, rawText, domainLabel) {
+	if (rawText.trim().length === 0) throw new ValidationError(ValidationErrorCode.InvalidInput, `${domainLabel} config text is empty`);
+	let result;
+	try {
+		result = codec.parse(rawText);
+	} catch (cause) {
+		throw new ValidationError(ValidationErrorCode.InvalidInput, `Failed to parse ${domainLabel}: ${cause instanceof Error ? cause.message : String(cause)}`, cause);
+	}
+	if (result == null) throw new ValidationError(ValidationErrorCode.InvalidInput, `${domainLabel} config is empty (no data after parsing)`);
+	return result;
+}
+//#endregion
 //#region src/core/application/action/parseConfig.ts
-function parseActionConfigText(rawText) {
-	return wrapBusinessRuleError(() => ActionConfigParser.parse(rawText));
+function parseActionConfigText(codec, rawText) {
+	const parsed = parseConfigText(codec, rawText, "Action");
+	return wrapBusinessRuleError(() => ActionConfigParser.parse(parsed));
 }
 //#endregion
 //#region src/core/application/action/applyAction.ts
 async function applyAction({ container }) {
 	await applyFromConfig({
 		getStorage: () => container.actionStorage.get(),
-		parseConfig: parseActionConfigText,
+		parseConfig: (content) => parseActionConfigText(container.configCodec, content),
 		fetchRemote: () => container.actionConfigurator.getActions(),
 		update: async (config, current) => {
 			await container.actionConfigurator.updateActions({
@@ -783,6 +752,16 @@ function createLocalFileStorage(filePath, label = "file") {
 function createLocalFileActionStorage(filePath) {
 	return createLocalFileStorage(filePath, "action file");
 }
+//#endregion
+//#region src/core/adapters/yaml/configCodec.ts
+const configCodec = {
+	parse: (text) => parse(text),
+	stringify: (data) => stringify(data, {
+		lineWidth: 0,
+		defaultKeyType: "PLAIN",
+		defaultStringType: "PLAIN"
+	})
+};
 const VALID_SCOPES = new Set([
 	"ALL",
 	"ADMIN",
@@ -1067,6 +1046,16 @@ function assertStringArray(value, fieldPath) {
 function assertString(value, fieldPath) {
 	if (typeof value !== "string") throw new SystemError(SystemErrorCode.ExternalApiError, `Expected string at ${fieldPath}, got ${typeof value}`);
 }
+function normalizeDefaultValue(type, rest) {
+	if (type === "RADIO_BUTTON" || type === "DROP_DOWN") {
+		if (rest.defaultValue !== void 0 && Array.isArray(rest.defaultValue)) {
+			const arr = rest.defaultValue;
+			rest.defaultValue = arr.length > 0 ? String(arr[0]) : "";
+		}
+	} else if (type === "CHECK_BOX" || type === "MULTI_SELECT") {
+		if (rest.defaultValue !== void 0 && typeof rest.defaultValue === "string") rest.defaultValue = rest.defaultValue === "" ? [] : [rest.defaultValue];
+	}
+}
 function fromKintoneProperty(prop) {
 	const { type, code, label, noLabel, ...rest } = prop;
 	const base = {
@@ -1116,14 +1105,7 @@ function fromKintoneProperty(prop) {
 		};
 	}
 	if (!KNOWN_FIELD_TYPES.has(type)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unknown field type: ${type}`);
-	if (type === "RADIO_BUTTON" || type === "DROP_DOWN") {
-		if (rest.defaultValue !== void 0 && Array.isArray(rest.defaultValue)) {
-			const arr = rest.defaultValue;
-			rest.defaultValue = arr.length > 0 ? String(arr[0]) : "";
-		}
-	} else if (type === "CHECK_BOX" || type === "MULTI_SELECT") {
-		if (rest.defaultValue !== void 0 && typeof rest.defaultValue === "string") rest.defaultValue = rest.defaultValue === "" ? [] : [rest.defaultValue];
-	}
+	normalizeDefaultValue(type, rest);
 	return {
 		...base,
 		type,
@@ -1453,6 +1435,16 @@ function toKintoneFieldValue(value) {
 	}
 	return { value };
 }
+function flattenSubtableRow(row) {
+	const cells = row.value;
+	const flat = {};
+	for (const [k, cell] of Object.entries(cells)) {
+		if (SYSTEM_FIELDS.has(k)) continue;
+		if (Array.isArray(cell.value)) flat[k] = cell.value.map(String);
+		else flat[k] = cell.value === null || cell.value === void 0 ? "" : String(cell.value);
+	}
+	return flat;
+}
 function fromKintoneFieldValue(value) {
 	if (value === null || value === void 0) return "";
 	if (typeof value === "string") return value;
@@ -1463,16 +1455,7 @@ function fromKintoneFieldValue(value) {
 		if (typeof first === "string") return value;
 		if (typeof first === "object" && first !== null) {
 			if ("code" in first && !("value" in first)) return value.filter(hasCode).map((u) => ({ code: u.code }));
-			if ("value" in first) return value.filter(isKintoneSubtableRow).map((row) => {
-				const cells = row.value;
-				const flat = {};
-				for (const [k, cell] of Object.entries(cells)) {
-					if (SYSTEM_FIELDS.has(k)) continue;
-					if (Array.isArray(cell.value)) flat[k] = cell.value.map(String);
-					else flat[k] = cell.value === null || cell.value === void 0 ? "" : String(cell.value);
-				}
-				return flat;
-			});
+			if ("value" in first) return value.filter(isKintoneSubtableRow).map(flattenSubtableRow);
 		}
 		return value.map(String);
 	}
@@ -1611,6 +1594,7 @@ function buildKintoneAuth(auth) {
 function createCliContainer(config) {
 	const client = config.client ?? createKintoneClient(config);
 	return {
+		configCodec,
 		formConfigurator: new KintoneFormConfigurator(client, config.appId),
 		schemaStorage: createLocalFileSchemaStorage(config.schemaFilePath),
 		appDeployer: new KintoneAppDeployer(client, config.appId)
@@ -1618,6 +1602,7 @@ function createCliContainer(config) {
 }
 function createSeedCliContainer(config) {
 	return {
+		configCodec,
 		recordManager: new KintoneRecordManager(config.client ?? createKintoneClient(config), config.appId),
 		seedStorage: createLocalFileSeedStorage(config.seedFilePath)
 	};
@@ -1625,6 +1610,7 @@ function createSeedCliContainer(config) {
 function createCustomizationCliContainer(config) {
 	const client = config.client ?? createKintoneClient(config);
 	return {
+		configCodec,
 		customizationConfigurator: new KintoneCustomizationConfigurator(client, config.appId),
 		customizationStorage: createLocalFileCustomizationStorage(config.customizeFilePath),
 		fileUploader: new KintoneFileUploader(client, process.cwd()),
@@ -1647,6 +1633,7 @@ function createKintoneClient(config) {
 function createActionCliContainer(config) {
 	const client = config.client ?? createKintoneClient(config);
 	return {
+		configCodec,
 		actionConfigurator: new KintoneActionConfigurator(client, config.appId),
 		actionStorage: createLocalFileActionStorage(config.actionFilePath),
 		appDeployer: new KintoneAppDeployer(client, config.appId)
@@ -1929,18 +1916,13 @@ const ConfigParser = { parse: parseProjectConfig };
 //#endregion
 //#region src/core/application/projectConfig/loadProjectConfig.ts
 /**
-* Pure function that parses YAML text into a ProjectConfig.
-* Intentionally does not use the container/context object pattern
-* because it has no external dependencies (no I/O, no ports).
+* Pure function that parses config text into a ProjectConfig.
+* Intentionally does not use the container/context object pattern because
+* it has no I/O ports; the ConfigCodec is a lightweight serialization port.
 */
-function loadProjectConfig(input) {
-	let raw;
-	try {
-		raw = parse(input.content);
-	} catch (cause) {
-		throw new ValidationError(ValidationErrorCode.InvalidInput, "Invalid YAML syntax in config file", cause);
-	}
-	return ConfigParser.parse(raw);
+function loadProjectConfig(input, codec) {
+	const raw = parseConfigText(codec, input.content, "Project config");
+	return wrapBusinessRuleError(() => ConfigParser.parse(raw));
 }
 //#endregion
 //#region src/core/domain/projectConfig/services/dependencyResolver.ts
@@ -2317,7 +2299,7 @@ async function resolveTarget(values) {
 	if (values["app-id"]) return { mode: "single-legacy" };
 	const configPath = values.config ?? "kintone-migrator.yaml";
 	if (values.app || values.all) {
-		const config = loadProjectConfig({ content: await readConfigFile(configPath) });
+		const config = loadProjectConfig({ content: await readConfigFile(configPath) }, configCodec);
 		const plan = resolveExecutionPlan({
 			config,
 			appName: values.app,
@@ -2336,7 +2318,7 @@ async function resolveTarget(values) {
 	}
 	if (await configFileExists(configPath)) return {
 		mode: "list-apps",
-		config: loadProjectConfig({ content: await readConfigFile(configPath) })
+		config: loadProjectConfig({ content: await readConfigFile(configPath) }, configCodec)
 	};
 	return { mode: "single-legacy" };
 }
@@ -2524,65 +2506,74 @@ const { resolveFilePath: resolveActionFilePath, resolveContainerConfig: resolveA
 	})
 });
 //#endregion
-//#region src/cli/commands/action/apply.ts
-async function runAction(config) {
-	const container = createActionCliContainer(config);
-	const s = p.spinner();
-	s.start("Applying action settings...");
-	await applyAction({ container });
-	s.stop("Action settings applied.");
-	p.log.success("Action settings applied successfully.");
-	return container;
-}
-var apply_default$12 = define({
-	name: "apply",
-	description: "Apply action settings from YAML to kintone app",
-	args: {
-		...actionArgs,
-		...confirmArgs
-	},
-	run: async (ctx) => {
+//#region src/cli/commands/applyCommandFactory.ts
+function createApplyCommand(config) {
+	async function runApply(containerConfig) {
+		const container = config.createContainer(containerConfig);
+		const s = p.spinner();
+		s.start(config.spinnerMessage);
+		let result;
 		try {
-			const values = ctx.values;
-			const skipConfirm = values.yes === true;
-			await routeMultiApp(values, {
-				singleLegacy: async () => {
-					await confirmAndDeploy([await runAction(resolveActionContainerConfig(values))], skipConfirm);
-				},
-				singleApp: async (app, projectConfig) => {
-					await confirmAndDeploy([await runAction(resolveActionAppContainerConfig(app, projectConfig, values))], skipConfirm);
-				},
-				multiApp: async (plan, projectConfig) => {
-					const containers = [];
-					await runMultiAppWithHeaders(plan, async (app) => {
-						const container = await runAction(resolveActionAppContainerConfig(app, projectConfig, values));
-						containers.push({
-							appDeployer: container.appDeployer,
-							appName: app.name
-						});
-					});
-					await confirmAndDeploy(containers, skipConfirm);
-				}
-			});
+			result = await config.applyFn({ container });
 		} catch (error) {
-			handleCliError(error);
+			s.stop("Apply failed.");
+			throw error;
 		}
+		s.stop(config.spinnerStopMessage);
+		config.onResult?.(result);
+		p.log.success(config.successMessage);
+		return container;
 	}
-});
-//#endregion
-//#region src/core/domain/services/yamlConfigSerializer.ts
-function serializeToYaml(data) {
-	try {
-		return stringify(data, {
-			lineWidth: 0,
-			defaultKeyType: "PLAIN",
-			defaultStringType: "PLAIN"
-		});
-	} catch (error) {
-		throw new BusinessRuleError(DomainServiceErrorCode.YamlSerializationFailed, `Failed to serialize config to YAML: ${error instanceof Error ? error.message : String(error)}`, error);
-	}
+	return define({
+		name: "apply",
+		description: config.description,
+		args: {
+			...config.args,
+			...confirmArgs
+		},
+		run: async (ctx) => {
+			try {
+				const values = ctx.values;
+				const skipConfirm = ctx.values.yes === true;
+				await routeMultiApp(values, {
+					singleLegacy: async () => {
+						await confirmAndDeploy([await runApply(config.resolveContainerConfig(values))], skipConfirm);
+					},
+					singleApp: async (app, projectConfig) => {
+						await confirmAndDeploy([await runApply(config.resolveAppContainerConfig(app, projectConfig, values))], skipConfirm);
+					},
+					multiApp: async (plan, projectConfig) => {
+						const containers = [];
+						await runMultiAppWithHeaders(plan, async (app) => {
+							const container = await runApply(config.resolveAppContainerConfig(app, projectConfig, values));
+							containers.push({
+								appDeployer: container.appDeployer,
+								appName: app.name
+							});
+						});
+						await confirmAndDeploy(containers, skipConfirm);
+					}
+				});
+			} catch (error) {
+				handleCliError(error);
+			}
+		}
+	});
 }
 //#endregion
+//#region src/cli/commands/action/apply.ts
+var apply_default$12 = createApplyCommand({
+	description: "Apply action settings from YAML to kintone app",
+	args: actionArgs,
+	spinnerMessage: "Applying action settings...",
+	spinnerStopMessage: "Action settings applied.",
+	successMessage: "Action settings applied successfully.",
+	createContainer: createActionCliContainer,
+	applyFn: applyAction,
+	resolveContainerConfig: resolveActionContainerConfig,
+	resolveAppContainerConfig: resolveActionAppContainerConfig
+});
+//#endregion
 //#region src/core/domain/action/services/configSerializer.ts
 function serializeDestApp(destApp) {
 	const result = {};
@@ -2618,7 +2609,7 @@ const ActionConfigSerializer = { serialize: (config) => {
 	const actions = {};
 	for (const [key, value] of Object.entries(config.actions)) actions[key] = serializeActionConfig(value);
 	serialized.actions = actions;
-	return serializeToYaml(serialized);
+	return serialized;
 } };
 //#endregion
 //#region src/core/application/captureFromConfigBase.ts
@@ -2630,11 +2621,20 @@ async function captureFromConfig(config) {
 	};
 }
 //#endregion
+//#region src/core/application/stringifyConfig.ts
+function stringifyConfig(codec, data) {
+	try {
+		return codec.stringify(data);
+	} catch (cause) {
+		throw new SystemError(SystemErrorCode.InternalServerError, `Failed to serialize config: ${cause instanceof Error ? cause.message : String(cause)}`, cause);
+	}
+}
+//#endregion
 //#region src/core/application/action/captureAction.ts
 async function captureAction({ container }) {
 	return captureFromConfig({
 		fetchRemote: () => container.actionConfigurator.getActions(),
-		serialize: ({ actions }) => ActionConfigSerializer.serialize({ actions }),
+		serialize: ({ actions }) => stringifyConfig(container.configCodec, ActionConfigSerializer.serialize({ actions })),
 		getStorage: () => container.actionStorage.get()
 	});
 }
@@ -2644,46 +2644,70 @@ async function saveAction({ container, input }) {
 	await container.actionStorage.update(input.configText);
 }
 //#endregion
-//#region src/cli/commands/action/capture.ts
-async function runCaptureAction(config) {
-	const container = createActionCliContainer(config);
-	const s = p.spinner();
-	s.start("Capturing action settings...");
-	const result = await captureAction({ container });
-	s.stop("Action settings captured.");
-	await saveAction({
-		container,
-		input: { configText: result.configText }
-	});
-	p.log.success(`Action settings saved to: ${pc.cyan(config.actionFilePath)}`);
-	if (result.hasExistingConfig) p.log.warn("Existing action file was overwritten.");
-}
-var capture_default$13 = define({
-	name: "capture",
-	description: "Capture current action settings from kintone app to file",
-	args: actionArgs,
-	run: async (ctx) => {
+//#region src/cli/commands/captureCommandFactory.ts
+function createCaptureCommand(config) {
+	async function runCapture(containerConfig) {
+		const container = config.createContainer(containerConfig);
+		const s = p.spinner();
+		s.start(config.spinnerMessage);
+		let result;
 		try {
-			const values = ctx.values;
-			await routeMultiApp(values, {
-				singleLegacy: async () => {
-					await runCaptureAction(resolveActionContainerConfig(values));
-				},
-				singleApp: async (app, projectConfig) => {
-					await runCaptureAction(resolveActionAppContainerConfig(app, projectConfig, values));
-				},
-				multiApp: async (plan, projectConfig) => {
-					await runMultiAppWithFailCheck(plan, async (app) => {
-						const config = resolveActionAppContainerConfig(app, projectConfig, values);
-						printAppHeader(app.name, app.appId);
-						await runCaptureAction(config);
-					}, "All action captures completed successfully.");
-				}
-			});
+			result = await config.captureFn({ container });
 		} catch (error) {
-			handleCliError(error);
+			s.stop("Capture failed.");
+			throw error;
 		}
+		s.stop(config.spinnerStopMessage);
+		await config.saveFn({
+			container,
+			input: { configText: result.configText }
+		});
+		if (result.hasExistingConfig) p.log.warn(`Existing ${config.domainLabel.toLowerCase()} file was overwritten.`);
+		p.log.success(`${config.domainLabel} saved to: ${pc.cyan(config.getConfigFilePath(containerConfig))}`);
 	}
+	return define({
+		name: "capture",
+		description: config.description,
+		args: config.args,
+		run: async (ctx) => {
+			try {
+				const values = ctx.values;
+				await routeMultiApp(values, {
+					singleLegacy: async () => {
+						await runCapture(config.resolveContainerConfig(values));
+					},
+					singleApp: async (app, projectConfig) => {
+						await runCapture(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 runCapture(containerConfig);
+						}, config.multiAppSuccessMessage);
+					}
+				});
+			} catch (error) {
+				handleCliError(error);
+			}
+		}
+	});
+}
+//#endregion
+//#region src/cli/commands/action/capture.ts
+var capture_default$13 = createCaptureCommand({
+	description: "Capture current action settings from kintone app to file",
+	args: actionArgs,
+	spinnerMessage: "Capturing action settings...",
+	spinnerStopMessage: "Action settings captured.",
+	domainLabel: "Action settings",
+	multiAppSuccessMessage: "All action captures completed successfully.",
+	createContainer: createActionCliContainer,
+	captureFn: captureAction,
+	saveFn: saveAction,
+	getConfigFilePath: (config) => config.actionFilePath,
+	resolveContainerConfig: resolveActionContainerConfig,
+	resolveAppContainerConfig: resolveActionAppContainerConfig
 });
 //#endregion
 //#region src/lib/deepEqual.ts
@@ -2753,14 +2777,7 @@ function isSetEqual(a, b, stack) {
 	}
 	return true;
 }
-function deepEqualInner(a, b, stack) {
-	if (a === b) return true;
-	if (typeof a === "number" && typeof b === "number" && Number.isNaN(a) && Number.isNaN(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;
+function compareDateOrRegExp(objA, objB) {
 	if (objA instanceof Date && objB instanceof Date) {
 		const ta = objA.getTime();
 		const tb = objB.getTime();
@@ -2769,16 +2786,30 @@ function deepEqualInner(a, b, stack) {
 	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;
+}
+function compareCollectionOrRecord(objA, objB, stack) {
+	if (Array.isArray(objA)) return isArrayEqual(objA, objB, stack);
+	if (objA instanceof Map) return isMapEqual$1(objA, objB, stack);
+	if (objB instanceof Map) return false;
+	if (objA instanceof Set) return isSetEqual(objA, objB, stack);
+	if (objB instanceof Set) return false;
+	if (isRecord(objA)) return isRecordEqual(objA, objB, stack);
+	return false;
+}
+function deepEqualInner(a, b, stack) {
+	if (a === b) return true;
+	if (typeof a === "number" && typeof b === "number" && Number.isNaN(a) && Number.isNaN(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;
+	const dateRegExpResult = compareDateOrRegExp(objA, objB);
+	if (dateRegExpResult !== void 0) return dateRegExpResult;
 	for (const [sa, sb] of stack) if (sa === objA && sb === objB) return true;
 	stack.push([objA, objB]);
 	try {
-		if (Array.isArray(objA)) return isArrayEqual(objA, objB, stack);
-		if (objA instanceof Map) return isMapEqual$1(objA, objB, stack);
-		if (objB instanceof Map) return false;
-		if (objA instanceof Set) return isSetEqual(objA, objB, stack);
-		if (objB instanceof Set) return false;
-		if (isRecord(objA)) return isRecordEqual(objA, objB, stack);
-		return false;
+		return compareCollectionOrRecord(objA, objB, stack);
 	} finally {
 		stack.pop();
 	}
@@ -2903,7 +2934,7 @@ async function detectActionDiff({ container }) {
 	return detectDiffFromConfig({
 		getStorage: () => container.actionStorage.get(),
 		fetchRemote: () => container.actionConfigurator.getActions(),
-		parseConfig: parseActionConfigText,
+		parseConfig: (content) => parseActionConfigText(container.configCodec, content),
 		detect: (local, remote) => ActionDiffDetector.detect(local, { actions: remote.actions }),
 		notFoundMessage: "Action config file not found"
 	});
@@ -2977,30 +3008,27 @@ var action_default = define({
 });
 //#endregion
 //#region src/core/domain/adminNotes/services/configParser.ts
-const AdminNotesConfigParser = { parse: (rawText) => {
-	const parsed = parseYamlConfig(rawText, {
-		emptyConfigText: AdminNotesErrorCode.AnEmptyConfigText,
-		invalidConfigYaml: AdminNotesErrorCode.AnInvalidConfigYaml,
-		invalidConfigStructure: AdminNotesErrorCode.AnInvalidConfigStructure
-	}, "Admin notes");
-	if (typeof parsed.content !== "string") throw new BusinessRuleError(AdminNotesErrorCode.AnInvalidConfigStructure, "Config must have a \"content\" string property");
-	if (typeof parsed.includeInTemplateAndDuplicates !== "boolean") throw new BusinessRuleError(AdminNotesErrorCode.AnInvalidConfigStructure, "Config must have an \"includeInTemplateAndDuplicates\" boolean property");
-	return {
-		content: parsed.content,
-		includeInTemplateAndDuplicates: parsed.includeInTemplateAndDuplicates
+const AdminNotesConfigParser = { parse: (parsed) => {
+	const obj = validateParsedConfig(parsed, AdminNotesErrorCode.AnInvalidConfigStructure, "Admin notes");
+	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");
+	return {
+		content: obj.content,
+		includeInTemplateAndDuplicates: obj.includeInTemplateAndDuplicates
 	};
 } };
 //#endregion
 //#region src/core/application/adminNotes/parseConfig.ts
-function parseAdminNotesConfigText(rawText) {
-	return wrapBusinessRuleError(() => AdminNotesConfigParser.parse(rawText));
+function parseAdminNotesConfigText(codec, rawText) {
+	const parsed = parseConfigText(codec, rawText, "Admin notes");
+	return wrapBusinessRuleError(() => AdminNotesConfigParser.parse(parsed));
 }
 //#endregion
 //#region src/core/application/adminNotes/applyAdminNotes.ts
 async function applyAdminNotes({ container }) {
 	await applyFromConfig({
 		getStorage: () => container.adminNotesStorage.get(),
-		parseConfig: parseAdminNotesConfigText,
+		parseConfig: (content) => parseAdminNotesConfigText(container.configCodec, content),
 		fetchRemote: () => container.adminNotesConfigurator.getAdminNotes(),
 		update: async (config, current) => {
 			await container.adminNotesConfigurator.updateAdminNotes({
@@ -3059,6 +3087,7 @@ function createLocalFileAdminNotesStorage(filePath) {
 function createAdminNotesCliContainer(config) {
 	const client = config.client ?? createKintoneClient(config);
 	return {
+		configCodec,
 		adminNotesConfigurator: new KintoneAdminNotesConfigurator(client, config.appId),
 		adminNotesStorage: createLocalFileAdminNotesStorage(config.adminNotesFilePath),
 		appDeployer: new KintoneAppDeployer(client, config.appId)
@@ -3087,64 +3116,31 @@ const { resolveFilePath: resolveAdminNotesFilePath, resolveContainerConfig: reso
 });
 //#endregion
 //#region src/cli/commands/admin-notes/apply.ts
-async function runAdminNotes(config) {
-	const container = createAdminNotesCliContainer(config);
-	const s = p.spinner();
-	s.start("Applying admin notes...");
-	await applyAdminNotes({ container });
-	s.stop("Admin notes applied.");
-	p.log.success("Admin notes applied successfully.");
-	return container;
-}
-var apply_default$11 = define({
-	name: "apply",
+var apply_default$11 = createApplyCommand({
 	description: "Apply admin notes from YAML to kintone app",
-	args: {
-		...adminNotesArgs,
-		...confirmArgs
-	},
-	run: async (ctx) => {
-		try {
-			const values = ctx.values;
-			const skipConfirm = values.yes === true;
-			await routeMultiApp(values, {
-				singleLegacy: async () => {
-					await confirmAndDeploy([await runAdminNotes(resolveAdminNotesContainerConfig(values))], skipConfirm);
-				},
-				singleApp: async (app, projectConfig) => {
-					await confirmAndDeploy([await runAdminNotes(resolveAdminNotesAppContainerConfig(app, projectConfig, values))], skipConfirm);
-				},
-				multiApp: async (plan, projectConfig) => {
-					const containers = [];
-					await runMultiAppWithHeaders(plan, async (app) => {
-						const container = await runAdminNotes(resolveAdminNotesAppContainerConfig(app, projectConfig, values));
-						containers.push({
-							appDeployer: container.appDeployer,
-							appName: app.name
-						});
-					});
-					await confirmAndDeploy(containers, skipConfirm);
-				}
-			});
-		} catch (error) {
-			handleCliError(error);
-		}
-	}
+	args: adminNotesArgs,
+	spinnerMessage: "Applying admin notes...",
+	spinnerStopMessage: "Admin notes applied.",
+	successMessage: "Admin notes applied successfully.",
+	createContainer: createAdminNotesCliContainer,
+	applyFn: applyAdminNotes,
+	resolveContainerConfig: resolveAdminNotesContainerConfig,
+	resolveAppContainerConfig: resolveAdminNotesAppContainerConfig
 });
 //#endregion
 //#region src/core/domain/adminNotes/services/configSerializer.ts
 const AdminNotesConfigSerializer = { serialize: (config) => {
-	return serializeToYaml({
+	return {
 		content: config.content,
 		includeInTemplateAndDuplicates: config.includeInTemplateAndDuplicates
-	});
+	};
 } };
 //#endregion
 //#region src/core/application/adminNotes/captureAdminNotes.ts
 async function captureAdminNotes({ container }) {
 	return captureFromConfig({
 		fetchRemote: () => container.adminNotesConfigurator.getAdminNotes(),
-		serialize: ({ config }) => AdminNotesConfigSerializer.serialize(config),
+		serialize: ({ config }) => stringifyConfig(container.configCodec, AdminNotesConfigSerializer.serialize(config)),
 		getStorage: () => container.adminNotesStorage.get()
 	});
 }
@@ -3155,45 +3151,19 @@ async function saveAdminNotes({ container, input }) {
 }
 //#endregion
 //#region src/cli/commands/admin-notes/capture.ts
-async function runCaptureAdminNotes(config) {
-	const container = createAdminNotesCliContainer(config);
-	const s = p.spinner();
-	s.start("Capturing admin notes...");
-	const result = await captureAdminNotes({ container });
-	s.stop("Admin notes captured.");
-	await saveAdminNotes({
-		container,
-		input: { configText: result.configText }
-	});
-	p.log.success(`Admin notes saved to: ${pc.cyan(config.adminNotesFilePath)}`);
-	if (result.hasExistingConfig) p.log.warn("Existing admin notes file was overwritten.");
-}
-var capture_default$12 = define({
-	name: "capture",
+var capture_default$12 = createCaptureCommand({
 	description: "Capture current admin notes from kintone app to file",
 	args: adminNotesArgs,
-	run: async (ctx) => {
-		try {
-			const values = ctx.values;
-			await routeMultiApp(values, {
-				singleLegacy: async () => {
-					await runCaptureAdminNotes(resolveAdminNotesContainerConfig(values));
-				},
-				singleApp: async (app, projectConfig) => {
-					await runCaptureAdminNotes(resolveAdminNotesAppContainerConfig(app, projectConfig, values));
-				},
-				multiApp: async (plan, projectConfig) => {
-					await runMultiAppWithFailCheck(plan, async (app) => {
-						const config = resolveAdminNotesAppContainerConfig(app, projectConfig, values);
-						printAppHeader(app.name, app.appId);
-						await runCaptureAdminNotes(config);
-					}, "All admin notes captures completed successfully.");
-				}
-			});
-		} catch (error) {
-			handleCliError(error);
-		}
-	}
+	spinnerMessage: "Capturing admin notes...",
+	spinnerStopMessage: "Admin notes captured.",
+	domainLabel: "Admin notes",
+	multiAppSuccessMessage: "All admin notes captures completed successfully.",
+	createContainer: createAdminNotesCliContainer,
+	captureFn: captureAdminNotes,
+	saveFn: saveAdminNotes,
+	getConfigFilePath: (config) => config.adminNotesFilePath,
+	resolveContainerConfig: resolveAdminNotesContainerConfig,
+	resolveAppContainerConfig: resolveAdminNotesAppContainerConfig
 });
 //#endregion
 //#region src/core/domain/adminNotes/services/diffDetector.ts
@@ -3220,7 +3190,7 @@ async function detectAdminNotesDiff({ container }) {
 	return detectDiffFromConfig({
 		getStorage: () => container.adminNotesStorage.get(),
 		fetchRemote: () => container.adminNotesConfigurator.getAdminNotes(),
-		parseConfig: parseAdminNotesConfigText,
+		parseConfig: (content) => parseAdminNotesConfigText(container.configCodec, content),
 		detect: (local, remote) => AdminNotesDiffDetector.detect(local, remote.config),
 		notFoundMessage: "Admin notes config file not found"
 	});
@@ -3276,14 +3246,10 @@ function parseAppRight(raw, index) {
 		recordExportable: parseStrictBoolean(raw.recordExportable, "recordExportable", `App right at index ${index}`, AppPermissionErrorCode.ApInvalidBooleanField)
 	};
 }
-const AppPermissionConfigParser = { parse: (rawText) => {
-	const parsed = parseYamlConfig(rawText, {
-		emptyConfigText: AppPermissionErrorCode.ApEmptyConfigText,
-		invalidConfigYaml: AppPermissionErrorCode.ApInvalidConfigYaml,
-		invalidConfigStructure: AppPermissionErrorCode.ApInvalidConfigStructure
-	}, "App permission");
-	if (!Array.isArray(parsed.rights)) throw new BusinessRuleError(AppPermissionErrorCode.ApInvalidConfigStructure, "Config must have a \"rights\" array");
-	const rights = parsed.rights.map((item, i) => parseAppRight(item, i));
+const AppPermissionConfigParser = { parse: (parsed) => {
+	const obj = validateParsedConfig(parsed, AppPermissionErrorCode.ApInvalidConfigStructure, "App permission");
+	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));
 	const seenKeys = /* @__PURE__ */ new Set();
 	for (const right of rights) {
 		const key = `${right.entity.type}:${right.entity.code}`;
@@ -3294,15 +3260,16 @@ const AppPermissionConfigParser = { parse: (rawText) => {
 } };
 //#endregion
 //#region src/core/application/appPermission/parseConfig.ts
-function parseAppPermissionConfigText(rawText) {
-	return wrapBusinessRuleError(() => AppPermissionConfigParser.parse(rawText));
+function parseAppPermissionConfigText(codec, rawText) {
+	const parsed = parseConfigText(codec, rawText, "App permission");
+	return wrapBusinessRuleError(() => AppPermissionConfigParser.parse(parsed));
 }
 //#endregion
 //#region src/core/application/appPermission/applyAppPermission.ts
 async function applyAppPermission({ container }) {
 	await applyFromConfig({
 		getStorage: () => container.appPermissionStorage.get(),
-		parseConfig: parseAppPermissionConfigText,
+		parseConfig: (content) => parseAppPermissionConfigText(container.configCodec, content),
 		fetchRemote: () => container.appPermissionConfigurator.getAppPermissions(),
 		update: async (config, current) => {
 			await container.appPermissionConfigurator.updateAppPermissions({
@@ -3403,6 +3370,7 @@ function createLocalFileAppPermissionStorage(filePath) {
 function createAppPermissionCliContainer(config) {
 	const client = config.client ?? createKintoneClient(config);
 	return {
+		configCodec,
 		appPermissionConfigurator: new KintoneAppPermissionConfigurator(client, config.appId),
 		appPermissionStorage: createLocalFileAppPermissionStorage(config.appAclFilePath),
 		appDeployer: new KintoneAppDeployer(client, config.appId)
@@ -3431,49 +3399,16 @@ const { resolveFilePath: resolveAppAclFilePath, resolveContainerConfig: resolveA
 });
 //#endregion
 //#region src/cli/commands/app-acl/apply.ts
-async function runAppAcl(config) {
-	const container = createAppPermissionCliContainer(config);
-	const s = p.spinner();
-	s.start("Applying app access permissions...");
-	await applyAppPermission({ container });
-	s.stop("App access permissions applied.");
-	p.log.success("App access permissions applied successfully.");
-	return container;
-}
-var apply_default$10 = define({
-	name: "apply",
+var apply_default$10 = createApplyCommand({
 	description: "Apply app access permissions from YAML to kintone app",
-	args: {
-		...appAclArgs,
-		...confirmArgs
-	},
-	run: async (ctx) => {
-		try {
-			const values = ctx.values;
-			const skipConfirm = values.yes === true;
-			await routeMultiApp(values, {
-				singleLegacy: async () => {
-					await confirmAndDeploy([await runAppAcl(resolveAppAclContainerConfig(values))], skipConfirm);
-				},
-				singleApp: async (app, projectConfig) => {
-					await confirmAndDeploy([await runAppAcl(resolveAppAclAppContainerConfig(app, projectConfig, values))], skipConfirm);
-				},
-				multiApp: async (plan, projectConfig) => {
-					const containers = [];
-					await runMultiAppWithHeaders(plan, async (app) => {
-						const container = await runAppAcl(resolveAppAclAppContainerConfig(app, projectConfig, values));
-						containers.push({
-							appDeployer: container.appDeployer,
-							appName: app.name
-						});
-					});
-					await confirmAndDeploy(containers, skipConfirm);
-				}
-			});
-		} catch (error) {
-			handleCliError(error);
-		}
-	}
+	args: appAclArgs,
+	spinnerMessage: "Applying app access permissions...",
+	spinnerStopMessage: "App access permissions applied.",
+	successMessage: "App access permissions applied successfully.",
+	createContainer: createAppPermissionCliContainer,
+	applyFn: applyAppPermission,
+	resolveContainerConfig: resolveAppAclContainerConfig,
+	resolveAppContainerConfig: resolveAppAclAppContainerConfig
 });
 //#endregion
 //#region src/core/domain/appPermission/services/configSerializer.ts
@@ -3494,14 +3429,14 @@ function serializeAppRight(right) {
 	};
 }
 const AppPermissionConfigSerializer = { serialize: (config) => {
-	return serializeToYaml({ rights: config.rights.map(serializeAppRight) });
+	return { rights: config.rights.map(serializeAppRight) };
 } };
 //#endregion
 //#region src/core/application/appPermission/captureAppPermission.ts
 async function captureAppPermission({ container }) {
 	return captureFromConfig({
 		fetchRemote: () => container.appPermissionConfigurator.getAppPermissions(),
-		serialize: ({ rights }) => AppPermissionConfigSerializer.serialize({ rights }),
+		serialize: ({ rights }) => stringifyConfig(container.configCodec, AppPermissionConfigSerializer.serialize({ rights })),
 		getStorage: () => container.appPermissionStorage.get()
 	});
 }
@@ -3512,45 +3447,19 @@ async function saveAppPermission({ container, input }) {
 }
 //#endregion
 //#region src/cli/commands/app-acl/capture.ts
-async function runCaptureAppAcl(config) {
-	const container = createAppPermissionCliContainer(config);
-	const s = p.spinner();
-	s.start("Capturing app access permissions...");
-	const result = await captureAppPermission({ container });
-	s.stop("App access permissions captured.");
-	await saveAppPermission({
-		container,
-		input: { configText: result.configText }
-	});
-	p.log.success(`App ACL saved to: ${pc.cyan(config.appAclFilePath)}`);
-	if (result.hasExistingConfig) p.log.warn("Existing app ACL file was overwritten.");
-}
-var capture_default$11 = define({
-	name: "capture",
+var capture_default$11 = createCaptureCommand({
 	description: "Capture current app access permissions from kintone app to file",
 	args: appAclArgs,
-	run: async (ctx) => {
-		try {
-			const values = ctx.values;
-			await routeMultiApp(values, {
-				singleLegacy: async () => {
-					await runCaptureAppAcl(resolveAppAclContainerConfig(values));
-				},
-				singleApp: async (app, projectConfig) => {
-					await runCaptureAppAcl(resolveAppAclAppContainerConfig(app, projectConfig, values));
-				},
-				multiApp: async (plan, projectConfig) => {
-					await runMultiAppWithFailCheck(plan, async (app) => {
-						const config = resolveAppAclAppContainerConfig(app, projectConfig, values);
-						printAppHeader(app.name, app.appId);
-						await runCaptureAppAcl(config);
-					}, "All app ACL captures completed successfully.");
-				}
-			});
-		} catch (error) {
-			handleCliError(error);
-		}
-	}
+	spinnerMessage: "Capturing app access permissions...",
+	spinnerStopMessage: "App access permissions captured.",
+	domainLabel: "App ACL",
+	multiAppSuccessMessage: "All app ACL captures completed successfully.",
+	createContainer: createAppPermissionCliContainer,
+	captureFn: captureAppPermission,
+	saveFn: saveAppPermission,
+	getConfigFilePath: (config) => config.appAclFilePath,
+	resolveContainerConfig: resolveAppAclContainerConfig,
+	resolveAppContainerConfig: resolveAppAclAppContainerConfig
 });
 //#endregion
 //#region src/core/domain/appPermission/services/diffDetector.ts
@@ -3609,7 +3518,7 @@ async function detectAppPermissionDiff({ container }) {
 	return detectDiffFromConfig({
 		getStorage: () => container.appPermissionStorage.get(),
 		fetchRemote: () => container.appPermissionConfigurator.getAppPermissions(),
-		parseConfig: parseAppPermissionConfigText,
+		parseConfig: (content) => parseAppPermissionConfigText(container.configCodec, content),
 		detect: (local, remote) => AppPermissionDiffDetector.detect(local, { rights: remote.rights }),
 		notFoundMessage: "App permission config file not found"
 	});
@@ -3693,12 +3602,8 @@ function parsePlatform(raw) {
 		css: raw.css === void 0 || raw.css === null ? [] : parseResourceList(raw.css)
 	};
 }
-const CustomizationConfigParser = { parse: (rawText) => {
-	const obj = parseYamlConfig(rawText, {
-		emptyConfigText: CustomizationErrorCode.CzEmptyConfigText,
-		invalidConfigYaml: CustomizationErrorCode.CzInvalidConfigYaml,
-		invalidConfigStructure: CustomizationErrorCode.CzInvalidConfigStructure
-	}, "Customization");
+const CustomizationConfigParser = { parse: (parsed) => {
+	const obj = validateParsedConfig(parsed, CustomizationErrorCode.CzInvalidConfigStructure, "Customization");
 	let scope;
 	if (obj.scope !== void 0 && obj.scope !== null) {
 		if (typeof obj.scope !== "string" || !isCustomizationScope(obj.scope)) throw new BusinessRuleError(CustomizationErrorCode.CzInvalidScope, `Invalid scope: ${String(obj.scope)}. Must be ALL, ADMIN, or NONE`);
@@ -3720,8 +3625,9 @@ const CustomizationConfigParser = { parse: (rawText) => {
 } };
 //#endregion
 //#region src/core/application/customization/parseConfig.ts
-function parseConfigText(rawText) {
-	return wrapBusinessRuleError(() => CustomizationConfigParser.parse(rawText));
+function parseCustomizationConfigText(codec, rawText) {
+	const parsed = parseConfigText(codec, rawText, "Customization");
+	return wrapBusinessRuleError(() => CustomizationConfigParser.parse(parsed));
 }
 //#endregion
 //#region src/core/application/customization/applyCustomization.ts
@@ -3753,7 +3659,7 @@ function mergePlatform(current, incoming) {
 async function applyCustomization({ container, input }) {
 	const result = await container.customizationStorage.get();
 	if (!result.exists) throw new ValidationError(ValidationErrorCode.InvalidInput, "Customization config file not found");
-	const config = parseConfigText(result.content);
+	const config = parseCustomizationConfigText(container.configCodec, result.content);
 	const currentCustomization = await container.customizationConfigurator.getCustomization();
 	const [resolvedDesktop, resolvedMobile] = await Promise.all([resolveResources(config.desktop, input.basePath, container.fileUploader), resolveResources(config.mobile, input.basePath, container.fileUploader)]);
 	const mergedDesktop = mergePlatform(currentCustomization.desktop, resolvedDesktop);
@@ -3821,11 +3727,11 @@ function serializePlatform(platform) {
 	};
 }
 const CustomizationConfigSerializer = { serialize: (config) => {
-	return serializeToYaml({
+	return {
 		...config.scope !== void 0 ? { scope: config.scope } : {},
 		...hasPlatformResources(config.desktop) ? { desktop: serializePlatform(config.desktop) } : {},
 		...hasPlatformResources(config.mobile) ? { mobile: serializePlatform(config.mobile) } : {}
-	});
+	};
 } };
 //#endregion
 //#region src/lib/deduplicateName.ts
@@ -3967,7 +3873,7 @@ async function captureCustomization({ container, input }) {
 		desktop: desktopPlan.platform,
 		mobile: mobilePlan.platform
 	};
-	const configText = CustomizationConfigSerializer.serialize(config);
+	const configText = stringifyConfig(container.configCodec, CustomizationConfigSerializer.serialize(config));
 	await downloadFiles([...desktopPlan.filesToDownload, ...mobilePlan.filesToDownload], container);
 	return {
 		configText,
@@ -4161,7 +4067,7 @@ async function detectCustomizationDiff({ container }) {
 	return detectDiffFromConfig({
 		getStorage: () => container.customizationStorage.get(),
 		fetchRemote: () => container.customizationConfigurator.getCustomization(),
-		parseConfig: (content) => parseConfigText(content),
+		parseConfig: (content) => parseCustomizationConfigText(container.configCodec, content),
 		detect: (local, remote) => CustomizationDiffDetector.detect(local, remote),
 		notFoundMessage: "Customization config file not found"
 	});
@@ -4282,6 +4188,7 @@ function createLocalFileFieldPermissionStorage(filePath) {
 function createFieldPermissionCliContainer(config) {
 	const client = config.client ?? createKintoneClient(config);
 	return {
+		configCodec,
 		fieldPermissionConfigurator: new KintoneFieldPermissionConfigurator(client, config.appId),
 		fieldPermissionStorage: createLocalFileFieldPermissionStorage(config.fieldAclFilePath),
 		appDeployer: new KintoneAppDeployer(client, config.appId)
@@ -4329,14 +4236,10 @@ function parseFieldRight(raw, index) {
 		entities
 	};
 }
-const FieldPermissionConfigParser = { parse: (rawText) => {
-	const parsed = parseYamlConfig(rawText, {
-		emptyConfigText: FieldPermissionErrorCode.FpEmptyConfigText,
-		invalidConfigYaml: FieldPermissionErrorCode.FpInvalidConfigYaml,
-		invalidConfigStructure: FieldPermissionErrorCode.FpInvalidConfigStructure
-	}, "Field permission");
-	if (!Array.isArray(parsed.rights)) throw new BusinessRuleError(FieldPermissionErrorCode.FpInvalidConfigStructure, "Config must have a \"rights\" array");
-	const rights = parsed.rights.map((item, i) => parseFieldRight(item, i));
+const FieldPermissionConfigParser = { parse: (parsed) => {
+	const obj = validateParsedConfig(parsed, FieldPermissionErrorCode.FpInvalidConfigStructure, "Field permission");
+	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));
 	const seenCodes = /* @__PURE__ */ new Set();
 	for (const right of rights) {
 		if (seenCodes.has(right.code)) throw new BusinessRuleError(FieldPermissionErrorCode.FpDuplicateFieldCode, `Duplicate field code: ${right.code}`);
@@ -4346,15 +4249,16 @@ const FieldPermissionConfigParser = { parse: (rawText) => {
 } };
 //#endregion
 //#region src/core/application/fieldPermission/parseConfig.ts
-function parseFieldPermissionConfigText(rawText) {
-	return wrapBusinessRuleError(() => FieldPermissionConfigParser.parse(rawText));
+function parseFieldPermissionConfigText(codec, rawText) {
+	const parsed = parseConfigText(codec, rawText, "Field permission");
+	return wrapBusinessRuleError(() => FieldPermissionConfigParser.parse(parsed));
 }
 //#endregion
 //#region src/core/application/fieldPermission/applyFieldPermission.ts
 async function applyFieldPermission({ container }) {
 	await applyFromConfig({
 		getStorage: () => container.fieldPermissionStorage.get(),
-		parseConfig: parseFieldPermissionConfigText,
+		parseConfig: (content) => parseFieldPermissionConfigText(container.configCodec, content),
 		fetchRemote: () => container.fieldPermissionConfigurator.getFieldPermissions(),
 		update: async (config, current) => {
 			await container.fieldPermissionConfigurator.updateFieldPermissions({
@@ -4388,49 +4292,16 @@ const { resolveFilePath: resolveFieldAclFilePath, resolveContainerConfig: resolv
 });
 //#endregion
 //#region src/cli/commands/field-acl/apply.ts
-async function runFieldAcl(config) {
-	const container = createFieldPermissionCliContainer(config);
-	const s = p.spinner();
-	s.start("Applying field access permissions...");
-	await applyFieldPermission({ container });
-	s.stop("Field access permissions applied.");
-	p.log.success("Field access permissions applied successfully.");
-	return container;
-}
-var apply_default$8 = define({
-	name: "apply",
+var apply_default$8 = createApplyCommand({
 	description: "Apply field access permissions from YAML to kintone app",
-	args: {
-		...fieldAclArgs,
-		...confirmArgs
-	},
-	run: async (ctx) => {
-		try {
-			const values = ctx.values;
-			const skipConfirm = values.yes === true;
-			await routeMultiApp(values, {
-				singleLegacy: async () => {
-					await confirmAndDeploy([await runFieldAcl(resolveFieldAclContainerConfig(values))], skipConfirm);
-				},
-				singleApp: async (app, projectConfig) => {
-					await confirmAndDeploy([await runFieldAcl(resolveFieldAclAppContainerConfig(app, projectConfig, values))], skipConfirm);
-				},
-				multiApp: async (plan, projectConfig) => {
-					const containers = [];
-					await runMultiAppWithHeaders(plan, async (app) => {
-						const container = await runFieldAcl(resolveFieldAclAppContainerConfig(app, projectConfig, values));
-						containers.push({
-							appDeployer: container.appDeployer,
-							appName: app.name
-						});
-					});
-					await confirmAndDeploy(containers, skipConfirm);
-				}
-			});
-		} catch (error) {
-			handleCliError(error);
-		}
-	}
+	args: fieldAclArgs,
+	spinnerMessage: "Applying field access permissions...",
+	spinnerStopMessage: "Field access permissions applied.",
+	successMessage: "Field access permissions applied successfully.",
+	createContainer: createFieldPermissionCliContainer,
+	applyFn: applyFieldPermission,
+	resolveContainerConfig: resolveFieldAclContainerConfig,
+	resolveAppContainerConfig: resolveFieldAclAppContainerConfig
 });
 //#endregion
 //#region src/core/domain/fieldPermission/services/configSerializer.ts
@@ -4446,17 +4317,17 @@ function serializeFieldRightEntity(entity) {
 	return result;
 }
 const FieldPermissionConfigSerializer = { serialize: (config) => {
-	return serializeToYaml({ rights: config.rights.map((right) => ({
+	return { rights: config.rights.map((right) => ({
 		code: right.code,
 		entities: right.entities.map(serializeFieldRightEntity)
-	})) });
+	})) };
 } };
 //#endregion
 //#region src/core/application/fieldPermission/captureFieldPermission.ts
 async function captureFieldPermission({ container }) {
 	return captureFromConfig({
 		fetchRemote: () => container.fieldPermissionConfigurator.getFieldPermissions(),
-		serialize: ({ rights }) => FieldPermissionConfigSerializer.serialize({ rights }),
+		serialize: ({ rights }) => stringifyConfig(container.configCodec, FieldPermissionConfigSerializer.serialize({ rights })),
 		getStorage: () => container.fieldPermissionStorage.get()
 	});
 }
@@ -4467,45 +4338,19 @@ async function saveFieldPermission({ container, input }) {
 }
 //#endregion
 //#region src/cli/commands/field-acl/capture.ts
-async function runCaptureFieldAcl(config) {
-	const container = createFieldPermissionCliContainer(config);
-	const s = p.spinner();
-	s.start("Capturing field access permissions...");
-	const result = await captureFieldPermission({ container });
-	s.stop("Field access permissions captured.");
-	await saveFieldPermission({
-		container,
-		input: { configText: result.configText }
-	});
-	p.log.success(`Field ACL saved to: ${pc.cyan(config.fieldAclFilePath)}`);
-	if (result.hasExistingConfig) p.log.warn("Existing field ACL file was overwritten.");
-}
-var capture_default$9 = define({
-	name: "capture",
+var capture_default$9 = createCaptureCommand({
 	description: "Capture current field access permissions from kintone app to file",
 	args: fieldAclArgs,
-	run: async (ctx) => {
-		try {
-			const values = ctx.values;
-			await routeMultiApp(values, {
-				singleLegacy: async () => {
-					await runCaptureFieldAcl(resolveFieldAclContainerConfig(values));
-				},
-				singleApp: async (app, projectConfig) => {
-					await runCaptureFieldAcl(resolveFieldAclAppContainerConfig(app, projectConfig, values));
-				},
-				multiApp: async (plan, projectConfig) => {
-					await runMultiAppWithFailCheck(plan, async (app) => {
-						const config = resolveFieldAclAppContainerConfig(app, projectConfig, values);
-						printAppHeader(app.name, app.appId);
-						await runCaptureFieldAcl(config);
-					}, "All field ACL captures completed successfully.");
-				}
-			});
-		} catch (error) {
-			handleCliError(error);
-		}
-	}
+	spinnerMessage: "Capturing field access permissions...",
+	spinnerStopMessage: "Field access permissions captured.",
+	domainLabel: "Field ACL",
+	multiAppSuccessMessage: "All field ACL captures completed successfully.",
+	createContainer: createFieldPermissionCliContainer,
+	captureFn: captureFieldPermission,
+	saveFn: saveFieldPermission,
+	getConfigFilePath: (config) => config.fieldAclFilePath,
+	resolveContainerConfig: resolveFieldAclContainerConfig,
+	resolveAppContainerConfig: resolveFieldAclAppContainerConfig
 });
 //#endregion
 //#region src/core/domain/fieldPermission/services/diffDetector.ts
@@ -4552,7 +4397,7 @@ async function detectFieldPermissionDiff({ container }) {
 	return detectDiffFromConfig({
 		getStorage: () => container.fieldPermissionStorage.get(),
 		fetchRemote: () => container.fieldPermissionConfigurator.getFieldPermissions(),
-		parseConfig: parseFieldPermissionConfigText,
+		parseConfig: (content) => parseFieldPermissionConfigText(container.configCodec, content),
 		detect: (local, remote) => FieldPermissionDiffDetector.detect(local, { rights: remote.rights }),
 		notFoundMessage: "Field permission config file not found"
 	});
@@ -4728,6 +4573,7 @@ function createLocalFileGeneralSettingsStorage(filePath) {
 function createGeneralSettingsCliContainer(config) {
 	const client = config.client ?? createKintoneClient(config);
 	return {
+		configCodec,
 		generalSettingsConfigurator: new KintoneGeneralSettingsConfigurator(client, config.appId),
 		generalSettingsStorage: createLocalFileGeneralSettingsStorage(config.settingsFilePath),
 		appDeployer: new KintoneAppDeployer(client, config.appId)
@@ -4948,6 +4794,7 @@ function createLocalFileNotificationStorage(filePath) {
 function createNotificationCliContainer(config) {
 	const client = config.client ?? createKintoneClient(config);
 	return {
+		configCodec,
 		notificationConfigurator: new KintoneNotificationConfigurator(client, config.appId),
 		notificationStorage: createLocalFileNotificationStorage(config.notificationFilePath),
 		appDeployer: new KintoneAppDeployer(client, config.appId)
@@ -5000,6 +4847,7 @@ function createLocalFilePluginStorage(filePath) {
 function createPluginCliContainer(config) {
 	const client = config.client ?? createKintoneClient(config);
 	return {
+		configCodec,
 		pluginConfigurator: new KintonePluginConfigurator(client, config.appId),
 		pluginStorage: createLocalFilePluginStorage(config.pluginFilePath),
 		appDeployer: new KintoneAppDeployer(client, config.appId)
@@ -5146,6 +4994,7 @@ function createLocalFileProcessManagementStorage(filePath) {
 function createProcessManagementCliContainer(config) {
 	const client = config.client ?? createKintoneClient(config);
 	return {
+		configCodec,
 		processManagementConfigurator: new KintoneProcessManagementConfigurator(client, config.appId),
 		processManagementStorage: createLocalFileProcessManagementStorage(config.processFilePath),
 		appDeployer: new KintoneAppDeployer(client, config.appId)
@@ -5238,6 +5087,7 @@ function createLocalFileRecordPermissionStorage(filePath) {
 function createRecordPermissionCliContainer(config) {
 	const client = config.client ?? createKintoneClient(config);
 	return {
+		configCodec,
 		recordPermissionConfigurator: new KintoneRecordPermissionConfigurator(client, config.appId),
 		recordPermissionStorage: createLocalFileRecordPermissionStorage(config.recordAclFilePath),
 		appDeployer: new KintoneAppDeployer(client, config.appId)
@@ -5510,6 +5360,7 @@ function createLocalFileReportStorage(filePath) {
 function createReportCliContainer(config) {
 	const client = config.client ?? createKintoneClient(config);
 	return {
+		configCodec,
 		reportConfigurator: new KintoneReportConfigurator(client, config.appId),
 		reportStorage: createLocalFileReportStorage(config.reportFilePath),
 		appDeployer: new KintoneAppDeployer(client, config.appId)
@@ -5616,6 +5467,7 @@ function createLocalFileViewStorage(filePath) {
 function createViewCliContainer(config) {
 	const client = config.client ?? createKintoneClient(config);
 	return {
+		configCodec,
 		viewConfigurator: new KintoneViewConfigurator(client, config.appId),
 		viewStorage: createLocalFileViewStorage(config.viewFilePath),
 		appDeployer: new KintoneAppDeployer(client, config.appId)
@@ -5904,11 +5756,7 @@ function serializeLayoutItem(item, fields) {
 	}
 }
 const SchemaSerializer = { serialize: (layout, fields) => {
-	return stringify({ layout: layout.map((item) => serializeLayoutItem(item, fields)) }, {
-		lineWidth: 0,
-		defaultKeyType: "PLAIN",
-		defaultStringType: "PLAIN"
-	});
+	return { layout: layout.map((item) => serializeLayoutItem(item, fields)) };
 } };
 //#endregion
 //#region src/core/application/formSchema/captureSchema.ts
@@ -5916,7 +5764,7 @@ async function captureSchema({ container }) {
 	const [currentFields, currentLayout] = await Promise.all([container.formConfigurator.getFields(), container.formConfigurator.getLayout()]);
 	const enrichedLayout = enrichLayoutWithFields(currentLayout, currentFields);
 	return {
-		schemaText: SchemaSerializer.serialize(enrichedLayout, currentFields),
+		schemaText: stringifyConfig(container.configCodec, SchemaSerializer.serialize(enrichedLayout, currentFields)),
 		hasExistingSchema: (await container.schemaStorage.get()).exists
 	};
 }
@@ -5955,14 +5803,14 @@ function serializeConfig(config) {
 	return result;
 }
 const GeneralSettingsConfigSerializer = { serialize: (config) => {
-	return serializeToYaml(serializeConfig(config));
+	return serializeConfig(config);
 } };
 //#endregion
 //#region src/core/application/generalSettings/captureGeneralSettings.ts
 async function captureGeneralSettings({ container }) {
 	return captureFromConfig({
 		fetchRemote: () => container.generalSettingsConfigurator.getGeneralSettings(),
-		serialize: ({ config }) => GeneralSettingsConfigSerializer.serialize(config),
+		serialize: ({ config }) => stringifyConfig(container.configCodec, GeneralSettingsConfigSerializer.serialize(config)),
 		getStorage: () => container.generalSettingsStorage.get()
 	});
 }
@@ -6026,7 +5874,7 @@ const NotificationConfigSerializer = { serialize: (config) => {
 		timezone: config.reminder.timezone,
 		notifications: config.reminder.notifications.map(serializeReminderNotification)
 	};
-	return serializeToYaml(serialized);
+	return serialized;
 } };
 //#endregion
 //#region src/core/application/notification/captureNotification.ts
@@ -6048,7 +5896,7 @@ async function captureNotification({ container }) {
 		}
 	};
 	return {
-		configText: NotificationConfigSerializer.serialize(config),
+		configText: stringifyConfig(container.configCodec, NotificationConfigSerializer.serialize(config)),
 		hasExistingConfig: (await container.notificationStorage.get()).exists
 	};
 }
@@ -6060,18 +5908,18 @@ async function saveNotification({ container, input }) {
 //#endregion
 //#region src/core/domain/plugin/services/configSerializer.ts
 const PluginConfigSerializer = { serialize: (config) => {
-	return serializeToYaml({ plugins: config.plugins.map((plugin) => ({
+	return { plugins: config.plugins.map((plugin) => ({
 		id: plugin.id,
 		name: plugin.name,
 		enabled: plugin.enabled
-	})) });
+	})) };
 } };
 //#endregion
 //#region src/core/application/plugin/capturePlugin.ts
 async function capturePlugin({ container }) {
 	return captureFromConfig({
 		fetchRemote: () => container.pluginConfigurator.getPlugins(),
-		serialize: ({ plugins }) => PluginConfigSerializer.serialize({ plugins }),
+		serialize: ({ plugins }) => stringifyConfig(container.configCodec, PluginConfigSerializer.serialize({ plugins })),
 		getStorage: () => container.pluginStorage.get()
 	});
 }
@@ -6097,7 +5945,7 @@ const ProcessManagementConfigSerializer = { serialize: (config) => {
 			entities: state.assignee.entities.map(serializeProcessEntity)
 		}
 	};
-	return serializeToYaml({
+	return {
 		enable: config.enable,
 		states: serializedStates,
 		actions: config.actions.map((action) => {
@@ -6111,14 +5959,14 @@ const ProcessManagementConfigSerializer = { serialize: (config) => {
 			if (action.executableUser !== void 0) serializedAction.executableUser = { entities: action.executableUser.entities.map(serializeProcessEntity) };
 			return serializedAction;
 		})
-	});
+	};
 } };
 //#endregion
 //#region src/core/application/processManagement/captureProcessManagement.ts
 async function captureProcessManagement({ container }) {
 	return captureFromConfig({
 		fetchRemote: () => container.processManagementConfigurator.getProcessManagement(),
-		serialize: ({ config }) => ProcessManagementConfigSerializer.serialize(config),
+		serialize: ({ config }) => stringifyConfig(container.configCodec, ProcessManagementConfigSerializer.serialize(config)),
 		getStorage: () => container.processManagementStorage.get()
 	});
 }
@@ -6142,17 +5990,17 @@ function serializeRecordRightEntity(entity) {
 	};
 }
 const RecordPermissionConfigSerializer = { serialize: (config) => {
-	return serializeToYaml({ rights: config.rights.map((right) => ({
+	return { rights: config.rights.map((right) => ({
 		filterCond: right.filterCond,
 		entities: right.entities.map(serializeRecordRightEntity)
-	})) });
+	})) };
 } };
 //#endregion
 //#region src/core/application/recordPermission/captureRecordPermission.ts
 async function captureRecordPermission({ container }) {
 	return captureFromConfig({
 		fetchRemote: () => container.recordPermissionConfigurator.getRecordPermissions(),
-		serialize: ({ rights }) => RecordPermissionConfigSerializer.serialize({ rights }),
+		serialize: ({ rights }) => stringifyConfig(container.configCodec, RecordPermissionConfigSerializer.serialize({ rights })),
 		getStorage: () => container.recordPermissionStorage.get()
 	});
 }
@@ -6213,14 +6061,14 @@ const ReportConfigSerializer = { serialize: (config) => {
 	const reports = {};
 	for (const [name, reportConfig] of Object.entries(config.reports)) reports[name] = serializeReportConfig(reportConfig);
 	serialized.reports = reports;
-	return serializeToYaml(serialized);
+	return serialized;
 } };
 //#endregion
 //#region src/core/application/report/captureReport.ts
 async function captureReport({ container }) {
 	return captureFromConfig({
 		fetchRemote: () => container.reportConfigurator.getReports(),
-		serialize: ({ reports }) => ReportConfigSerializer.serialize({ reports }),
+		serialize: ({ reports }) => stringifyConfig(container.configCodec, ReportConfigSerializer.serialize({ reports })),
 		getStorage: () => container.reportStorage.get()
 	});
 }
@@ -6233,14 +6081,10 @@ async function saveReport({ container, input }) {
 //#region src/core/domain/seedData/services/seedSerializer.ts
 const SeedSerializer = { serialize: (seedData) => {
 	const records = seedData.records.map((record) => ({ ...record }));
-	return stringify(seedData.key !== null ? {
+	return seedData.key !== null ? {
 		key: seedData.key,
 		records
-	} : { records }, {
-		lineWidth: 0,
-		defaultKeyType: "PLAIN",
-		defaultStringType: "PLAIN"
-	});
+	} : { records };
 } };
 //#endregion
 //#region src/core/domain/seedData/valueObject.ts
@@ -6253,10 +6097,10 @@ const UpsertKey = { create: (key) => {
 async function captureSeed({ container, input }) {
 	const key = input.keyField ? UpsertKey.create(input.keyField) : null;
 	const records = (await container.recordManager.getAllRecords()).map(({ record }) => record);
-	const seedText = SeedSerializer.serialize({
+	const seedText = stringifyConfig(container.configCodec, SeedSerializer.serialize({
 		key,
 		records
-	});
+	}));
 	const existing = await container.seedStorage.get();
 	return {
 		seedText,
@@ -6290,14 +6134,14 @@ function serializeViewConfig(config) {
 const ViewConfigSerializer = { serialize: (config) => {
 	const serialized = {};
 	for (const [name, viewConfig] of Object.entries(config.views)) serialized[name] = serializeViewConfig(viewConfig);
-	return serializeToYaml({ views: serialized });
+	return { views: serialized };
 } };
 //#endregion
 //#region src/core/application/view/captureView.ts
 async function captureView({ container }) {
 	return captureFromConfig({
 		fetchRemote: () => container.viewConfigurator.getViews(),
-		serialize: ({ views }) => ViewConfigSerializer.serialize({ views }),
+		serialize: ({ views }) => stringifyConfig(container.configCodec, ViewConfigSerializer.serialize({ views })),
 		getStorage: () => container.viewStorage.get()
 	});
 }
@@ -6481,7 +6325,7 @@ function deduplicateAppName(baseName, usedNames) {
 		startCounter: 2
 	}));
 }
-function generateProjectConfig(input) {
+function generateProjectConfig(input, codec) {
 	const apps = {};
 	const usedNames = /* @__PURE__ */ new Set();
 	for (const app of input.apps) {
@@ -6491,11 +6335,11 @@ function generateProjectConfig(input) {
 			files: buildAppFilePaths(name, input.baseDir)
 		};
 	}
-	return stringify({
+	return stringifyConfig(codec, {
 		domain: input.domain,
 		...input.guestSpaceId !== void 0 ? { guestSpaceId: input.guestSpaceId } : {},
 		apps
-	}, { lineWidth: 0 });
+	});
 }
 //#endregion
 //#region src/cli/commands/init.ts
@@ -6578,7 +6422,7 @@ var init_default = define({
 				domain: kintoneDomain,
 				guestSpaceId,
 				baseDir: output
-			});
+			}, configCodec);
 			if (dryRun) {
 				p.log.info(pc.dim("(dry-run mode - no files will be written)"));
 				p.log.step(`\nConfig file: ${pc.cyan(configPath)}`);
@@ -6732,12 +6576,8 @@ function parseReminderConfig(raw) {
 		notifications
 	};
 }
-const NotificationConfigParser = { parse: (rawText) => {
-	const obj = parseYamlConfig(rawText, {
-		emptyConfigText: NotificationErrorCode.NtEmptyConfigText,
-		invalidConfigYaml: NotificationErrorCode.NtInvalidConfigYaml,
-		invalidConfigStructure: NotificationErrorCode.NtInvalidConfigStructure
-	}, "Notification");
+const NotificationConfigParser = { parse: (parsed) => {
+	const obj = validateParsedConfig(parsed, NotificationErrorCode.NtInvalidConfigStructure, "Notification");
 	const config = {};
 	if (obj.general !== void 0) config.general = parseGeneralConfig(obj.general);
 	if (obj.perRecord !== void 0) config.perRecord = parsePerRecordConfig(obj.perRecord);
@@ -6746,8 +6586,9 @@ const NotificationConfigParser = { parse: (rawText) => {
 } };
 //#endregion
 //#region src/core/application/notification/parseConfig.ts
-function parseNotificationConfigText(rawText) {
-	return wrapBusinessRuleError(() => NotificationConfigParser.parse(rawText));
+function parseNotificationConfigText(codec, rawText) {
+	const parsed = parseConfigText(codec, rawText, "Notification");
+	return wrapBusinessRuleError(() => NotificationConfigParser.parse(parsed));
 }
 //#endregion
 //#region src/core/application/notification/applyNotification.ts
@@ -6763,7 +6604,7 @@ function parseNotificationConfigText(rawText) {
 async function applyNotification({ container }) {
 	const result = await container.notificationStorage.get();
 	if (!result.exists) throw new ValidationError(ValidationErrorCode.InvalidInput, "Notification config file not found");
-	const config = parseNotificationConfigText(result.content);
+	const config = parseNotificationConfigText(container.configCodec, result.content);
 	if (config.general !== void 0) {
 		const currentGeneral = await container.notificationConfigurator.getGeneralNotifications();
 		await container.notificationConfigurator.updateGeneralNotifications({
@@ -6811,91 +6652,32 @@ const { resolveFilePath: resolveNotificationFilePath, resolveContainerConfig: re
 });
 //#endregion
 //#region src/cli/commands/notification/apply.ts
-async function runNotification(config) {
-	const container = createNotificationCliContainer(config);
-	const s = p.spinner();
-	s.start("Applying notification settings...");
-	await applyNotification({ container });
-	s.stop("Notification settings applied.");
-	p.log.success("Notification settings applied successfully.");
-	return container;
-}
-var apply_default$7 = define({
-	name: "apply",
+var apply_default$7 = createApplyCommand({
 	description: "Apply notification settings from YAML to kintone app",
-	args: {
-		...notificationArgs,
-		...confirmArgs
-	},
-	run: async (ctx) => {
-		try {
-			const values = ctx.values;
-			const skipConfirm = values.yes === true;
-			await routeMultiApp(values, {
-				singleLegacy: async () => {
-					await confirmAndDeploy([await runNotification(resolveNotificationContainerConfig(values))], skipConfirm);
-				},
-				singleApp: async (app, projectConfig) => {
-					await confirmAndDeploy([await runNotification(resolveNotificationAppContainerConfig(app, projectConfig, values))], skipConfirm);
-				},
-				multiApp: async (plan, projectConfig) => {
-					const containers = [];
-					await runMultiAppWithHeaders(plan, async (app) => {
-						const container = await runNotification(resolveNotificationAppContainerConfig(app, projectConfig, values));
-						containers.push({
-							appDeployer: container.appDeployer,
-							appName: app.name
-						});
-					});
-					await confirmAndDeploy(containers, skipConfirm);
-				}
-			});
-		} catch (error) {
-			handleCliError(error);
-		}
-	}
+	args: notificationArgs,
+	spinnerMessage: "Applying notification settings...",
+	spinnerStopMessage: "Notification settings applied.",
+	successMessage: "Notification settings applied successfully.",
+	createContainer: createNotificationCliContainer,
+	applyFn: applyNotification,
+	resolveContainerConfig: resolveNotificationContainerConfig,
+	resolveAppContainerConfig: resolveNotificationAppContainerConfig
 });
 //#endregion
 //#region src/cli/commands/notification/capture.ts
-async function runCaptureNotification(config) {
-	const container = createNotificationCliContainer(config);
-	const s = p.spinner();
-	s.start("Capturing notification settings...");
-	const result = await captureNotification({ container });
-	s.stop("Notification settings captured.");
-	await saveNotification({
-		container,
-		input: { configText: result.configText }
-	});
-	p.log.success(`Notification settings saved to: ${pc.cyan(config.notificationFilePath)}`);
-	if (result.hasExistingConfig) p.log.warn("Existing notification file was overwritten.");
-}
-var capture_default$8 = define({
-	name: "capture",
+var capture_default$8 = createCaptureCommand({
 	description: "Capture current notification settings from kintone app to file",
 	args: notificationArgs,
-	run: async (ctx) => {
-		try {
-			const values = ctx.values;
-			await routeMultiApp(values, {
-				singleLegacy: async () => {
-					await runCaptureNotification(resolveNotificationContainerConfig(values));
-				},
-				singleApp: async (app, projectConfig) => {
-					await runCaptureNotification(resolveNotificationAppContainerConfig(app, projectConfig, values));
-				},
-				multiApp: async (plan, projectConfig) => {
-					await runMultiAppWithFailCheck(plan, async (app) => {
-						const config = resolveNotificationAppContainerConfig(app, projectConfig, values);
-						printAppHeader(app.name, app.appId);
-						await runCaptureNotification(config);
-					}, "All notification captures completed successfully.");
-				}
-			});
-		} catch (error) {
-			handleCliError(error);
-		}
-	}
+	spinnerMessage: "Capturing notification settings...",
+	spinnerStopMessage: "Notification settings captured.",
+	domainLabel: "Notification settings",
+	multiAppSuccessMessage: "All notification captures completed successfully.",
+	createContainer: createNotificationCliContainer,
+	captureFn: captureNotification,
+	saveFn: saveNotification,
+	getConfigFilePath: (config) => config.notificationFilePath,
+	resolveContainerConfig: resolveNotificationContainerConfig,
+	resolveAppContainerConfig: resolveNotificationAppContainerConfig
 });
 //#endregion
 //#region src/lib/groupByKey.ts
@@ -7112,7 +6894,7 @@ async function detectNotificationDiff({ container }) {
 		container.notificationConfigurator.getReminderNotifications()
 	]);
 	if (!storageResult.exists) throw new ValidationError(ValidationErrorCode.InvalidInput, "Notification config file not found");
-	const localConfig = parseNotificationConfigText(storageResult.content);
+	const localConfig = parseNotificationConfigText(container.configCodec, storageResult.content);
 	const remoteConfig = {
 		general: {
 			notifyToCommenter: generalResult.notifyToCommenter,
@@ -7160,12 +6942,8 @@ function parsePluginEntry(raw, index) {
 		enabled: typeof raw.enabled === "boolean" ? raw.enabled : true
 	};
 }
-const PluginConfigParser = { parse: (rawText) => {
-	const obj = parseYamlConfig(rawText, {
-		emptyConfigText: PluginErrorCode.PlEmptyConfigText,
-		invalidConfigYaml: PluginErrorCode.PlInvalidConfigYaml,
-		invalidConfigStructure: PluginErrorCode.PlInvalidConfigStructure
-	}, "Plugin");
+const PluginConfigParser = { parse: (parsed) => {
+	const obj = validateParsedConfig(parsed, PluginErrorCode.PlInvalidConfigStructure, "Plugin");
 	if (!Array.isArray(obj.plugins)) throw new BusinessRuleError(PluginErrorCode.PlInvalidConfigStructure, "Config must have a \"plugins\" array");
 	const plugins = obj.plugins.map((item, i) => parsePluginEntry(item, i));
 	const seenIds = /* @__PURE__ */ new Set();
@@ -7177,15 +6955,16 @@ const PluginConfigParser = { parse: (rawText) => {
 } };
 //#endregion
 //#region src/core/application/plugin/parseConfig.ts
-function parsePluginConfigText(rawText) {
-	return wrapBusinessRuleError(() => PluginConfigParser.parse(rawText));
+function parsePluginConfigText(codec, rawText) {
+	const parsed = parseConfigText(codec, rawText, "Plugin");
+	return wrapBusinessRuleError(() => PluginConfigParser.parse(parsed));
 }
 //#endregion
 //#region src/core/application/plugin/applyPlugin.ts
 async function applyPlugin({ container }) {
 	const result = await container.pluginStorage.get();
 	if (!result.exists) throw new ValidationError(ValidationErrorCode.InvalidInput, "Plugin config file not found");
-	const config = parsePluginConfigText(result.content);
+	const config = parsePluginConfigText(container.configCodec, result.content);
 	const current = await container.pluginConfigurator.getPlugins();
 	const currentIds = new Set(current.plugins.map((p) => p.id));
 	const missingIds = config.plugins.map((p) => p.id).filter((id) => !currentIds.has(id));
@@ -7217,91 +6996,32 @@ const { resolveFilePath: resolvePluginFilePath, resolveContainerConfig: resolveP
 });
 //#endregion
 //#region src/cli/commands/plugin/apply.ts
-async function runPlugin(config) {
-	const container = createPluginCliContainer(config);
-	const s = p.spinner();
-	s.start("Applying plugins...");
-	await applyPlugin({ container });
-	s.stop("Plugins applied.");
-	p.log.success("Plugins applied successfully.");
-	return container;
-}
-var apply_default$6 = define({
-	name: "apply",
+var apply_default$6 = createApplyCommand({
 	description: "Apply plugins from YAML to kintone app",
-	args: {
-		...pluginArgs,
-		...confirmArgs
-	},
-	run: async (ctx) => {
-		try {
-			const values = ctx.values;
-			const skipConfirm = values.yes === true;
-			await routeMultiApp(values, {
-				singleLegacy: async () => {
-					await confirmAndDeploy([await runPlugin(resolvePluginContainerConfig(values))], skipConfirm);
-				},
-				singleApp: async (app, projectConfig) => {
-					await confirmAndDeploy([await runPlugin(resolvePluginAppContainerConfig(app, projectConfig, values))], skipConfirm);
-				},
-				multiApp: async (plan, projectConfig) => {
-					const containers = [];
-					await runMultiAppWithHeaders(plan, async (app) => {
-						const container = await runPlugin(resolvePluginAppContainerConfig(app, projectConfig, values));
-						containers.push({
-							appDeployer: container.appDeployer,
-							appName: app.name
-						});
-					});
-					await confirmAndDeploy(containers, skipConfirm);
-				}
-			});
-		} catch (error) {
-			handleCliError(error);
-		}
-	}
+	args: pluginArgs,
+	spinnerMessage: "Applying plugins...",
+	spinnerStopMessage: "Plugins applied.",
+	successMessage: "Plugins applied successfully.",
+	createContainer: createPluginCliContainer,
+	applyFn: applyPlugin,
+	resolveContainerConfig: resolvePluginContainerConfig,
+	resolveAppContainerConfig: resolvePluginAppContainerConfig
 });
 //#endregion
 //#region src/cli/commands/plugin/capture.ts
-async function runCapturePlugin(config) {
-	const container = createPluginCliContainer(config);
-	const s = p.spinner();
-	s.start("Capturing plugins...");
-	const result = await capturePlugin({ container });
-	s.stop("Plugins captured.");
-	await savePlugin({
-		container,
-		input: { configText: result.configText }
-	});
-	p.log.success(`Plugins saved to: ${pc.cyan(config.pluginFilePath)}`);
-	if (result.hasExistingConfig) p.log.warn("Existing plugin file was overwritten.");
-}
-var capture_default$7 = define({
-	name: "capture",
+var capture_default$7 = createCaptureCommand({
 	description: "Capture current plugins from kintone app to file",
 	args: pluginArgs,
-	run: async (ctx) => {
-		try {
-			const values = ctx.values;
-			await routeMultiApp(values, {
-				singleLegacy: async () => {
-					await runCapturePlugin(resolvePluginContainerConfig(values));
-				},
-				singleApp: async (app, projectConfig) => {
-					await runCapturePlugin(resolvePluginAppContainerConfig(app, projectConfig, values));
-				},
-				multiApp: async (plan, projectConfig) => {
-					await runMultiAppWithFailCheck(plan, async (app) => {
-						const config = resolvePluginAppContainerConfig(app, projectConfig, values);
-						printAppHeader(app.name, app.appId);
-						await runCapturePlugin(config);
-					}, "All plugin captures completed successfully.");
-				}
-			});
-		} catch (error) {
-			handleCliError(error);
-		}
-	}
+	spinnerMessage: "Capturing plugins...",
+	spinnerStopMessage: "Plugins captured.",
+	domainLabel: "Plugins",
+	multiAppSuccessMessage: "All plugin captures completed successfully.",
+	createContainer: createPluginCliContainer,
+	captureFn: capturePlugin,
+	saveFn: savePlugin,
+	getConfigFilePath: (config) => config.pluginFilePath,
+	resolveContainerConfig: resolvePluginContainerConfig,
+	resolveAppContainerConfig: resolvePluginAppContainerConfig
 });
 //#endregion
 //#region src/core/domain/plugin/services/diffDetector.ts
@@ -7340,7 +7060,7 @@ async function detectPluginDiff({ container }) {
 	return detectDiffFromConfig({
 		getStorage: () => container.pluginStorage.get(),
 		fetchRemote: () => container.pluginConfigurator.getPlugins(),
-		parseConfig: parsePluginConfigText,
+		parseConfig: (content) => parsePluginConfigText(container.configCodec, content),
 		detect: (local, remote) => PluginDiffDetector.detect(local, { plugins: remote.plugins }),
 		notFoundMessage: "Plugin config file not found"
 	});
@@ -7438,19 +7158,15 @@ function parseAction(raw, index) {
 	};
 	return result;
 }
-const ProcessManagementConfigParser = { parse: (rawText) => {
-	const parsed = parseYamlConfig(rawText, {
-		emptyConfigText: ProcessManagementErrorCode.PmEmptyConfigText,
-		invalidConfigYaml: ProcessManagementErrorCode.PmInvalidConfigYaml,
-		invalidConfigStructure: ProcessManagementErrorCode.PmInvalidConfigStructure
-	}, "Process management");
-	const enable = parsed.enable !== void 0 && parsed.enable !== null ? parseStrictBoolean(parsed.enable, "enable", "Config", ProcessManagementErrorCode.PmInvalidBooleanField) : false;
-	if (parsed.states !== void 0 && parsed.states !== null && !isRecord(parsed.states)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, "Config \"states\" must be an object (map of state name to state definition)");
-	const rawStates = isRecord(parsed.states) ? parsed.states : {};
+const ProcessManagementConfigParser = { parse: (parsed) => {
+	const obj = validateParsedConfig(parsed, ProcessManagementErrorCode.PmInvalidConfigStructure, "Process management");
+	const enable = obj.enable !== void 0 && obj.enable !== null ? parseStrictBoolean(obj.enable, "enable", "Config", ProcessManagementErrorCode.PmInvalidBooleanField) : false;
+	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(parsed.actions) && parsed.actions !== void 0) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, "Config \"actions\" must be an array");
-	const actions = (Array.isArray(parsed.actions) ? parsed.actions : []).map((item, i) => parseAction(item, i));
+	if (!Array.isArray(obj.actions) && obj.actions !== void 0) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, "Config \"actions\" must be an array");
+	const actions = (Array.isArray(obj.actions) ? obj.actions : []).map((item, i) => parseAction(item, i));
 	const actionNames = /* @__PURE__ */ new Set();
 	for (const action of actions) {
 		if (actionNames.has(action.name)) throw new BusinessRuleError(ProcessManagementErrorCode.PmDuplicateActionName, `Duplicate action name: "${action.name}"`);
@@ -7469,15 +7185,16 @@ const ProcessManagementConfigParser = { parse: (rawText) => {
 } };
 //#endregion
 //#region src/core/application/processManagement/parseConfig.ts
-function parseProcessManagementConfigText(rawText) {
-	return wrapBusinessRuleError(() => ProcessManagementConfigParser.parse(rawText));
+function parseProcessManagementConfigText(codec, rawText) {
+	const parsed = parseConfigText(codec, rawText, "Process management");
+	return wrapBusinessRuleError(() => ProcessManagementConfigParser.parse(parsed));
 }
 //#endregion
 //#region src/core/application/processManagement/applyProcessManagement.ts
 async function applyProcessManagement({ container }) {
 	const result = await container.processManagementStorage.get();
 	if (!result.exists) throw new ValidationError(ValidationErrorCode.InvalidInput, "Process management config file not found");
-	const config = parseProcessManagementConfigText(result.content);
+	const config = parseProcessManagementConfigText(container.configCodec, result.content);
 	const current = await container.processManagementConfigurator.getProcessManagement();
 	const enableChanged = current.config.enable !== config.enable;
 	await container.processManagementConfigurator.updateProcessManagement({
@@ -7512,92 +7229,35 @@ const { resolveFilePath: resolveProcessFilePath, resolveContainerConfig: resolve
 });
 //#endregion
 //#region src/cli/commands/process/apply.ts
-async function runProcessApply(config) {
-	const container = createProcessManagementCliContainer(config);
-	const s = p.spinner();
-	s.start("Applying process management settings...");
-	const result = await applyProcessManagement({ container });
-	s.stop("Process management settings applied.");
-	if (result.enableChanged) p.log.warn(result.newEnable ? "Process management will be ENABLED. This activates workflow processing for this app." : "Process management will be DISABLED. This deactivates workflow processing for this app.");
-	p.log.success("Process management settings applied successfully.");
-	return container;
-}
-var apply_default$5 = define({
-	name: "apply",
+var apply_default$5 = createApplyCommand({
 	description: "Apply process management settings from YAML to kintone app",
-	args: {
-		...processArgs,
-		...confirmArgs
+	args: processArgs,
+	spinnerMessage: "Applying process management settings...",
+	spinnerStopMessage: "Process management settings applied.",
+	successMessage: "Process management settings applied successfully.",
+	createContainer: createProcessManagementCliContainer,
+	applyFn: applyProcessManagement,
+	onResult: (result) => {
+		if (result.enableChanged) p.log.warn(result.newEnable ? "Process management will be ENABLED. This activates workflow processing for this app." : "Process management will be DISABLED. This deactivates workflow processing for this app.");
 	},
-	run: async (ctx) => {
-		try {
-			const values = ctx.values;
-			const skipConfirm = values.yes === true;
-			await routeMultiApp(values, {
-				singleLegacy: async () => {
-					await confirmAndDeploy([await runProcessApply(resolveProcessContainerConfig(values))], skipConfirm);
-				},
-				singleApp: async (app, projectConfig) => {
-					await confirmAndDeploy([await runProcessApply(resolveProcessAppContainerConfig(app, projectConfig, values))], skipConfirm);
-				},
-				multiApp: async (plan, projectConfig) => {
-					const containers = [];
-					await runMultiAppWithHeaders(plan, async (app) => {
-						const container = await runProcessApply(resolveProcessAppContainerConfig(app, projectConfig, values));
-						containers.push({
-							appDeployer: container.appDeployer,
-							appName: app.name
-						});
-					});
-					await confirmAndDeploy(containers, skipConfirm);
-				}
-			});
-		} catch (error) {
-			handleCliError(error);
-		}
-	}
+	resolveContainerConfig: resolveProcessContainerConfig,
+	resolveAppContainerConfig: resolveProcessAppContainerConfig
 });
 //#endregion
 //#region src/cli/commands/process/capture.ts
-async function runCaptureProcess(config) {
-	const container = createProcessManagementCliContainer(config);
-	const s = p.spinner();
-	s.start("Capturing process management settings...");
-	const result = await captureProcessManagement({ container });
-	s.stop("Process management settings captured.");
-	await saveProcessManagement({
-		container,
-		input: { configText: result.configText }
-	});
-	p.log.success(`Process management settings saved to: ${pc.cyan(config.processFilePath)}`);
-	if (result.hasExistingConfig) p.log.warn("Existing process management file was overwritten.");
-}
-var capture_default$6 = define({
-	name: "capture",
+var capture_default$6 = createCaptureCommand({
 	description: "Capture current process management settings from kintone app to file",
 	args: processArgs,
-	run: async (ctx) => {
-		try {
-			const values = ctx.values;
-			await routeMultiApp(values, {
-				singleLegacy: async () => {
-					await runCaptureProcess(resolveProcessContainerConfig(values));
-				},
-				singleApp: async (app, projectConfig) => {
-					await runCaptureProcess(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 runCaptureProcess(config);
-					}, "All process management captures completed successfully.");
-				}
-			});
-		} catch (error) {
-			handleCliError(error);
-		}
-	}
+	spinnerMessage: "Capturing process management settings...",
+	spinnerStopMessage: "Process management settings captured.",
+	domainLabel: "Process management settings",
+	multiAppSuccessMessage: "All process management captures completed successfully.",
+	createContainer: createProcessManagementCliContainer,
+	captureFn: captureProcessManagement,
+	saveFn: saveProcessManagement,
+	getConfigFilePath: (config) => config.processFilePath,
+	resolveContainerConfig: resolveProcessContainerConfig,
+	resolveAppContainerConfig: resolveProcessAppContainerConfig
 });
 //#endregion
 //#region src/core/domain/processManagement/services/diffDetector.ts
@@ -7626,14 +7286,7 @@ function compareActions(localAction, remoteAction) {
 	if (!isExecutableUserEqual(localAction.executableUser, remoteAction.executableUser)) diffs.push("executableUser changed");
 	return diffs;
 }
-function compareConfigs$1(local, remote) {
-	const entries = [];
-	if (local.enable !== remote.enable) entries.push({
-		type: "modified",
-		category: "enable",
-		name: "enable",
-		details: `${String(remote.enable)} -> ${String(local.enable)}`
-	});
+function compareStates(local, remote, entries) {
 	const localStateNames = new Set(Object.keys(local.states));
 	const remoteStateNames = new Set(Object.keys(remote.states));
 	for (const name of localStateNames) if (!remoteStateNames.has(name)) entries.push({
@@ -7662,6 +7315,8 @@ function compareConfigs$1(local, remote) {
 		name,
 		details: `assignee: ${remote.states[name].assignee.type}`
 	});
+}
+function compareActionEntries(local, remote, entries) {
 	const localActionMap = new Map(local.actions.map((a) => [a.name, a]));
 	const remoteActionMap = new Map(remote.actions.map((a) => [a.name, a]));
 	for (const [name, localAction] of localActionMap) {
@@ -7688,6 +7343,17 @@ function compareConfigs$1(local, remote) {
 		name,
 		details: `${remoteAction.from} -> ${remoteAction.to}`
 	});
+}
+function compareConfigs$1(local, remote) {
+	const entries = [];
+	if (local.enable !== remote.enable) entries.push({
+		type: "modified",
+		category: "enable",
+		name: "enable",
+		details: `${String(remote.enable)} -> ${String(local.enable)}`
+	});
+	compareStates(local, remote, entries);
+	compareActionEntries(local, remote, entries);
 	return entries;
 }
 const ProcessManagementDiffDetector = { detect: (local, remote) => {
@@ -7699,7 +7365,7 @@ async function detectProcessManagementDiff({ container }) {
 	return detectDiffFromConfig({
 		getStorage: () => container.processManagementStorage.get(),
 		fetchRemote: () => container.processManagementConfigurator.getProcessManagement(),
-		parseConfig: parseProcessManagementConfigText,
+		parseConfig: (content) => parseProcessManagementConfigText(container.configCodec, content),
 		detect: (local, remote) => ProcessManagementDiffDetector.detect(local, remote.config),
 		notFoundMessage: "Process management config file not found"
 	});
@@ -7762,14 +7428,10 @@ function parseRecordRight(raw, index) {
 		entities
 	};
 }
-const RecordPermissionConfigParser = { parse: (rawText) => {
-	const parsed = parseYamlConfig(rawText, {
-		emptyConfigText: RecordPermissionErrorCode.RpEmptyConfigText,
-		invalidConfigYaml: RecordPermissionErrorCode.RpInvalidConfigYaml,
-		invalidConfigStructure: RecordPermissionErrorCode.RpInvalidConfigStructure
-	}, "Record permission");
-	if (!Array.isArray(parsed.rights)) throw new BusinessRuleError(RecordPermissionErrorCode.RpInvalidConfigStructure, "Config must have a \"rights\" array");
-	const rights = parsed.rights.map((item, i) => parseRecordRight(item, i));
+const RecordPermissionConfigParser = { parse: (parsed) => {
+	const obj = validateParsedConfig(parsed, RecordPermissionErrorCode.RpInvalidConfigStructure, "Record permission");
+	if (!Array.isArray(obj.rights)) throw new BusinessRuleError(RecordPermissionErrorCode.RpInvalidConfigStructure, "Config must have a \"rights\" array");
+	const rights = obj.rights.map((item, i) => parseRecordRight(item, i));
 	for (const right of rights) {
 		const seenKeys = /* @__PURE__ */ new Set();
 		for (const re of right.entities) {
@@ -7782,15 +7444,16 @@ const RecordPermissionConfigParser = { parse: (rawText) => {
 } };
 //#endregion
 //#region src/core/application/recordPermission/parseConfig.ts
-function parseRecordPermissionConfigText(rawText) {
-	return wrapBusinessRuleError(() => RecordPermissionConfigParser.parse(rawText));
+function parseRecordPermissionConfigText(codec, rawText) {
+	const parsed = parseConfigText(codec, rawText, "Record permission");
+	return wrapBusinessRuleError(() => RecordPermissionConfigParser.parse(parsed));
 }
 //#endregion
 //#region src/core/application/recordPermission/applyRecordPermission.ts
 async function applyRecordPermission({ container }) {
 	await applyFromConfig({
 		getStorage: () => container.recordPermissionStorage.get(),
-		parseConfig: parseRecordPermissionConfigText,
+		parseConfig: (content) => parseRecordPermissionConfigText(container.configCodec, content),
 		fetchRemote: () => container.recordPermissionConfigurator.getRecordPermissions(),
 		update: async (config, current) => {
 			await container.recordPermissionConfigurator.updateRecordPermissions({
@@ -7824,91 +7487,32 @@ const { resolveFilePath: resolveRecordAclFilePath, resolveContainerConfig: resol
 });
 //#endregion
 //#region src/cli/commands/record-acl/apply.ts
-async function runRecordAcl(config) {
-	const container = createRecordPermissionCliContainer(config);
-	const s = p.spinner();
-	s.start("Applying record access permissions...");
-	await applyRecordPermission({ container });
-	s.stop("Record access permissions applied.");
-	p.log.success("Record access permissions applied successfully.");
-	return container;
-}
-var apply_default$4 = define({
-	name: "apply",
+var apply_default$4 = createApplyCommand({
 	description: "Apply record access permissions from YAML to kintone app",
-	args: {
-		...recordAclArgs,
-		...confirmArgs
-	},
-	run: async (ctx) => {
-		try {
-			const values = ctx.values;
-			const skipConfirm = values.yes === true;
-			await routeMultiApp(values, {
-				singleLegacy: async () => {
-					await confirmAndDeploy([await runRecordAcl(resolveRecordAclContainerConfig(values))], skipConfirm);
-				},
-				singleApp: async (app, projectConfig) => {
-					await confirmAndDeploy([await runRecordAcl(resolveRecordAclAppContainerConfig(app, projectConfig, values))], skipConfirm);
-				},
-				multiApp: async (plan, projectConfig) => {
-					const containers = [];
-					await runMultiAppWithHeaders(plan, async (app) => {
-						const container = await runRecordAcl(resolveRecordAclAppContainerConfig(app, projectConfig, values));
-						containers.push({
-							appDeployer: container.appDeployer,
-							appName: app.name
-						});
-					});
-					await confirmAndDeploy(containers, skipConfirm);
-				}
-			});
-		} catch (error) {
-			handleCliError(error);
-		}
-	}
+	args: recordAclArgs,
+	spinnerMessage: "Applying record access permissions...",
+	spinnerStopMessage: "Record access permissions applied.",
+	successMessage: "Record access permissions applied successfully.",
+	createContainer: createRecordPermissionCliContainer,
+	applyFn: applyRecordPermission,
+	resolveContainerConfig: resolveRecordAclContainerConfig,
+	resolveAppContainerConfig: resolveRecordAclAppContainerConfig
 });
 //#endregion
 //#region src/cli/commands/record-acl/capture.ts
-async function runCaptureRecordAcl(config) {
-	const container = createRecordPermissionCliContainer(config);
-	const s = p.spinner();
-	s.start("Capturing record access permissions...");
-	const result = await captureRecordPermission({ container });
-	s.stop("Record access permissions captured.");
-	await saveRecordPermission({
-		container,
-		input: { configText: result.configText }
-	});
-	p.log.success(`Record ACL saved to: ${pc.cyan(config.recordAclFilePath)}`);
-	if (result.hasExistingConfig) p.log.warn("Existing record ACL file was overwritten.");
-}
-var capture_default$5 = define({
-	name: "capture",
+var capture_default$5 = createCaptureCommand({
 	description: "Capture current record access permissions from kintone app to file",
 	args: recordAclArgs,
-	run: async (ctx) => {
-		try {
-			const values = ctx.values;
-			await routeMultiApp(values, {
-				singleLegacy: async () => {
-					await runCaptureRecordAcl(resolveRecordAclContainerConfig(values));
-				},
-				singleApp: async (app, projectConfig) => {
-					await runCaptureRecordAcl(resolveRecordAclAppContainerConfig(app, projectConfig, values));
-				},
-				multiApp: async (plan, projectConfig) => {
-					await runMultiAppWithFailCheck(plan, async (app) => {
-						const config = resolveRecordAclAppContainerConfig(app, projectConfig, values);
-						printAppHeader(app.name, app.appId);
-						await runCaptureRecordAcl(config);
-					}, "All record ACL captures completed successfully.");
-				}
-			});
-		} catch (error) {
-			handleCliError(error);
-		}
-	}
+	spinnerMessage: "Capturing record access permissions...",
+	spinnerStopMessage: "Record access permissions captured.",
+	domainLabel: "Record ACL",
+	multiAppSuccessMessage: "All record ACL captures completed successfully.",
+	createContainer: createRecordPermissionCliContainer,
+	captureFn: captureRecordPermission,
+	saveFn: saveRecordPermission,
+	getConfigFilePath: (config) => config.recordAclFilePath,
+	resolveContainerConfig: resolveRecordAclContainerConfig,
+	resolveAppContainerConfig: resolveRecordAclAppContainerConfig
 });
 //#endregion
 //#region src/core/domain/recordPermission/services/diffDetector.ts
@@ -7940,40 +7544,38 @@ function describeRight(right) {
 	});
 	return perEntity.length > 0 ? perEntity.join(", ") : "no entities";
 }
+function compareRightsForFilter(filterCond, localRights, remoteRights, entries) {
+	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 (!isRightEqual(localRight, remoteRight)) {
+				const detail = localRight.entities.length !== remoteRight.entities.length ? `entities: ${remoteRight.entities.length} -> ${localRight.entities.length}` : "entities changed";
+				entries.push({
+					type: "modified",
+					filterCond,
+					details: detail
+				});
+			}
+		}
+	}
+}
 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 (!isRightEqual(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, localRights] of localMulti) compareRightsForFilter(filterCond, localRights, remoteMulti.get(filterCond) ?? [], entries);
 	for (const [filterCond, remoteRights] of remoteMulti) if (!localMulti.has(filterCond)) for (const remoteRight of remoteRights) entries.push({
 		type: "deleted",
 		filterCond,
@@ -7987,7 +7589,7 @@ async function detectRecordPermissionDiff({ container }) {
 	return detectDiffFromConfig({
 		getStorage: () => container.recordPermissionStorage.get(),
 		fetchRemote: () => container.recordPermissionConfigurator.getRecordPermissions(),
-		parseConfig: parseRecordPermissionConfigText,
+		parseConfig: (content) => parseRecordPermissionConfigText(container.configCodec, content),
 		detect: (local, remote) => RecordPermissionDiffDetector.detect(local, { rights: remote.rights }),
 		notFoundMessage: "Record permission config file not found"
 	});
@@ -8051,45 +7653,48 @@ function parseSort(raw, index) {
 		order: raw.order
 	};
 }
+function parsePeriodMonth(raw) {
+	if (raw.month === void 0 || raw.month === null) return void 0;
+	const parsed = Number(raw.month);
+	if (!Number.isInteger(parsed) || parsed < 1 || parsed > 12) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `periodicReport.period has invalid month: ${String(raw.month)}. Must be an integer between 1 and 12`);
+	return parsed;
+}
+function parsePeriodPattern(raw) {
+	if (raw.pattern === void 0 || raw.pattern === null) return void 0;
+	if (typeof raw.pattern !== "string" || !isPeriodicReportPattern(raw.pattern)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `periodicReport.period has invalid pattern: ${String(raw.pattern)}. Must be JAN_APR_JUL_OCT, FEB_MAY_AUG_NOV, or MAR_JUN_SEP_DEC`);
+	return raw.pattern;
+}
+function parsePeriodDayOfMonth(raw) {
+	if (raw.dayOfMonth === void 0 || raw.dayOfMonth === null) return void 0;
+	if (raw.dayOfMonth === "END_OF_MONTH") return "END_OF_MONTH";
+	const parsed = Number(raw.dayOfMonth);
+	if (!Number.isInteger(parsed)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `periodicReport.period has invalid dayOfMonth: ${String(raw.dayOfMonth)}. Must be an integer or "END_OF_MONTH"`);
+	if (parsed < 1 || parsed > 31) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `periodicReport.period has out-of-range dayOfMonth: ${parsed}. Must be 1-31`);
+	return parsed;
+}
+function parsePeriodDayOfWeek(raw) {
+	if (raw.dayOfWeek === void 0 || raw.dayOfWeek === null) return void 0;
+	const dayStr = String(raw.dayOfWeek);
+	if (!isDayOfWeek(dayStr)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `periodicReport.period has invalid dayOfWeek: ${dayStr}. Must be SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, or SATURDAY`);
+	return dayStr;
+}
+function parsePeriodMinute(raw) {
+	if (raw.minute === void 0 || raw.minute === null) return void 0;
+	const parsed = Number(raw.minute);
+	if (!Number.isInteger(parsed) || parsed < 0 || parsed > 50 || parsed % 10 !== 0) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `periodicReport.period has invalid minute: ${String(raw.minute)}. Must be a multiple of 10 (0, 10, 20, 30, 40, 50)`);
+	return parsed;
+}
 function parsePeriodicReportPeriod(raw) {
 	if (!isRecord(raw)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, "periodicReport.period must be an object");
 	if (typeof raw.every !== "string" || !isPeriodicReportEvery(raw.every)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `periodicReport.period has invalid every: ${String(raw.every)}. Must be YEAR, QUARTER, MONTH, WEEK, DAY, or HOUR`);
-	const every = raw.every;
-	let month;
-	if (raw.month !== void 0 && raw.month !== null) {
-		const parsed = Number(raw.month);
-		if (!Number.isInteger(parsed) || parsed < 1 || parsed > 12) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `periodicReport.period has invalid month: ${String(raw.month)}. Must be an integer between 1 and 12`);
-		month = parsed;
-	}
-	let pattern;
-	if (raw.pattern !== void 0 && raw.pattern !== null) {
-		if (typeof raw.pattern !== "string" || !isPeriodicReportPattern(raw.pattern)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `periodicReport.period has invalid pattern: ${String(raw.pattern)}. Must be JAN_APR_JUL_OCT, FEB_MAY_AUG_NOV, or MAR_JUN_SEP_DEC`);
-		pattern = raw.pattern;
-	}
-	let dayOfMonth;
-	if (raw.dayOfMonth !== void 0 && raw.dayOfMonth !== null) if (raw.dayOfMonth === "END_OF_MONTH") dayOfMonth = "END_OF_MONTH";
-	else {
-		const parsed = Number(raw.dayOfMonth);
-		if (!Number.isInteger(parsed)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `periodicReport.period has invalid dayOfMonth: ${String(raw.dayOfMonth)}. Must be an integer or "END_OF_MONTH"`);
-		if (parsed < 1 || parsed > 31) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `periodicReport.period has out-of-range dayOfMonth: ${parsed}. Must be 1-31`);
-		dayOfMonth = parsed;
-	}
-	let time;
-	if (raw.time !== void 0 && raw.time !== null) time = String(raw.time);
-	let dayOfWeek;
-	if (raw.dayOfWeek !== void 0 && raw.dayOfWeek !== null) {
-		const dayStr = String(raw.dayOfWeek);
-		if (!isDayOfWeek(dayStr)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `periodicReport.period has invalid dayOfWeek: ${dayStr}. Must be SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, or SATURDAY`);
-		dayOfWeek = dayStr;
-	}
-	let minute;
-	if (raw.minute !== void 0 && raw.minute !== null) {
-		const parsed = Number(raw.minute);
-		if (!Number.isInteger(parsed) || parsed < 0 || parsed > 50 || parsed % 10 !== 0) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `periodicReport.period has invalid minute: ${String(raw.minute)}. Must be a multiple of 10 (0, 10, 20, 30, 40, 50)`);
-		minute = parsed;
-	}
+	const month = parsePeriodMonth(raw);
+	const pattern = parsePeriodPattern(raw);
+	const dayOfMonth = parsePeriodDayOfMonth(raw);
+	const time = raw.time !== void 0 && raw.time !== null ? String(raw.time) : void 0;
+	const dayOfWeek = parsePeriodDayOfWeek(raw);
+	const minute = parsePeriodMinute(raw);
 	return {
-		every,
+		every: raw.every,
 		...month !== void 0 ? { month } : {},
 		...pattern !== void 0 ? { pattern } : {},
 		...dayOfMonth !== void 0 ? { dayOfMonth } : {},
@@ -8107,6 +7712,11 @@ function parsePeriodicReport(raw) {
 		period: parsePeriodicReportPeriod(raw.period)
 	};
 }
+function parseOptionalArrayField(raw, fieldName, reportName, parseFn) {
+	const value = raw[fieldName];
+	if (value !== void 0 && !Array.isArray(value)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Report "${reportName}" has invalid ${fieldName}: must be an array`);
+	return Array.isArray(value) ? value.map((item, i) => parseFn(item, i)) : [];
+}
 function parseReportConfig(raw, reportName) {
 	if (reportName.length === 0) throw new BusinessRuleError(ReportErrorCode.RtEmptyReportName, "Report name (key) must not be empty");
 	if (!isRecord(raw)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Report "${reportName}" must be an object`);
@@ -8119,13 +7729,10 @@ function parseReportConfig(raw, reportName) {
 	const name = typeof raw.name === "string" && raw.name.length > 0 ? raw.name : reportName;
 	if (raw.index !== void 0 && raw.index !== null && (typeof raw.index !== "number" || !Number.isInteger(raw.index) || raw.index < 0)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Report "${reportName}" has invalid index: ${String(raw.index)}. Must be a non-negative integer`);
 	const index = typeof raw.index === "number" ? raw.index : 0;
-	if (raw.groups !== void 0 && !Array.isArray(raw.groups)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Report "${reportName}" has invalid groups: must be an array`);
-	const groups = Array.isArray(raw.groups) ? raw.groups.map((item, i) => parseGroup(item, i)) : [];
-	if (raw.aggregations !== void 0 && !Array.isArray(raw.aggregations)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Report "${reportName}" has invalid aggregations: must be an array`);
-	const aggregations = Array.isArray(raw.aggregations) ? raw.aggregations.map((item, i) => parseAggregation(item, i)) : [];
+	const groups = parseOptionalArrayField(raw, "groups", reportName, parseGroup);
+	const aggregations = parseOptionalArrayField(raw, "aggregations", reportName, parseAggregation);
 	const filterCond = typeof raw.filterCond === "string" ? raw.filterCond : "";
-	if (raw.sorts !== void 0 && !Array.isArray(raw.sorts)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Report "${reportName}" has invalid sorts: must be an array`);
-	const sorts = Array.isArray(raw.sorts) ? raw.sorts.map((item, i) => parseSort(item, i)) : [];
+	const sorts = parseOptionalArrayField(raw, "sorts", reportName, parseSort);
 	const result = {
 		chartType: raw.chartType,
 		...chartMode !== void 0 ? { chartMode } : {},
@@ -8142,12 +7749,8 @@ function parseReportConfig(raw, reportName) {
 	};
 	return result;
 }
-const ReportConfigParser = { parse: (rawText) => {
-	const obj = parseYamlConfig(rawText, {
-		emptyConfigText: ReportErrorCode.RtEmptyConfigText,
-		invalidConfigYaml: ReportErrorCode.RtInvalidConfigYaml,
-		invalidConfigStructure: ReportErrorCode.RtInvalidConfigStructure
-	}, "Report");
+const ReportConfigParser = { parse: (parsed) => {
+	const obj = validateParsedConfig(parsed, ReportErrorCode.RtInvalidConfigStructure, "Report");
 	if (!isRecord(obj.reports)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, "Config must have a \"reports\" object");
 	const rawReports = obj.reports;
 	const reports = {};
@@ -8156,15 +7759,16 @@ const ReportConfigParser = { parse: (rawText) => {
 } };
 //#endregion
 //#region src/core/application/report/parseConfig.ts
-function parseReportConfigText(rawText) {
-	return wrapBusinessRuleError(() => ReportConfigParser.parse(rawText));
+function parseReportConfigText(codec, rawText) {
+	const parsed = parseConfigText(codec, rawText, "Report");
+	return wrapBusinessRuleError(() => ReportConfigParser.parse(parsed));
 }
 //#endregion
 //#region src/core/application/report/applyReport.ts
 async function applyReport({ container }) {
 	await applyFromConfig({
 		getStorage: () => container.reportStorage.get(),
-		parseConfig: parseReportConfigText,
+		parseConfig: (content) => parseReportConfigText(container.configCodec, content),
 		fetchRemote: () => container.reportConfigurator.getReports(),
 		update: async (config, current) => {
 			await container.reportConfigurator.updateReports({
@@ -8198,91 +7802,32 @@ const { resolveFilePath: resolveReportFilePath, resolveContainerConfig: resolveR
 });
 //#endregion
 //#region src/cli/commands/report/apply.ts
-async function runReport(config) {
-	const container = createReportCliContainer(config);
-	const s = p.spinner();
-	s.start("Applying report settings...");
-	await applyReport({ container });
-	s.stop("Report settings applied.");
-	p.log.success("Report settings applied successfully.");
-	return container;
-}
-var apply_default$3 = define({
-	name: "apply",
+var apply_default$3 = createApplyCommand({
 	description: "Apply report settings from YAML to kintone app",
-	args: {
-		...reportArgs,
-		...confirmArgs
-	},
-	run: async (ctx) => {
-		try {
-			const values = ctx.values;
-			const skipConfirm = values.yes === true;
-			await routeMultiApp(values, {
-				singleLegacy: async () => {
-					await confirmAndDeploy([await runReport(resolveReportContainerConfig(values))], skipConfirm);
-				},
-				singleApp: async (app, projectConfig) => {
-					await confirmAndDeploy([await runReport(resolveReportAppContainerConfig(app, projectConfig, values))], skipConfirm);
-				},
-				multiApp: async (plan, projectConfig) => {
-					const containers = [];
-					await runMultiAppWithHeaders(plan, async (app) => {
-						const container = await runReport(resolveReportAppContainerConfig(app, projectConfig, values));
-						containers.push({
-							appDeployer: container.appDeployer,
-							appName: app.name
-						});
-					});
-					await confirmAndDeploy(containers, skipConfirm);
-				}
-			});
-		} catch (error) {
-			handleCliError(error);
-		}
-	}
+	args: reportArgs,
+	spinnerMessage: "Applying report settings...",
+	spinnerStopMessage: "Report settings applied.",
+	successMessage: "Report settings applied successfully.",
+	createContainer: createReportCliContainer,
+	applyFn: applyReport,
+	resolveContainerConfig: resolveReportContainerConfig,
+	resolveAppContainerConfig: resolveReportAppContainerConfig
 });
 //#endregion
 //#region src/cli/commands/report/capture.ts
-async function runCaptureReport(config) {
-	const container = createReportCliContainer(config);
-	const s = p.spinner();
-	s.start("Capturing report settings...");
-	const result = await captureReport({ container });
-	s.stop("Report settings captured.");
-	await saveReport({
-		container,
-		input: { configText: result.configText }
-	});
-	p.log.success(`Reports saved to: ${pc.cyan(config.reportFilePath)}`);
-	if (result.hasExistingConfig) p.log.warn("Existing report file was overwritten.");
-}
-var capture_default$4 = define({
-	name: "capture",
+var capture_default$4 = createCaptureCommand({
 	description: "Capture current report settings from kintone app to file",
 	args: reportArgs,
-	run: async (ctx) => {
-		try {
-			const values = ctx.values;
-			await routeMultiApp(values, {
-				singleLegacy: async () => {
-					await runCaptureReport(resolveReportContainerConfig(values));
-				},
-				singleApp: async (app, projectConfig) => {
-					await runCaptureReport(resolveReportAppContainerConfig(app, projectConfig, values));
-				},
-				multiApp: async (plan, projectConfig) => {
-					await runMultiAppWithFailCheck(plan, async (app) => {
-						const config = resolveReportAppContainerConfig(app, projectConfig, values);
-						printAppHeader(app.name, app.appId);
-						await runCaptureReport(config);
-					}, "All report captures completed successfully.");
-				}
-			});
-		} catch (error) {
-			handleCliError(error);
-		}
-	}
+	spinnerMessage: "Capturing report settings...",
+	spinnerStopMessage: "Report settings captured.",
+	domainLabel: "Reports",
+	multiAppSuccessMessage: "All report captures completed successfully.",
+	createContainer: createReportCliContainer,
+	captureFn: captureReport,
+	saveFn: saveReport,
+	getConfigFilePath: (config) => config.reportFilePath,
+	resolveContainerConfig: resolveReportContainerConfig,
+	resolveAppContainerConfig: resolveReportAppContainerConfig
 });
 //#endregion
 //#region src/core/domain/report/services/diffDetector.ts
@@ -8327,7 +7872,7 @@ async function detectReportDiff({ container }) {
 	return detectDiffFromConfig({
 		getStorage: () => container.reportStorage.get(),
 		fetchRemote: () => container.reportConfigurator.getReports(),
-		parseConfig: parseReportConfigText,
+		parseConfig: (content) => parseReportConfigText(container.configCodec, content),
 		detect: (local, remote) => ReportDiffDetector.detect(local, { reports: remote.reports }),
 		notFoundMessage: "Report config file not found"
 	});
@@ -8700,6 +8245,35 @@ function buildFieldDefinition(base, fieldType, properties) {
 		};
 	}
 }
+function parseReferenceTableField(raw, code, base) {
+	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(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));
+	const relatedApp = refTable.relatedApp;
+	const conditionField = String(condition.field ?? "");
+	const conditionRelatedField = String(condition.relatedField ?? "");
+	if (conditionField.length === 0) throw new BusinessRuleError(FormSchemaErrorCode.FsInvalidSchemaStructure, `Field "${code}" of type REFERENCE_TABLE must have a non-empty "referenceTable.condition.field"`);
+	if (conditionRelatedField.length === 0) throw new BusinessRuleError(FormSchemaErrorCode.FsInvalidSchemaStructure, `Field "${code}" of type REFERENCE_TABLE must have a non-empty "referenceTable.condition.relatedField"`);
+	return {
+		...base,
+		type: "REFERENCE_TABLE",
+		properties: { referenceTable: {
+			relatedApp: { app: String(relatedApp.app ?? "") },
+			condition: {
+				field: FieldCode.create(conditionField),
+				relatedField: FieldCode.create(conditionRelatedField)
+			},
+			...refTable.filterCond !== void 0 ? { filterCond: String(refTable.filterCond) } : {},
+			displayFields,
+			...refTable.sort !== void 0 ? { sort: String(refTable.sort) } : {},
+			...refTable.size !== void 0 ? { size: String(refTable.size) } : {}
+		} }
+	};
+}
 function parseFieldDefinitionFromFlat(raw) {
 	const code = String(raw.code);
 	const type = String(raw.type);
@@ -8724,35 +8298,7 @@ function parseFieldDefinitionFromFlat(raw) {
 			properties: { fields: subFields }
 		};
 	}
-	if (fieldType === "REFERENCE_TABLE") {
-		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(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));
-		const relatedApp = refTable.relatedApp;
-		const conditionField = String(condition.field ?? "");
-		const conditionRelatedField = String(condition.relatedField ?? "");
-		if (conditionField.length === 0) throw new BusinessRuleError(FormSchemaErrorCode.FsInvalidSchemaStructure, `Field "${code}" of type REFERENCE_TABLE must have a non-empty "referenceTable.condition.field"`);
-		if (conditionRelatedField.length === 0) throw new BusinessRuleError(FormSchemaErrorCode.FsInvalidSchemaStructure, `Field "${code}" of type REFERENCE_TABLE must have a non-empty "referenceTable.condition.relatedField"`);
-		return {
-			...base,
-			type: "REFERENCE_TABLE",
-			properties: { referenceTable: {
-				relatedApp: { app: String(relatedApp.app ?? "") },
-				condition: {
-					field: FieldCode.create(conditionField),
-					relatedField: FieldCode.create(conditionRelatedField)
-				},
-				...refTable.filterCond !== void 0 ? { filterCond: String(refTable.filterCond) } : {},
-				displayFields,
-				...refTable.sort !== void 0 ? { sort: String(refTable.sort) } : {},
-				...refTable.size !== void 0 ? { size: String(refTable.size) } : {}
-			} }
-		};
-	}
+	if (fieldType === "REFERENCE_TABLE") return parseReferenceTableField(raw, code, base);
 	const properties = extractProperties(raw);
 	validateFieldProperties(code, fieldType, properties);
 	return buildFieldDefinition(base, fieldType, properties);
@@ -8828,6 +8374,68 @@ function mergeFieldMaps(target, source) {
 	}
 	return merged;
 }
+function parseGroupLayoutItem(raw) {
+	const code = FieldCode.create(String(raw.code));
+	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) : [];
+	let groupFields = /* @__PURE__ */ new Map();
+	const layout = [];
+	for (const r of rawLayout) {
+		const row = parseLayoutRow(r);
+		const rowFields = collectFieldsFromElements(row.fields);
+		groupFields = mergeFieldMaps(groupFields, rowFields);
+		layout.push(row);
+	}
+	const groupDef = {
+		code,
+		label,
+		...noLabel !== void 0 ? { noLabel } : {},
+		type: "GROUP",
+		properties: { ...openGroup !== void 0 ? { openGroup } : {} }
+	};
+	checkDuplicateFieldCode(groupFields, code);
+	groupFields.set(code, groupDef);
+	return {
+		item: {
+			type: "GROUP",
+			code,
+			label,
+			...noLabel !== void 0 ? { noLabel } : {},
+			...openGroup !== void 0 ? { openGroup } : {},
+			layout
+		},
+		fields: groupFields
+	};
+}
+function parseSubtableLayoutItem(raw) {
+	const code = FieldCode.create(String(raw.code));
+	const label = String(raw.label ?? "");
+	const noLabel = typeof raw.noLabel === "boolean" ? raw.noLabel : void 0;
+	const elements = (Array.isArray(raw.fields) ? raw.fields : []).map(parseLayoutElement);
+	const subFields = collectFieldsFromElements(elements);
+	const subtableDef = {
+		code,
+		label,
+		...noLabel !== void 0 ? { noLabel } : {},
+		type: "SUBTABLE",
+		properties: { fields: subFields }
+	};
+	const allFields = new Map(subFields);
+	checkDuplicateFieldCode(allFields, code);
+	allFields.set(code, subtableDef);
+	return {
+		item: {
+			type: "SUBTABLE",
+			code,
+			label,
+			...noLabel !== void 0 ? { noLabel } : {},
+			fields: elements
+		},
+		fields: allFields
+	};
+}
 function parseLayoutItem(raw) {
 	const type = String(raw.type);
 	switch (type) {
@@ -8838,68 +8446,8 @@ function parseLayoutItem(raw) {
 				fields: collectFieldsFromElements(row.fields)
 			};
 		}
-		case "GROUP": {
-			const code = FieldCode.create(String(raw.code));
-			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) : [];
-			let groupFields = /* @__PURE__ */ new Map();
-			const layout = [];
-			for (const r of rawLayout) {
-				const row = parseLayoutRow(r);
-				const rowFields = collectFieldsFromElements(row.fields);
-				groupFields = mergeFieldMaps(groupFields, rowFields);
-				layout.push(row);
-			}
-			const groupDef = {
-				code,
-				label,
-				...noLabel !== void 0 ? { noLabel } : {},
-				type: "GROUP",
-				properties: { ...openGroup !== void 0 ? { openGroup } : {} }
-			};
-			checkDuplicateFieldCode(groupFields, code);
-			groupFields.set(code, groupDef);
-			return {
-				item: {
-					type: "GROUP",
-					code,
-					label,
-					...noLabel !== void 0 ? { noLabel } : {},
-					...openGroup !== void 0 ? { openGroup } : {},
-					layout
-				},
-				fields: groupFields
-			};
-		}
-		case "SUBTABLE": {
-			const code = FieldCode.create(String(raw.code));
-			const label = String(raw.label ?? "");
-			const noLabel = typeof raw.noLabel === "boolean" ? raw.noLabel : void 0;
-			const elements = (Array.isArray(raw.fields) ? raw.fields : []).map(parseLayoutElement);
-			const subFields = collectFieldsFromElements(elements);
-			const subtableDef = {
-				code,
-				label,
-				...noLabel !== void 0 ? { noLabel } : {},
-				type: "SUBTABLE",
-				properties: { fields: subFields }
-			};
-			const allFields = new Map(subFields);
-			checkDuplicateFieldCode(allFields, code);
-			allFields.set(code, subtableDef);
-			return {
-				item: {
-					type: "SUBTABLE",
-					code,
-					label,
-					...noLabel !== void 0 ? { noLabel } : {},
-					fields: elements
-				},
-				fields: allFields
-			};
-		}
+		case "GROUP": return parseGroupLayoutItem(raw);
+		case "SUBTABLE": return parseSubtableLayoutItem(raw);
 		case "REFERENCE_TABLE": {
 			const code = FieldCode.create(String(raw.code));
 			const label = String(raw.label ?? "");
@@ -8920,14 +8468,7 @@ function parseLayoutItem(raw) {
 		default: throw new BusinessRuleError(FormSchemaErrorCode.FsInvalidLayoutStructure, `Unknown layout item type: "${type}"`);
 	}
 }
-const SchemaParser = { parse: (rawText) => {
-	if (rawText.trim().length === 0) throw new BusinessRuleError(FormSchemaErrorCode.FsEmptySchemaText, "Schema text cannot be empty");
-	let parsed;
-	try {
-		parsed = parse(rawText);
-	} catch {
-		throw new BusinessRuleError(FormSchemaErrorCode.FsInvalidSchemaFormat, "Schema text is not valid YAML/JSON");
-	}
+const SchemaParser = { parse: (parsed) => {
 	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.");
@@ -8946,8 +8487,9 @@ const SchemaParser = { parse: (rawText) => {
 } };
 //#endregion
 //#region src/core/application/formSchema/parseSchema.ts
-function parseSchemaText(rawText) {
-	return wrapBusinessRuleError(() => SchemaParser.parse(rawText));
+function parseSchemaText(codec, rawText) {
+	const parsed = parseConfigText(codec, rawText, "Schema");
+	return wrapBusinessRuleError(() => SchemaParser.parse(parsed));
 }
 //#endregion
 //#region src/core/application/formSchema/detectDiff.ts
@@ -8975,7 +8517,7 @@ function toFieldDto(field) {
 async function detectDiff({ container }) {
 	const result = await container.schemaStorage.get();
 	if (!result.exists) throw new ValidationError(ValidationErrorCode.InvalidInput, "Schema file not found");
-	const schema = parseSchemaText(result.content);
+	const schema = parseSchemaText(container.configCodec, result.content);
 	const [currentFields, currentLayout] = await Promise.all([container.formConfigurator.getFields(), container.formConfigurator.getLayout()]);
 	const diff = DiffDetector.detect(schema, currentFields);
 	const enrichedCurrentLayout = enrichLayoutWithFields(currentLayout, currentFields);
@@ -9340,10 +8882,22 @@ function assertSchemaValid(schema) {
 }
 //#endregion
 //#region src/core/application/formSchema/executeMigration.ts
+function processModifiedEntry(after, before, fieldsToUpdate, innerFieldsToDelete) {
+	if (after.type === "SUBTABLE" && before !== void 0 && before.type === "SUBTABLE") {
+		const { newInnerFields, existingInnerFields, deletedInnerFieldCodes } = splitSubtableInnerFields(after, before);
+		if (newInnerFields.size > 0) throw new ValidationError(ValidationErrorCode.InvalidInput, `kintone REST API does not support adding fields to an existing subtable. Use the schema override command instead. Subtable: ${after.code}`);
+		if (existingInnerFields.size > 0) fieldsToUpdate.push({
+			...after,
+			properties: { fields: existingInnerFields }
+		});
+		for (const code of deletedInnerFieldCodes) innerFieldsToDelete.push(code);
+	} else if (before !== void 0 && before.type !== after.type) throw new ValidationError(ValidationErrorCode.InvalidInput, `Field type change detected for "${after.code}" (${before.type} → ${after.type}). Use the schema override command instead.`);
+	else fieldsToUpdate.push(after);
+}
 async function executeMigration({ container }) {
 	const result = await container.schemaStorage.get();
 	if (!result.exists) throw new ValidationError(ValidationErrorCode.InvalidInput, "Schema file not found");
-	const schema = parseSchemaText(result.content);
+	const schema = parseSchemaText(container.configCodec, result.content);
 	assertSchemaValid(schema);
 	const [currentFields, currentLayout] = await Promise.all([container.formConfigurator.getFields(), container.formConfigurator.getLayout()]);
 	const diff = DiffDetector.detect(schema, currentFields);
@@ -9365,18 +8919,7 @@ async function executeMigration({ container }) {
 	for (const entry of modified) {
 		if (entry.after === void 0) continue;
 		if (subtableInnerCodes.has(entry.fieldCode)) continue;
-		const after = entry.after;
-		const before = entry.before;
-		if (after.type === "SUBTABLE" && before !== void 0 && before.type === "SUBTABLE") {
-			const { newInnerFields, existingInnerFields, deletedInnerFieldCodes } = splitSubtableInnerFields(after, before);
-			if (newInnerFields.size > 0) throw new ValidationError(ValidationErrorCode.InvalidInput, `kintone REST API does not support adding fields to an existing subtable. Use the schema override command instead. Subtable: ${after.code}`);
-			if (existingInnerFields.size > 0) fieldsToUpdate.push({
-				...after,
-				properties: { fields: existingInnerFields }
-			});
-			for (const code of deletedInnerFieldCodes) innerFieldsToDelete.push(code);
-		} else if (before !== void 0 && before.type !== after.type) throw new ValidationError(ValidationErrorCode.InvalidInput, `Field type change detected for "${after.code}" (${before.type} → ${after.type}). Use the schema override command instead.`);
-		else fieldsToUpdate.push(after);
+		processModifiedEntry(entry.after, entry.before, fieldsToUpdate, innerFieldsToDelete);
 	}
 	if (fieldsToAdd.length > 0) await container.formConfigurator.addFields(fieldsToAdd);
 	if (fieldsToUpdate.length > 0) await container.formConfigurator.updateFields(fieldsToUpdate);
@@ -9485,55 +9028,62 @@ var migrate_default = define({
 });
 //#endregion
 //#region src/core/application/formSchema/forceOverrideForm.ts
+function classifySubtableField(fieldCode, schemaDef, currentFields, result) {
+	const currentDef = currentFields.get(fieldCode);
+	if (currentDef !== void 0 && currentDef.type === "SUBTABLE") {
+		const { newInnerFields, existingInnerFields, deletedInnerFieldCodes } = splitSubtableInnerFields(schemaDef, currentDef);
+		const allInnerFieldsRemoved = existingInnerFields.size === 0 && deletedInnerFieldCodes.length > 0;
+		if (newInnerFields.size > 0 || allInnerFieldsRemoved) {
+			result.toDelete.push(fieldCode);
+			result.toAdd.push(schemaDef);
+		} else {
+			result.toUpdate.push({
+				...schemaDef,
+				properties: { fields: existingInnerFields }
+			});
+			for (const code of deletedInnerFieldCodes) result.innerFieldsToDelete.push(code);
+		}
+	} else {
+		result.toDelete.push(fieldCode);
+		result.toAdd.push(schemaDef);
+	}
+}
+function classifyExistingField(fieldCode, schemaDef, currentFields, result) {
+	if (schemaDef.type === "SUBTABLE") classifySubtableField(fieldCode, schemaDef, currentFields, result);
+	else {
+		const currentDef = currentFields.get(fieldCode);
+		if (currentDef !== void 0 && currentDef.type !== schemaDef.type) {
+			result.toDelete.push(fieldCode);
+			result.toAdd.push(schemaDef);
+		} else result.toUpdate.push(schemaDef);
+	}
+}
 async function forceOverrideForm({ container }) {
 	const result = await container.schemaStorage.get();
 	if (!result.exists) throw new ValidationError(ValidationErrorCode.InvalidInput, "Schema file not found");
-	const schema = parseSchemaText(result.content);
+	const schema = parseSchemaText(container.configCodec, result.content);
 	assertSchemaValid(schema);
 	const currentFields = await container.formConfigurator.getFields();
 	const subtableInnerCodes = collectSubtableInnerFieldCodes(schema.fields);
-	const toAdd = [];
-	const toUpdate = [];
-	const toDelete = [];
-	const innerFieldsToDelete = [];
+	const classification = {
+		toAdd: [],
+		toUpdate: [],
+		toDelete: [],
+		innerFieldsToDelete: []
+	};
 	for (const [fieldCode, schemaDef] of schema.fields) {
 		if (subtableInnerCodes.has(fieldCode)) continue;
-		if (currentFields.has(fieldCode)) if (schemaDef.type === "SUBTABLE") {
-			const currentDef = currentFields.get(fieldCode);
-			if (currentDef !== void 0 && currentDef.type === "SUBTABLE") {
-				const { newInnerFields, existingInnerFields, deletedInnerFieldCodes } = splitSubtableInnerFields(schemaDef, currentDef);
-				const allInnerFieldsRemoved = existingInnerFields.size === 0 && deletedInnerFieldCodes.length > 0;
-				if (newInnerFields.size > 0 || allInnerFieldsRemoved) {
-					toDelete.push(fieldCode);
-					toAdd.push(schemaDef);
-				} else {
-					toUpdate.push({
-						...schemaDef,
-						properties: { fields: existingInnerFields }
-					});
-					for (const code of deletedInnerFieldCodes) innerFieldsToDelete.push(code);
-				}
-			} else {
-				toDelete.push(fieldCode);
-				toAdd.push(schemaDef);
-			}
-		} else {
-			const currentDef = currentFields.get(fieldCode);
-			if (currentDef !== void 0 && currentDef.type !== schemaDef.type) {
-				toDelete.push(fieldCode);
-				toAdd.push(schemaDef);
-			} else toUpdate.push(schemaDef);
-		}
-		else toAdd.push(schemaDef);
+		if (currentFields.has(fieldCode)) classifyExistingField(fieldCode, schemaDef, currentFields, classification);
+		else classification.toAdd.push(schemaDef);
 	}
 	const currentSubtableInnerCodes = collectSubtableInnerFieldCodes(currentFields);
 	for (const fieldCode of currentFields.keys()) {
 		if (currentSubtableInnerCodes.has(fieldCode)) continue;
-		if (!schema.fields.has(fieldCode)) toDelete.push(fieldCode);
+		if (!schema.fields.has(fieldCode)) classification.toDelete.push(fieldCode);
 	}
-	if (toDelete.length > 0 || innerFieldsToDelete.length > 0) await container.formConfigurator.deleteFields([...toDelete, ...innerFieldsToDelete]);
-	if (toAdd.length > 0) await container.formConfigurator.addFields(toAdd);
-	if (toUpdate.length > 0) await container.formConfigurator.updateFields(toUpdate);
+	if (classification.toDelete.length > 0 || classification.innerFieldsToDelete.length > 0) await container.formConfigurator.deleteFields([...classification.toDelete, ...classification.innerFieldsToDelete]);
+	if (classification.toAdd.length > 0) await container.formConfigurator.addFields(classification.toAdd);
+	if (classification.toUpdate.length > 0) await container.formConfigurator.updateFields(classification.toUpdate);
 	await container.formConfigurator.updateLayout(schema.layout);
 }
 //#endregion
@@ -9667,7 +9217,10 @@ var override_default = define({
 //#endregion
 //#region src/core/application/container/validateCli.ts
 function createValidateCliContainer(config) {
-	return { schemaStorage: createLocalFileSchemaStorage(config.schemaFilePath) };
+	return {
+		configCodec,
+		schemaStorage: createLocalFileSchemaStorage(config.schemaFilePath)
+	};
 }
 //#endregion
 //#region src/core/application/formSchema/validateSchema.ts
@@ -9676,7 +9229,7 @@ async function validateSchema({ container }) {
 	if (!result.exists) throw new ValidationError(ValidationErrorCode.InvalidInput, "Schema file not found");
 	let schema;
 	try {
-		schema = parseSchemaText(result.content);
+		schema = parseSchemaText(container.configCodec, result.content);
 	} catch (error) {
 		if (isValidationError(error)) return {
 			parseError: error.message,
@@ -9854,14 +9407,7 @@ function parseRecord(raw, index) {
 	for (const [key, value] of Object.entries(raw)) record[key] = normalizeValue(value);
 	return record;
 }
-const SeedParser = { parse: (rawText) => {
-	if (rawText.trim().length === 0) throw new BusinessRuleError(SeedDataErrorCode.SdEmptySeedText, "Seed text cannot be empty");
-	let parsed;
-	try {
-		parsed = parse(rawText);
-	} catch {
-		throw new BusinessRuleError(SeedDataErrorCode.SdInvalidSeedYaml, "Seed text is not valid YAML");
-	}
+const SeedParser = { parse: (parsed) => {
 	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;
@@ -9887,15 +9433,16 @@ const SeedParser = { parse: (rawText) => {
 } };
 //#endregion
 //#region src/core/application/seedData/parseConfig.ts
-function parseSeedText(rawText) {
-	return wrapBusinessRuleError(() => SeedParser.parse(rawText));
+function parseSeedText(codec, rawText) {
+	const parsed = parseConfigText(codec, rawText, "Seed");
+	return wrapBusinessRuleError(() => SeedParser.parse(parsed));
 }
 //#endregion
 //#region src/core/application/seedData/upsertSeed.ts
 async function upsertSeed({ container, input }) {
 	const result = await container.seedStorage.get();
 	if (!result.exists) throw new ValidationError(ValidationErrorCode.InvalidInput, "Seed file not found");
-	const seedData = parseSeedText(result.content);
+	const seedData = parseSeedText(container.configCodec, result.content);
 	if (input.clean) {
 		const { deletedCount } = await container.recordManager.deleteAllRecords();
 		if (seedData.records.length > 0) await container.recordManager.addRecords(seedData.records);
@@ -10153,41 +9700,33 @@ function parseNumberPrecision(raw) {
 		roundingMode: parseEnum(raw.roundingMode, VALID_ROUNDING_MODES, GeneralSettingsErrorCode.GsInvalidConfigStructure, `numberPrecision.roundingMode must be HALF_EVEN, UP, or DOWN, got: ${String(raw.roundingMode)}`)
 	};
 }
-const GeneralSettingsConfigParser = { parse: (rawText) => {
-	const parsed = parseYamlConfig(rawText, {
-		emptyConfigText: GeneralSettingsErrorCode.GsEmptyConfigText,
-		invalidConfigYaml: GeneralSettingsErrorCode.GsInvalidConfigYaml,
-		invalidConfigStructure: GeneralSettingsErrorCode.GsInvalidConfigStructure
-	}, "General settings");
-	let name;
-	if (parsed.name !== void 0 && parsed.name !== null) {
-		if (typeof parsed.name !== "string") throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "name must be a string");
-		name = parsed.name;
-	}
-	let description;
-	if (parsed.description !== void 0 && parsed.description !== null) {
-		if (typeof parsed.description !== "string") throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "description must be a string");
-		description = parsed.description;
-	}
-	let icon;
-	if (parsed.icon !== void 0 && parsed.icon !== null) icon = parseIcon(parsed.icon);
-	let theme;
-	if (parsed.theme !== void 0 && parsed.theme !== null) theme = parseEnum(parsed.theme, VALID_THEMES, GeneralSettingsErrorCode.GsInvalidTheme, `theme must be WHITE, RED, GREEN, BLUE, YELLOW, BLACK, CLIPBOARD, BINDER, PENCIL, or CLIPS, got: ${String(parsed.theme)}`);
-	let titleField;
-	if (parsed.titleField !== void 0 && parsed.titleField !== null) titleField = parseTitleField(parsed.titleField);
-	const enableThumbnails = parseOptionalBoolean(parsed, "enableThumbnails");
-	const enableBulkDeletion = parseOptionalBoolean(parsed, "enableBulkDeletion");
-	const enableComments = parseOptionalBoolean(parsed, "enableComments");
-	const enableDuplicateRecord = parseOptionalBoolean(parsed, "enableDuplicateRecord");
-	const enableInlineRecordEditing = parseOptionalBoolean(parsed, "enableInlineRecordEditing");
-	let numberPrecision;
-	if (parsed.numberPrecision !== void 0 && parsed.numberPrecision !== null) numberPrecision = parseNumberPrecision(parsed.numberPrecision);
-	let firstMonthOfFiscalYear;
-	if (parsed.firstMonthOfFiscalYear !== void 0 && parsed.firstMonthOfFiscalYear !== null) {
-		if (typeof parsed.firstMonthOfFiscalYear !== "number") throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "firstMonthOfFiscalYear must be a number");
-		if (parsed.firstMonthOfFiscalYear < 1 || parsed.firstMonthOfFiscalYear > 12 || !Number.isInteger(parsed.firstMonthOfFiscalYear)) throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, `firstMonthOfFiscalYear must be an integer between 1 and 12, got: ${parsed.firstMonthOfFiscalYear}`);
-		firstMonthOfFiscalYear = parsed.firstMonthOfFiscalYear;
-	}
+function parseOptionalString(obj, fieldName) {
+	const value = obj[fieldName];
+	if (value === void 0 || value === null) return void 0;
+	if (typeof value !== "string") throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, `${fieldName} must be a string`);
+	return value;
+}
+function parseFirstMonthOfFiscalYear(obj) {
+	const value = obj.firstMonthOfFiscalYear;
+	if (value === void 0 || value === null) return void 0;
+	if (typeof value !== "number") throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "firstMonthOfFiscalYear must be a number");
+	if (value < 1 || value > 12 || !Number.isInteger(value)) throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, `firstMonthOfFiscalYear must be an integer between 1 and 12, got: ${value}`);
+	return value;
+}
+const GeneralSettingsConfigParser = { parse: (parsed) => {
+	const obj = validateParsedConfig(parsed, GeneralSettingsErrorCode.GsInvalidConfigStructure, "General settings");
+	const name = parseOptionalString(obj, "name");
+	const description = parseOptionalString(obj, "description");
+	const icon = obj.icon !== void 0 && obj.icon !== null ? parseIcon(obj.icon) : void 0;
+	const theme = obj.theme !== void 0 && obj.theme !== null ? parseEnum(obj.theme, VALID_THEMES, GeneralSettingsErrorCode.GsInvalidTheme, `theme must be WHITE, RED, GREEN, BLUE, YELLOW, BLACK, CLIPBOARD, BINDER, PENCIL, or CLIPS, got: ${String(obj.theme)}`) : void 0;
+	const titleField = obj.titleField !== void 0 && obj.titleField !== null ? parseTitleField(obj.titleField) : void 0;
+	const enableThumbnails = parseOptionalBoolean(obj, "enableThumbnails");
+	const enableBulkDeletion = parseOptionalBoolean(obj, "enableBulkDeletion");
+	const enableComments = parseOptionalBoolean(obj, "enableComments");
+	const enableDuplicateRecord = parseOptionalBoolean(obj, "enableDuplicateRecord");
+	const enableInlineRecordEditing = parseOptionalBoolean(obj, "enableInlineRecordEditing");
+	const numberPrecision = obj.numberPrecision !== void 0 && obj.numberPrecision !== null ? parseNumberPrecision(obj.numberPrecision) : void 0;
+	const firstMonthOfFiscalYear = parseFirstMonthOfFiscalYear(obj);
 	return {
 		...name !== void 0 ? { name } : {},
 		...description !== void 0 ? { description } : {},
@@ -10205,15 +9744,16 @@ const GeneralSettingsConfigParser = { parse: (rawText) => {
 } };
 //#endregion
 //#region src/core/application/generalSettings/parseConfig.ts
-function parseGeneralSettingsConfigText(rawText) {
-	return wrapBusinessRuleError(() => GeneralSettingsConfigParser.parse(rawText));
+function parseGeneralSettingsConfigText(codec, rawText) {
+	const parsed = parseConfigText(codec, rawText, "General settings");
+	return wrapBusinessRuleError(() => GeneralSettingsConfigParser.parse(parsed));
 }
 //#endregion
 //#region src/core/application/generalSettings/applyGeneralSettings.ts
 async function applyGeneralSettings({ container }) {
 	await applyFromConfig({
 		getStorage: () => container.generalSettingsStorage.get(),
-		parseConfig: parseGeneralSettingsConfigText,
+		parseConfig: (content) => parseGeneralSettingsConfigText(container.configCodec, content),
 		fetchRemote: () => container.generalSettingsConfigurator.getGeneralSettings(),
 		update: async (config, current) => {
 			await container.generalSettingsConfigurator.updateGeneralSettings({
@@ -10247,91 +9787,32 @@ const { resolveFilePath: resolveSettingsFilePath, resolveContainerConfig: resolv
 });
 //#endregion
 //#region src/cli/commands/settings/apply.ts
-async function runSettings(config) {
-	const container = createGeneralSettingsCliContainer(config);
-	const s = p.spinner();
-	s.start("Applying general settings...");
-	await applyGeneralSettings({ container });
-	s.stop("General settings applied.");
-	p.log.success("General settings applied successfully.");
-	return container;
-}
-var apply_default$1 = define({
-	name: "apply",
+var apply_default$1 = createApplyCommand({
 	description: "Apply general settings from YAML to kintone app",
-	args: {
-		...settingsArgs,
-		...confirmArgs
-	},
-	run: async (ctx) => {
-		try {
-			const values = ctx.values;
-			const skipConfirm = values.yes === true;
-			await routeMultiApp(values, {
-				singleLegacy: async () => {
-					await confirmAndDeploy([await runSettings(resolveSettingsContainerConfig(values))], skipConfirm);
-				},
-				singleApp: async (app, projectConfig) => {
-					await confirmAndDeploy([await runSettings(resolveSettingsAppContainerConfig(app, projectConfig, values))], skipConfirm);
-				},
-				multiApp: async (plan, projectConfig) => {
-					const containers = [];
-					await runMultiAppWithHeaders(plan, async (app) => {
-						const container = await runSettings(resolveSettingsAppContainerConfig(app, projectConfig, values));
-						containers.push({
-							appDeployer: container.appDeployer,
-							appName: app.name
-						});
-					});
-					await confirmAndDeploy(containers, skipConfirm);
-				}
-			});
-		} catch (error) {
-			handleCliError(error);
-		}
-	}
+	args: settingsArgs,
+	spinnerMessage: "Applying general settings...",
+	spinnerStopMessage: "General settings applied.",
+	successMessage: "General settings applied successfully.",
+	createContainer: createGeneralSettingsCliContainer,
+	applyFn: applyGeneralSettings,
+	resolveContainerConfig: resolveSettingsContainerConfig,
+	resolveAppContainerConfig: resolveSettingsAppContainerConfig
 });
 //#endregion
 //#region src/cli/commands/settings/capture.ts
-async function runCaptureSettings(config) {
-	const container = createGeneralSettingsCliContainer(config);
-	const s = p.spinner();
-	s.start("Capturing general settings...");
-	const result = await captureGeneralSettings({ container });
-	s.stop("General settings captured.");
-	await saveGeneralSettings({
-		container,
-		input: { configText: result.configText }
-	});
-	p.log.success(`General settings saved to: ${pc.cyan(config.settingsFilePath)}`);
-	if (result.hasExistingConfig) p.log.warn("Existing general settings file was overwritten.");
-}
-var capture_default$1 = define({
-	name: "capture",
+var capture_default$1 = createCaptureCommand({
 	description: "Capture current general settings from kintone app to file",
 	args: settingsArgs,
-	run: async (ctx) => {
-		try {
-			const values = ctx.values;
-			await routeMultiApp(values, {
-				singleLegacy: async () => {
-					await runCaptureSettings(resolveSettingsContainerConfig(values));
-				},
-				singleApp: async (app, projectConfig) => {
-					await runCaptureSettings(resolveSettingsAppContainerConfig(app, projectConfig, values));
-				},
-				multiApp: async (plan, projectConfig) => {
-					await runMultiAppWithFailCheck(plan, async (app) => {
-						const config = resolveSettingsAppContainerConfig(app, projectConfig, values);
-						printAppHeader(app.name, app.appId);
-						await runCaptureSettings(config);
-					}, "All general settings captures completed successfully.");
-				}
-			});
-		} catch (error) {
-			handleCliError(error);
-		}
-	}
+	spinnerMessage: "Capturing general settings...",
+	spinnerStopMessage: "General settings captured.",
+	domainLabel: "General settings",
+	multiAppSuccessMessage: "All general settings captures completed successfully.",
+	createContainer: createGeneralSettingsCliContainer,
+	captureFn: captureGeneralSettings,
+	saveFn: saveGeneralSettings,
+	getConfigFilePath: (config) => config.settingsFilePath,
+	resolveContainerConfig: resolveSettingsContainerConfig,
+	resolveAppContainerConfig: resolveSettingsAppContainerConfig
 });
 //#endregion
 //#region src/core/domain/generalSettings/services/diffDetector.ts
@@ -10400,7 +9881,7 @@ async function detectGeneralSettingsDiff({ container }) {
 	return detectDiffFromConfig({
 		getStorage: () => container.generalSettingsStorage.get(),
 		fetchRemote: () => container.generalSettingsConfigurator.getGeneralSettings(),
-		parseConfig: parseGeneralSettingsConfigText,
+		parseConfig: (content) => parseGeneralSettingsConfigText(container.configCodec, content),
 		detect: (local, remote) => GeneralSettingsDiffDetector.detect(local, remote.config),
 		notFoundMessage: "General settings config file not found"
 	});
@@ -10460,12 +9941,8 @@ function parseViewConfig(name, raw) {
 		...raw.sort !== void 0 && { sort: String(raw.sort) }
 	};
 }
-const ViewConfigParser = { parse: (rawText) => {
-	const obj = parseYamlConfig(rawText, {
-		emptyConfigText: ViewErrorCode.VwEmptyConfigText,
-		invalidConfigYaml: ViewErrorCode.VwInvalidConfigYaml,
-		invalidConfigStructure: ViewErrorCode.VwInvalidConfigStructure
-	}, "View");
+const ViewConfigParser = { parse: (parsed) => {
+	const obj = validateParsedConfig(parsed, ViewErrorCode.VwInvalidConfigStructure, "View");
 	if (!isRecord(obj.views)) throw new BusinessRuleError(ViewErrorCode.VwInvalidConfigStructure, "Config must have a \"views\" object");
 	const viewsObj = obj.views;
 	const views = {};
@@ -10477,15 +9954,16 @@ const ViewConfigParser = { parse: (rawText) => {
 } };
 //#endregion
 //#region src/core/application/view/parseConfig.ts
-function parseViewConfigText(rawText) {
-	return wrapBusinessRuleError(() => ViewConfigParser.parse(rawText));
+function parseViewConfigText(codec, rawText) {
+	const parsed = parseConfigText(codec, rawText, "View");
+	return wrapBusinessRuleError(() => ViewConfigParser.parse(parsed));
 }
 //#endregion
 //#region src/core/application/view/applyView.ts
 async function applyView({ 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 config = parseViewConfigText(container.configCodec, result.content);
 	const skippedBuiltinViews = [];
 	const filteredViews = {};
 	for (const [name, view] of Object.entries(config.views)) if (view.builtinType !== void 0) skippedBuiltinViews.push(name);
@@ -10521,107 +9999,53 @@ const { resolveFilePath: resolveViewFilePath, resolveContainerConfig: resolveVie
 });
 //#endregion
 //#region src/cli/commands/view/apply.ts
-async function runView(config) {
-	const container = createViewCliContainer(config);
-	const s = p.spinner();
-	s.start("Applying views...");
-	const result = await applyView({ container });
-	s.stop("Views applied.");
-	if (result.skippedBuiltinViews.length > 0) p.log.warn(`Skipped built-in views: ${result.skippedBuiltinViews.join(", ")}`);
-	p.log.success("Views applied successfully.");
-	return container;
-}
-var apply_default = define({
-	name: "apply",
+var apply_default = createApplyCommand({
 	description: "Apply view settings from YAML to kintone app",
-	args: {
-		...viewArgs,
-		...confirmArgs
+	args: viewArgs,
+	spinnerMessage: "Applying views...",
+	spinnerStopMessage: "Views applied.",
+	successMessage: "Views applied successfully.",
+	createContainer: createViewCliContainer,
+	applyFn: applyView,
+	onResult: (result) => {
+		if (result.skippedBuiltinViews.length > 0) p.log.warn(`Skipped built-in views: ${result.skippedBuiltinViews.join(", ")}`);
 	},
-	run: async (ctx) => {
-		try {
-			const values = ctx.values;
-			const skipConfirm = values.yes === true;
-			await routeMultiApp(values, {
-				singleLegacy: async () => {
-					await confirmAndDeploy([await runView(resolveViewContainerConfig(values))], skipConfirm);
-				},
-				singleApp: async (app, projectConfig) => {
-					await confirmAndDeploy([await runView(resolveViewAppContainerConfig(app, projectConfig, values))], skipConfirm);
-				},
-				multiApp: async (plan, projectConfig) => {
-					const containers = [];
-					await runMultiAppWithHeaders(plan, async (app) => {
-						const container = await runView(resolveViewAppContainerConfig(app, projectConfig, values));
-						containers.push({
-							appDeployer: container.appDeployer,
-							appName: app.name
-						});
-					});
-					await confirmAndDeploy(containers, skipConfirm);
-				}
-			});
-		} catch (error) {
-			handleCliError(error);
-		}
-	}
+	resolveContainerConfig: resolveViewContainerConfig,
+	resolveAppContainerConfig: resolveViewAppContainerConfig
 });
 //#endregion
 //#region src/cli/commands/view/capture.ts
-async function runCaptureView(config) {
-	const container = createViewCliContainer(config);
-	const s = p.spinner();
-	s.start("Capturing views...");
-	const result = await captureView({ container });
-	s.stop("Views captured.");
-	await saveView({
-		container,
-		input: { configText: result.configText }
-	});
-	p.log.success(`Views saved to: ${pc.cyan(config.viewFilePath)}`);
-	if (result.hasExistingConfig) p.log.warn("Existing view file was overwritten.");
-}
-var capture_default = define({
-	name: "capture",
+var capture_default = createCaptureCommand({
 	description: "Capture current view settings from kintone app to file",
 	args: viewArgs,
-	run: async (ctx) => {
-		try {
-			const values = ctx.values;
-			await routeMultiApp(values, {
-				singleLegacy: async () => {
-					await runCaptureView(resolveViewContainerConfig(values));
-				},
-				singleApp: async (app, projectConfig) => {
-					await runCaptureView(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 runCaptureView(config);
-					}, "All view captures completed successfully.");
-				}
-			});
-		} catch (error) {
-			handleCliError(error);
-		}
-	}
+	spinnerMessage: "Capturing views...",
+	spinnerStopMessage: "Views captured.",
+	domainLabel: "Views",
+	multiAppSuccessMessage: "All view captures completed successfully.",
+	createContainer: createViewCliContainer,
+	captureFn: captureView,
+	saveFn: saveView,
+	getConfigFilePath: (config) => config.viewFilePath,
+	resolveContainerConfig: resolveViewContainerConfig,
+	resolveAppContainerConfig: resolveViewAppContainerConfig
 });
 //#endregion
 //#region src/core/domain/view/services/diffDetector.ts
+function checkOptionalStringChange(changes, field, localVal, remoteVal) {
+	if ((localVal ?? "") !== (remoteVal ?? "")) changes.push(`${field} changed`);
+}
 function describeChanges(local, remote) {
 	const changes = [];
 	if (local.type !== remote.type) changes.push(`type: ${remote.type} -> ${local.type}`);
-	if ((local.builtinType ?? "") !== (remote.builtinType ?? "")) changes.push("builtinType changed");
+	checkOptionalStringChange(changes, "builtinType", local.builtinType, remote.builtinType);
 	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");
+	checkOptionalStringChange(changes, "filterCond", local.filterCond, remote.filterCond);
+	checkOptionalStringChange(changes, "sort", local.sort, remote.sort);
+	checkOptionalStringChange(changes, "date", local.date, remote.date);
+	checkOptionalStringChange(changes, "title", local.title, remote.title);
+	checkOptionalStringChange(changes, "html", local.html, remote.html);
 	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");
+	checkOptionalStringChange(changes, "device", local.device, remote.device);
 	if (!deepEqual(local.fields ?? [], remote.fields ?? [])) changes.push("fields changed");
 	return changes;
 }
@@ -10653,7 +10077,7 @@ async function detectViewDiff({ container }) {
 	return detectDiffFromConfig({
 		getStorage: () => container.viewStorage.get(),
 		fetchRemote: () => container.viewConfigurator.getViews(),
-		parseConfig: (content) => parseViewConfigText(content).views,
+		parseConfig: (content) => parseViewConfigText(container.configCodec, content).views,
 		detect: (views, remote) => ViewDiffDetector.detect(views, remote.views),
 		notFoundMessage: "View config file not found"
 	});