kintone-migrator 0.24.2 → 0.24.4

package/dist/index.mjs

@@ -4,9 +4,9 @@ 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 { KintoneRestAPIClient, KintoneRestAPIError } from "@kintone/rest-api-client";
 import * as v from "valibot";
 import pc from "picocolors";
 
@@ -68,6 +68,7 @@ const FieldPermissionErrorCode = {
 	FpInvalidConfigStructure: "FP_INVALID_CONFIG_STRUCTURE",
 	FpInvalidAccessibility: "FP_INVALID_ACCESSIBILITY",
 	FpInvalidEntityType: "FP_INVALID_ENTITY_TYPE",
+	FpInvalidBooleanField: "FP_INVALID_BOOLEAN_FIELD",
 	FpEmptyFieldCode: "FP_EMPTY_FIELD_CODE",
 	FpEmptyEntityCode: "FP_EMPTY_ENTITY_CODE",
 	FpDuplicateFieldCode: "FP_DUPLICATE_FIELD_CODE"
@@ -95,7 +96,9 @@ const GeneralSettingsErrorCode = {
 	GsInvalidConfigYaml: "GS_INVALID_CONFIG_YAML",
 	GsInvalidConfigStructure: "GS_INVALID_CONFIG_STRUCTURE",
 	GsInvalidTheme: "GS_INVALID_THEME",
-	GsInvalidIconType: "GS_INVALID_ICON_TYPE"
+	GsInvalidIconType: "GS_INVALID_ICON_TYPE",
+	GsInvalidBooleanField: "GS_INVALID_BOOLEAN_FIELD",
+	GsInvalidNumberPrecision: "GS_INVALID_NUMBER_PRECISION"
 };
 
 //#endregion
@@ -130,7 +133,9 @@ const ProcessManagementErrorCode = {
 	PmInvalidConfigStructure: "PM_INVALID_CONFIG_STRUCTURE",
 	PmInvalidAssigneeType: "PM_INVALID_ASSIGNEE_TYPE",
 	PmInvalidEntityType: "PM_INVALID_ENTITY_TYPE",
-	PmInvalidActionReference: "PM_INVALID_ACTION_REFERENCE"
+	PmInvalidBooleanField: "PM_INVALID_BOOLEAN_FIELD",
+	PmInvalidActionReference: "PM_INVALID_ACTION_REFERENCE",
+	PmDuplicateActionName: "PM_DUPLICATE_ACTION_NAME"
 };
 
 //#endregion
@@ -154,7 +159,8 @@ const RecordPermissionErrorCode = {
 	RpInvalidConfigStructure: "RP_INVALID_CONFIG_STRUCTURE",
 	RpInvalidEntityType: "RP_INVALID_ENTITY_TYPE",
 	RpEmptyEntityCode: "RP_EMPTY_ENTITY_CODE",
-	RpInvalidPermissionValue: "RP_INVALID_PERMISSION_VALUE"
+	RpInvalidPermissionValue: "RP_INVALID_PERMISSION_VALUE",
+	RpDuplicateEntity: "RP_DUPLICATE_ENTITY"
 };
 
 //#endregion
@@ -180,6 +186,10 @@ const SeedDataErrorCode = {
 	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 = {
@@ -209,6 +219,7 @@ const BusinessRuleErrorCode = {
 	...RecordPermissionErrorCode,
 	...ReportErrorCode,
 	...SeedDataErrorCode,
+	...DomainServiceErrorCode,
 	...ViewErrorCode
 };
 /**
@@ -329,6 +340,16 @@ function isSystemError(error) {
 	return error instanceof SystemError;
 }
 
+//#endregion
+//#region src/core/application/applyFromConfigBase.ts
+async function applyFromConfig(config) {
+	const result = await config.getStorage();
+	if (!result.exists) throw new ValidationError(ValidationErrorCode.InvalidInput, config.notFoundMessage);
+	const parsed = config.parseConfig(result.content);
+	const remote = await config.fetchRemote();
+	await config.update(parsed, remote);
+}
+
 //#endregion
 //#region src/lib/typeGuards.ts
 /**
@@ -344,10 +365,6 @@ function isRecord(value) {
 //#endregion
 //#region src/core/domain/typeGuards.ts
 /**
-* Type guard utilities for safe runtime type narrowing.
-* Use these functions instead of `as` casts when working with `unknown` values.
-*/
-/**
 * Narrows `unknown` to `{ code: string }`.
 */
 function hasCode(value) {
@@ -369,6 +386,45 @@ function hasOptionalType(value) {
 	if (!isRecord(value)) return false;
 	return value.type === void 0 || typeof value.type === "string";
 }
+/**
+* Strict boolean validation — rejects non-boolean values.
+* Returns the boolean value if valid, or `defaultValue` when the value is undefined/null.
+* Throws `BusinessRuleError` when the value is present but not a boolean.
+*/
+function parseStrictBoolean(value, fieldName, context, errorCode, defaultValue) {
+	if (value === void 0 || value === null) {
+		if (defaultValue !== void 0) return defaultValue;
+		throw new BusinessRuleError(errorCode, `${context} must have a boolean "${fieldName}" property`);
+	}
+	if (typeof value !== "boolean") throw new BusinessRuleError(errorCode, `${context} has invalid "${fieldName}" value: ${String(value)}. Must be a boolean`);
+	return value;
+}
+/**
+* Validates that an unknown value is a string within an allowed set and returns a typed value.
+* Replaces manual `typeof` + `Set.has` + `as` cast patterns.
+*/
+function parseEnum(value, validValues, errorCode, message) {
+	if (typeof value !== "string" || !validValues.has(value)) throw new BusinessRuleError(errorCode, message);
+	return value;
+}
+/**
+* Shared entity parsing logic for domains that use `{ type, code }` entities.
+* Handles common validation: isRecord check, type enum validation, and code non-empty check.
+* Use `allowEmptyCode` to permit empty/missing code for specific entity types (e.g., CREATOR).
+*/
+function parseEntityBase(raw, index, validTypes, errorCodes, options) {
+	if (!isRecord(raw)) throw new BusinessRuleError(errorCodes.invalidStructure, `Entity at index ${index} must be an object`);
+	const type = parseEnum(raw.type, validTypes, errorCodes.invalidType, `Entity at index ${index} has invalid type: ${String(raw.type)}. Must be ${[...validTypes].join(", ")}`);
+	if (options?.allowEmptyCode?.(type)) return {
+		type,
+		code: typeof raw.code === "string" ? raw.code : ""
+	};
+	if (typeof raw.code !== "string" || raw.code.length === 0) throw new BusinessRuleError(errorCodes.emptyCode, `Entity at index ${index} must have a non-empty "code" property`);
+	return {
+		type,
+		code: raw.code
+	};
+}
 
 //#endregion
 //#region src/core/domain/services/yamlConfigParser.ts
@@ -479,13 +535,17 @@ function parseActionConfigText(rawText) {
 //#endregion
 //#region src/core/application/action/applyAction.ts
 async function applyAction({ container }) {
-	const result = await container.actionStorage.get();
-	if (!result.exists) throw new ValidationError(ValidationErrorCode.InvalidInput, "Action config file not found");
-	const config = parseActionConfigText(result.content);
-	const current = await container.actionConfigurator.getActions();
-	await container.actionConfigurator.updateActions({
-		actions: config.actions,
-		revision: current.revision
+	await applyFromConfig({
+		getStorage: () => container.actionStorage.get(),
+		parseConfig: parseActionConfigText,
+		fetchRemote: () => container.actionConfigurator.getActions(),
+		update: async (config, current) => {
+			await container.actionConfigurator.updateActions({
+				actions: config.actions,
+				revision: current.revision
+			});
+		},
+		notFoundMessage: "Action config file not found"
 	});
 }
 
@@ -1516,11 +1576,7 @@ function buildKintoneAuth(auth) {
 	};
 }
 function createCliContainer(config) {
-	const client = new KintoneRestAPIClient({
-		baseUrl: config.baseUrl,
-		auth: buildKintoneAuth(config.auth),
-		guestSpaceId: config.guestSpaceId
-	});
+	const client = config.client ?? createKintoneClient(config);
 	return {
 		formConfigurator: new KintoneFormConfigurator(client, config.appId),
 		schemaStorage: createLocalFileSchemaStorage(config.schemaFilePath),
@@ -1529,20 +1585,12 @@ function createCliContainer(config) {
 }
 function createSeedCliContainer(config) {
 	return {
-		recordManager: new KintoneRecordManager(new KintoneRestAPIClient({
-			baseUrl: config.baseUrl,
-			auth: buildKintoneAuth(config.auth),
-			guestSpaceId: config.guestSpaceId
-		}), config.appId),
+		recordManager: new KintoneRecordManager(config.client ?? createKintoneClient(config), config.appId),
 		seedStorage: createLocalFileSeedStorage(config.seedFilePath)
 	};
 }
 function createCustomizationCliContainer(config) {
-	const client = new KintoneRestAPIClient({
-		baseUrl: config.baseUrl,
-		auth: buildKintoneAuth(config.auth),
-		guestSpaceId: config.guestSpaceId
-	});
+	const client = config.client ?? createKintoneClient(config);
 	return {
 		customizationConfigurator: new KintoneCustomizationConfigurator(client, config.appId),
 		customizationStorage: createLocalFileCustomizationStorage(config.customizeFilePath),
@@ -1554,13 +1602,19 @@ function createCustomizationCliContainer(config) {
 }
 
 //#endregion
-//#region src/core/application/container/actionCli.ts
-function createActionCliContainer(config) {
-	const client = new KintoneRestAPIClient({
+//#region src/core/application/container/kintoneClient.ts
+function createKintoneClient(config) {
+	return new KintoneRestAPIClient({
 		baseUrl: config.baseUrl,
 		auth: buildKintoneAuth(config.auth),
 		guestSpaceId: config.guestSpaceId
 	});
+}
+
+//#endregion
+//#region src/core/application/container/actionCli.ts
+function createActionCliContainer(config) {
+	const client = config.client ?? createKintoneClient(config);
 	return {
 		actionConfigurator: new KintoneActionConfigurator(client, config.appId),
 		actionStorage: createLocalFileActionStorage(config.actionFilePath),
@@ -2453,7 +2507,7 @@ function serializeToYaml(data) {
 			defaultStringType: "PLAIN"
 		});
 	} catch (error) {
-		throw new BusinessRuleError(BusinessRuleErrorCode.AcInvalidConfigStructure, `Failed to serialize config to YAML: ${error instanceof Error ? error.message : String(error)}`, error);
+		throw new BusinessRuleError(DomainServiceErrorCode.YamlSerializationFailed, `Failed to serialize config to YAML: ${error instanceof Error ? error.message : String(error)}`, error);
 	}
 }
 
@@ -2497,15 +2551,25 @@ const ActionConfigSerializer = { serialize: (config) => {
 } };
 
 //#endregion
-//#region src/core/application/action/captureAction.ts
-async function captureAction({ container }) {
-	const { actions } = await container.actionConfigurator.getActions();
+//#region src/core/application/captureFromConfigBase.ts
+async function captureFromConfig(config) {
+	const remote = await config.fetchRemote();
 	return {
-		configText: ActionConfigSerializer.serialize({ actions }),
-		hasExistingConfig: (await container.actionStorage.get()).exists
+		configText: config.serialize(remote),
+		hasExistingConfig: (await config.getStorage()).exists
 	};
 }
 
+//#endregion
+//#region src/core/application/action/captureAction.ts
+async function captureAction({ container }) {
+	return captureFromConfig({
+		fetchRemote: () => container.actionConfigurator.getActions(),
+		serialize: ({ actions }) => ActionConfigSerializer.serialize({ actions }),
+		getStorage: () => container.actionStorage.get()
+	});
+}
+
 //#endregion
 //#region src/core/application/action/saveAction.ts
 async function saveAction({ container, input }) {
@@ -2815,20 +2879,16 @@ var action_default = define({
 //#endregion
 //#region src/core/domain/adminNotes/services/configParser.ts
 const AdminNotesConfigParser = { parse: (rawText) => {
-	if (rawText.trim().length === 0) throw new BusinessRuleError(AdminNotesErrorCode.AnEmptyConfigText, "Admin notes config text is empty");
-	let parsed;
-	try {
-		parsed = parse(rawText);
-	} catch (error) {
-		throw new BusinessRuleError(AdminNotesErrorCode.AnInvalidConfigYaml, `Failed to parse YAML: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	if (!isRecord(parsed)) throw new BusinessRuleError(AdminNotesErrorCode.AnInvalidConfigStructure, "Config must be a YAML object");
-	const obj = parsed;
-	if (typeof obj.content !== "string") throw new BusinessRuleError(AdminNotesErrorCode.AnInvalidConfigStructure, "Config must have a \"content\" string property");
-	if (typeof obj.includeInTemplateAndDuplicates !== "boolean") throw new BusinessRuleError(AdminNotesErrorCode.AnInvalidConfigStructure, "Config must have an \"includeInTemplateAndDuplicates\" boolean property");
+	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: obj.content,
-		includeInTemplateAndDuplicates: obj.includeInTemplateAndDuplicates
+		content: parsed.content,
+		includeInTemplateAndDuplicates: parsed.includeInTemplateAndDuplicates
 	};
 } };
 
@@ -2841,13 +2901,17 @@ function parseAdminNotesConfigText(rawText) {
 //#endregion
 //#region src/core/application/adminNotes/applyAdminNotes.ts
 async function applyAdminNotes({ container }) {
-	const result = await container.adminNotesStorage.get();
-	if (!result.exists) throw new ValidationError(ValidationErrorCode.InvalidInput, "Admin notes config file not found");
-	const config = parseAdminNotesConfigText(result.content);
-	const current = await container.adminNotesConfigurator.getAdminNotes();
-	await container.adminNotesConfigurator.updateAdminNotes({
-		config,
-		revision: current.revision
+	await applyFromConfig({
+		getStorage: () => container.adminNotesStorage.get(),
+		parseConfig: parseAdminNotesConfigText,
+		fetchRemote: () => container.adminNotesConfigurator.getAdminNotes(),
+		update: async (config, current) => {
+			await container.adminNotesConfigurator.updateAdminNotes({
+				config,
+				revision: current.revision
+			});
+		},
+		notFoundMessage: "Admin notes config file not found"
 	});
 }
 
@@ -2903,11 +2967,7 @@ function createLocalFileAdminNotesStorage(filePath) {
 //#endregion
 //#region src/core/application/container/adminNotesCli.ts
 function createAdminNotesCliContainer(config) {
-	const client = new KintoneRestAPIClient({
-		baseUrl: config.baseUrl,
-		auth: buildKintoneAuth(config.auth),
-		guestSpaceId: config.guestSpaceId
-	});
+	const client = config.client ?? createKintoneClient(config);
 	return {
 		adminNotesConfigurator: new KintoneAdminNotesConfigurator(client, config.appId),
 		adminNotesStorage: createLocalFileAdminNotesStorage(config.adminNotesFilePath),
@@ -2986,24 +3046,20 @@ var apply_default$11 = define({
 //#endregion
 //#region src/core/domain/adminNotes/services/configSerializer.ts
 const AdminNotesConfigSerializer = { serialize: (config) => {
-	return stringify({
+	return serializeToYaml({
 		content: config.content,
 		includeInTemplateAndDuplicates: config.includeInTemplateAndDuplicates
-	}, {
-		lineWidth: 0,
-		defaultKeyType: "PLAIN",
-		defaultStringType: "PLAIN"
 	});
 } };
 
 //#endregion
 //#region src/core/application/adminNotes/captureAdminNotes.ts
 async function captureAdminNotes({ container }) {
-	const { config } = await container.adminNotesConfigurator.getAdminNotes();
-	return {
-		configText: AdminNotesConfigSerializer.serialize(config),
-		hasExistingConfig: (await container.adminNotesStorage.get()).exists
-	};
+	return captureFromConfig({
+		fetchRemote: () => container.adminNotesConfigurator.getAdminNotes(),
+		serialize: ({ config }) => AdminNotesConfigSerializer.serialize(config),
+		getStorage: () => container.adminNotesStorage.get()
+	});
 }
 
 //#endregion
@@ -3123,52 +3179,34 @@ const VALID_ENTITY_TYPES$8 = new Set([
 	"CREATOR"
 ]);
 function parseEntity$3(raw, index) {
-	if (!isRecord(raw)) throw new BusinessRuleError(AppPermissionErrorCode.ApInvalidConfigStructure, `Entity at index ${index} must be an object`);
-	const obj = raw;
-	if (typeof obj.type !== "string" || !VALID_ENTITY_TYPES$8.has(obj.type)) throw new BusinessRuleError(AppPermissionErrorCode.ApInvalidEntityType, `Entity at index ${index} has invalid type: ${String(obj.type)}. Must be USER, GROUP, ORGANIZATION, or CREATOR`);
-	const type = obj.type;
-	if (type === "CREATOR") return {
-		type,
-		code: typeof obj.code === "string" ? obj.code : ""
-	};
-	if (typeof obj.code !== "string" || obj.code.length === 0) throw new BusinessRuleError(AppPermissionErrorCode.ApEmptyEntityCode, `Entity at index ${index} must have a non-empty "code" property`);
-	return {
-		type,
-		code: obj.code
-	};
-}
-function parseBooleanField$1(obj, field, index) {
-	const value = obj[field];
-	if (typeof value !== "boolean") throw new BusinessRuleError(AppPermissionErrorCode.ApInvalidBooleanField, `App right at index ${index} must have a boolean "${field}" property`);
-	return value;
+	return parseEntityBase(raw, index, VALID_ENTITY_TYPES$8, {
+		invalidStructure: AppPermissionErrorCode.ApInvalidConfigStructure,
+		invalidType: AppPermissionErrorCode.ApInvalidEntityType,
+		emptyCode: AppPermissionErrorCode.ApEmptyEntityCode
+	}, { allowEmptyCode: (type) => type === "CREATOR" });
 }
 function parseAppRight(raw, index) {
 	if (!isRecord(raw)) throw new BusinessRuleError(AppPermissionErrorCode.ApInvalidConfigStructure, `App right at index ${index} must be an object`);
-	const obj = raw;
 	return {
-		entity: parseEntity$3(obj.entity, index),
-		includeSubs: parseBooleanField$1(obj, "includeSubs", index),
-		appEditable: parseBooleanField$1(obj, "appEditable", index),
-		recordViewable: parseBooleanField$1(obj, "recordViewable", index),
-		recordAddable: parseBooleanField$1(obj, "recordAddable", index),
-		recordEditable: parseBooleanField$1(obj, "recordEditable", index),
-		recordDeletable: parseBooleanField$1(obj, "recordDeletable", index),
-		recordImportable: parseBooleanField$1(obj, "recordImportable", index),
-		recordExportable: parseBooleanField$1(obj, "recordExportable", index)
+		entity: parseEntity$3(raw.entity, index),
+		includeSubs: parseStrictBoolean(raw.includeSubs, "includeSubs", `App right at index ${index}`, AppPermissionErrorCode.ApInvalidBooleanField),
+		appEditable: parseStrictBoolean(raw.appEditable, "appEditable", `App right at index ${index}`, AppPermissionErrorCode.ApInvalidBooleanField),
+		recordViewable: parseStrictBoolean(raw.recordViewable, "recordViewable", `App right at index ${index}`, AppPermissionErrorCode.ApInvalidBooleanField),
+		recordAddable: parseStrictBoolean(raw.recordAddable, "recordAddable", `App right at index ${index}`, AppPermissionErrorCode.ApInvalidBooleanField),
+		recordEditable: parseStrictBoolean(raw.recordEditable, "recordEditable", `App right at index ${index}`, AppPermissionErrorCode.ApInvalidBooleanField),
+		recordDeletable: parseStrictBoolean(raw.recordDeletable, "recordDeletable", `App right at index ${index}`, AppPermissionErrorCode.ApInvalidBooleanField),
+		recordImportable: parseStrictBoolean(raw.recordImportable, "recordImportable", `App right at index ${index}`, AppPermissionErrorCode.ApInvalidBooleanField),
+		recordExportable: parseStrictBoolean(raw.recordExportable, "recordExportable", `App right at index ${index}`, AppPermissionErrorCode.ApInvalidBooleanField)
 	};
 }
 const AppPermissionConfigParser = { parse: (rawText) => {
-	if (rawText.trim().length === 0) throw new BusinessRuleError(AppPermissionErrorCode.ApEmptyConfigText, "App permission config text is empty");
-	let parsed;
-	try {
-		parsed = parse(rawText);
-	} catch (error) {
-		throw new BusinessRuleError(AppPermissionErrorCode.ApInvalidConfigYaml, `Failed to parse YAML: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	if (!isRecord(parsed)) throw new BusinessRuleError(AppPermissionErrorCode.ApInvalidConfigStructure, "Config must be a YAML object");
-	const obj = parsed;
-	if (!Array.isArray(obj.rights)) throw new BusinessRuleError(AppPermissionErrorCode.ApInvalidConfigStructure, "Config must have a \"rights\" array");
-	const rights = obj.rights.map((item, i) => parseAppRight(item, i));
+	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 seenKeys = /* @__PURE__ */ new Set();
 	for (const right of rights) {
 		const key = `${right.entity.type}:${right.entity.code}`;
@@ -3187,13 +3225,17 @@ function parseAppPermissionConfigText(rawText) {
 //#endregion
 //#region src/core/application/appPermission/applyAppPermission.ts
 async function applyAppPermission({ container }) {
-	const result = await container.appPermissionStorage.get();
-	if (!result.exists) throw new ValidationError(ValidationErrorCode.InvalidInput, "App permission config file not found");
-	const config = parseAppPermissionConfigText(result.content);
-	const current = await container.appPermissionConfigurator.getAppPermissions();
-	await container.appPermissionConfigurator.updateAppPermissions({
-		rights: config.rights,
-		revision: current.revision
+	await applyFromConfig({
+		getStorage: () => container.appPermissionStorage.get(),
+		parseConfig: parseAppPermissionConfigText,
+		fetchRemote: () => container.appPermissionConfigurator.getAppPermissions(),
+		update: async (config, current) => {
+			await container.appPermissionConfigurator.updateAppPermissions({
+				rights: config.rights,
+				revision: current.revision
+			});
+		},
+		notFoundMessage: "App permission config file not found"
 	});
 }
 
@@ -3291,11 +3333,7 @@ function createLocalFileAppPermissionStorage(filePath) {
 //#endregion
 //#region src/core/application/container/appPermissionCli.ts
 function createAppPermissionCliContainer(config) {
-	const client = new KintoneRestAPIClient({
-		baseUrl: config.baseUrl,
-		auth: buildKintoneAuth(config.auth),
-		guestSpaceId: config.guestSpaceId
-	});
+	const client = config.client ?? createKintoneClient(config);
 	return {
 		appPermissionConfigurator: new KintoneAppPermissionConfigurator(client, config.appId),
 		appPermissionStorage: createLocalFileAppPermissionStorage(config.appAclFilePath),
@@ -3390,21 +3428,17 @@ function serializeAppRight(right) {
 	};
 }
 const AppPermissionConfigSerializer = { serialize: (config) => {
-	return stringify({ rights: config.rights.map(serializeAppRight) }, {
-		lineWidth: 0,
-		defaultKeyType: "PLAIN",
-		defaultStringType: "PLAIN"
-	});
+	return serializeToYaml({ rights: config.rights.map(serializeAppRight) });
 } };
 
 //#endregion
 //#region src/core/application/appPermission/captureAppPermission.ts
 async function captureAppPermission({ container }) {
-	const { rights } = await container.appPermissionConfigurator.getAppPermissions();
-	return {
-		configText: AppPermissionConfigSerializer.serialize({ rights }),
-		hasExistingConfig: (await container.appPermissionStorage.get()).exists
-	};
+	return captureFromConfig({
+		fetchRemote: () => container.appPermissionConfigurator.getAppPermissions(),
+		serialize: ({ rights }) => AppPermissionConfigSerializer.serialize({ rights }),
+		getStorage: () => container.appPermissionStorage.get()
+	});
 }
 
 //#endregion
@@ -3840,8 +3874,8 @@ function planResources(resources, platformDir, resourceType, relativeBaseDir) {
 		filesToDownload
 	};
 }
-function planPlatform(remotePlatform, platformName, args) {
-	const platformDir = join(args.input.basePath, args.input.filePrefix, platformName);
+function planPlatform(remotePlatform, platformName, basePath, filePrefix) {
+	const platformDir = join(basePath, filePrefix, platformName);
 	const platformPrefix = platformName;
 	const jsPlan = planResources(remotePlatform.js, platformDir, "js", platformPrefix);
 	const cssPlan = planResources(remotePlatform.css, platformDir, "css", platformPrefix);
@@ -3869,18 +3903,18 @@ async function downloadFiles(files, container) {
 		await container.fileWriter.write(file.absolutePath, data);
 	}));
 }
-async function captureCustomization(args) {
-	const existing = await args.container.customizationStorage.get();
-	const { scope, desktop, mobile } = await args.container.customizationConfigurator.getCustomization();
-	const desktopPlan = planPlatform(desktop, "desktop", args);
-	const mobilePlan = planPlatform(mobile, "mobile", args);
+async function captureCustomization({ container, input }) {
+	const existing = await container.customizationStorage.get();
+	const { scope, desktop, mobile } = await container.customizationConfigurator.getCustomization();
+	const desktopPlan = planPlatform(desktop, "desktop", input.basePath, input.filePrefix);
+	const mobilePlan = planPlatform(mobile, "mobile", input.basePath, input.filePrefix);
 	const config = {
 		scope,
 		desktop: desktopPlan.platform,
 		mobile: mobilePlan.platform
 	};
 	const configText = CustomizationConfigSerializer.serialize(config);
-	await downloadFiles([...desktopPlan.filesToDownload, ...mobilePlan.filesToDownload], args.container);
+	await downloadFiles([...desktopPlan.filesToDownload, ...mobilePlan.filesToDownload], container);
 	return {
 		configText,
 		hasExistingConfig: existing.exists,
@@ -4208,11 +4242,7 @@ function createLocalFileFieldPermissionStorage(filePath) {
 //#endregion
 //#region src/core/application/container/fieldPermissionCli.ts
 function createFieldPermissionCliContainer(config) {
-	const client = new KintoneRestAPIClient({
-		baseUrl: config.baseUrl,
-		auth: buildKintoneAuth(config.auth),
-		guestSpaceId: config.guestSpaceId
-	});
+	const client = config.client ?? createKintoneClient(config);
 	return {
 		fieldPermissionConfigurator: new KintoneFieldPermissionConfigurator(client, config.appId),
 		fieldPermissionStorage: createLocalFileFieldPermissionStorage(config.fieldAclFilePath),
@@ -4234,53 +4264,42 @@ const VALID_ENTITY_TYPES$5 = new Set([
 	"FIELD_ENTITY"
 ]);
 function parseEntity$2(raw, index) {
-	if (!isRecord(raw)) throw new BusinessRuleError(FieldPermissionErrorCode.FpInvalidConfigStructure, `Entity at index ${index} must be an object`);
-	const obj = raw;
-	if (typeof obj.type !== "string" || !VALID_ENTITY_TYPES$5.has(obj.type)) throw new BusinessRuleError(FieldPermissionErrorCode.FpInvalidEntityType, `Entity at index ${index} has invalid type: ${String(obj.type)}. Must be USER, GROUP, ORGANIZATION, or FIELD_ENTITY`);
-	if (typeof obj.code !== "string" || obj.code.length === 0) throw new BusinessRuleError(FieldPermissionErrorCode.FpEmptyEntityCode, `Entity at index ${index} must have a non-empty "code" property`);
-	return {
-		type: obj.type,
-		code: obj.code
-	};
+	return parseEntityBase(raw, index, VALID_ENTITY_TYPES$5, {
+		invalidStructure: FieldPermissionErrorCode.FpInvalidConfigStructure,
+		invalidType: FieldPermissionErrorCode.FpInvalidEntityType,
+		emptyCode: FieldPermissionErrorCode.FpEmptyEntityCode
+	});
 }
 function parseFieldRightEntity(raw, index) {
 	if (!isRecord(raw)) throw new BusinessRuleError(FieldPermissionErrorCode.FpInvalidConfigStructure, `Field right entity at index ${index} must be an object`);
-	const obj = raw;
-	if (typeof obj.accessibility !== "string" || !VALID_ACCESSIBILITIES.has(obj.accessibility)) throw new BusinessRuleError(FieldPermissionErrorCode.FpInvalidAccessibility, `Field right entity at index ${index} has invalid accessibility: ${String(obj.accessibility)}. Must be READ, WRITE, or NONE`);
-	const entity = parseEntity$2(obj.entity, index);
 	const result = {
-		accessibility: obj.accessibility,
-		entity
+		accessibility: parseEnum(raw.accessibility, VALID_ACCESSIBILITIES, FieldPermissionErrorCode.FpInvalidAccessibility, `Field right entity at index ${index} has invalid accessibility: ${String(raw.accessibility)}. Must be READ, WRITE, or NONE`),
+		entity: parseEntity$2(raw.entity, index)
 	};
-	if (obj.includeSubs !== void 0 && obj.includeSubs !== null) return {
+	if (raw.includeSubs !== void 0 && raw.includeSubs !== null) return {
 		...result,
-		includeSubs: Boolean(obj.includeSubs)
+		includeSubs: parseStrictBoolean(raw.includeSubs, "includeSubs", `Field right entity at index ${index}`, FieldPermissionErrorCode.FpInvalidBooleanField)
 	};
 	return result;
 }
 function parseFieldRight(raw, index) {
 	if (!isRecord(raw)) throw new BusinessRuleError(FieldPermissionErrorCode.FpInvalidConfigStructure, `Field right at index ${index} must be an object`);
-	const obj = raw;
-	if (typeof obj.code !== "string" || obj.code.length === 0) throw new BusinessRuleError(FieldPermissionErrorCode.FpEmptyFieldCode, `Field right at index ${index} must have a non-empty "code" property`);
-	if (!Array.isArray(obj.entities)) throw new BusinessRuleError(FieldPermissionErrorCode.FpInvalidConfigStructure, `Field right at index ${index} must have an "entities" array`);
-	const entities = obj.entities.map((item, i) => parseFieldRightEntity(item, i));
+	if (typeof raw.code !== "string" || raw.code.length === 0) throw new BusinessRuleError(FieldPermissionErrorCode.FpEmptyFieldCode, `Field right at index ${index} must have a non-empty "code" property`);
+	if (!Array.isArray(raw.entities)) throw new BusinessRuleError(FieldPermissionErrorCode.FpInvalidConfigStructure, `Field right at index ${index} must have an "entities" array`);
+	const entities = raw.entities.map((item, i) => parseFieldRightEntity(item, i));
 	return {
-		code: obj.code,
+		code: raw.code,
 		entities
 	};
 }
 const FieldPermissionConfigParser = { parse: (rawText) => {
-	if (rawText.trim().length === 0) throw new BusinessRuleError(FieldPermissionErrorCode.FpEmptyConfigText, "Field permission config text is empty");
-	let parsed;
-	try {
-		parsed = parse(rawText);
-	} catch (error) {
-		throw new BusinessRuleError(FieldPermissionErrorCode.FpInvalidConfigYaml, `Failed to parse YAML: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	if (!isRecord(parsed)) throw new BusinessRuleError(FieldPermissionErrorCode.FpInvalidConfigStructure, "Config must be a YAML object");
-	const obj = parsed;
-	if (!Array.isArray(obj.rights)) throw new BusinessRuleError(FieldPermissionErrorCode.FpInvalidConfigStructure, "Config must have a \"rights\" array");
-	const rights = obj.rights.map((item, i) => parseFieldRight(item, i));
+	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 seenCodes = /* @__PURE__ */ new Set();
 	for (const right of rights) {
 		if (seenCodes.has(right.code)) throw new BusinessRuleError(FieldPermissionErrorCode.FpDuplicateFieldCode, `Duplicate field code: ${right.code}`);
@@ -4298,13 +4317,17 @@ function parseFieldPermissionConfigText(rawText) {
 //#endregion
 //#region src/core/application/fieldPermission/applyFieldPermission.ts
 async function applyFieldPermission({ container }) {
-	const result = await container.fieldPermissionStorage.get();
-	if (!result.exists) throw new ValidationError(ValidationErrorCode.InvalidInput, "Field permission config file not found");
-	const config = parseFieldPermissionConfigText(result.content);
-	const current = await container.fieldPermissionConfigurator.getFieldPermissions();
-	await container.fieldPermissionConfigurator.updateFieldPermissions({
-		rights: config.rights,
-		revision: current.revision
+	await applyFromConfig({
+		getStorage: () => container.fieldPermissionStorage.get(),
+		parseConfig: parseFieldPermissionConfigText,
+		fetchRemote: () => container.fieldPermissionConfigurator.getFieldPermissions(),
+		update: async (config, current) => {
+			await container.fieldPermissionConfigurator.updateFieldPermissions({
+				rights: config.rights,
+				revision: current.revision
+			});
+		},
+		notFoundMessage: "Field permission config file not found"
 	});
 }
 
@@ -4390,24 +4413,20 @@ function serializeFieldRightEntity(entity) {
 	return result;
 }
 const FieldPermissionConfigSerializer = { serialize: (config) => {
-	return stringify({ rights: config.rights.map((right) => ({
+	return serializeToYaml({ rights: config.rights.map((right) => ({
 		code: right.code,
 		entities: right.entities.map(serializeFieldRightEntity)
-	})) }, {
-		lineWidth: 0,
-		defaultKeyType: "PLAIN",
-		defaultStringType: "PLAIN"
-	});
+	})) });
 } };
 
 //#endregion
 //#region src/core/application/fieldPermission/captureFieldPermission.ts
 async function captureFieldPermission({ container }) {
-	const { rights } = await container.fieldPermissionConfigurator.getFieldPermissions();
-	return {
-		configText: FieldPermissionConfigSerializer.serialize({ rights }),
-		hasExistingConfig: (await container.fieldPermissionStorage.get()).exists
-	};
+	return captureFromConfig({
+		fetchRemote: () => container.fieldPermissionConfigurator.getFieldPermissions(),
+		serialize: ({ rights }) => FieldPermissionConfigSerializer.serialize({ rights }),
+		getStorage: () => container.fieldPermissionStorage.get()
+	});
 }
 
 //#endregion
@@ -4461,7 +4480,7 @@ var capture_default$9 = define({
 
 //#endregion
 //#region src/core/domain/fieldPermission/services/diffDetector.ts
-function areEntitiesEqual(a, b) {
+function isEntitiesEqual$1(a, b) {
 	return deepEqual(a.entities.map((e) => ({
 		accessibility: e.accessibility,
 		type: e.entity.type,
@@ -4485,7 +4504,7 @@ const FieldPermissionDiffDetector = { detect: (local, remote) => {
 			fieldCode: code,
 			details: `${localRight.entities.length} entities`
 		});
-		else if (!areEntitiesEqual(localRight, remoteRight)) entries.push({
+		else if (!isEntitiesEqual$1(localRight, remoteRight)) entries.push({
 			type: "modified",
 			fieldCode: code,
 			details: "entities changed"
@@ -4684,11 +4703,7 @@ function createLocalFileGeneralSettingsStorage(filePath) {
 //#endregion
 //#region src/core/application/container/generalSettingsCli.ts
 function createGeneralSettingsCliContainer(config) {
-	const client = new KintoneRestAPIClient({
-		baseUrl: config.baseUrl,
-		auth: buildKintoneAuth(config.auth),
-		guestSpaceId: config.guestSpaceId
-	});
+	const client = config.client ?? createKintoneClient(config);
 	return {
 		generalSettingsConfigurator: new KintoneGeneralSettingsConfigurator(client, config.appId),
 		generalSettingsStorage: createLocalFileGeneralSettingsStorage(config.settingsFilePath),
@@ -4929,11 +4944,7 @@ function createLocalFileNotificationStorage(filePath) {
 //#endregion
 //#region src/core/application/container/notificationCli.ts
 function createNotificationCliContainer(config) {
-	const client = new KintoneRestAPIClient({
-		baseUrl: config.baseUrl,
-		auth: buildKintoneAuth(config.auth),
-		guestSpaceId: config.guestSpaceId
-	});
+	const client = config.client ?? createKintoneClient(config);
 	return {
 		notificationConfigurator: new KintoneNotificationConfigurator(client, config.appId),
 		notificationStorage: createLocalFileNotificationStorage(config.notificationFilePath),
@@ -4992,11 +5003,7 @@ function createLocalFilePluginStorage(filePath) {
 //#endregion
 //#region src/core/application/container/pluginCli.ts
 function createPluginCliContainer(config) {
-	const client = new KintoneRestAPIClient({
-		baseUrl: config.baseUrl,
-		auth: buildKintoneAuth(config.auth),
-		guestSpaceId: config.guestSpaceId
-	});
+	const client = config.client ?? createKintoneClient(config);
 	return {
 		pluginConfigurator: new KintonePluginConfigurator(client, config.appId),
 		pluginStorage: createLocalFilePluginStorage(config.pluginFilePath),
@@ -5149,11 +5156,7 @@ function createLocalFileProcessManagementStorage(filePath) {
 //#endregion
 //#region src/core/application/container/processManagementCli.ts
 function createProcessManagementCliContainer(config) {
-	const client = new KintoneRestAPIClient({
-		baseUrl: config.baseUrl,
-		auth: buildKintoneAuth(config.auth),
-		guestSpaceId: config.guestSpaceId
-	});
+	const client = config.client ?? createKintoneClient(config);
 	return {
 		processManagementConfigurator: new KintoneProcessManagementConfigurator(client, config.appId),
 		processManagementStorage: createLocalFileProcessManagementStorage(config.processFilePath),
@@ -5252,11 +5255,7 @@ function createLocalFileRecordPermissionStorage(filePath) {
 //#endregion
 //#region src/core/application/container/recordPermissionCli.ts
 function createRecordPermissionCliContainer(config) {
-	const client = new KintoneRestAPIClient({
-		baseUrl: config.baseUrl,
-		auth: buildKintoneAuth(config.auth),
-		guestSpaceId: config.guestSpaceId
-	});
+	const client = config.client ?? createKintoneClient(config);
 	return {
 		recordPermissionConfigurator: new KintoneRecordPermissionConfigurator(client, config.appId),
 		recordPermissionStorage: createLocalFileRecordPermissionStorage(config.recordAclFilePath),
@@ -5547,11 +5546,7 @@ function createLocalFileReportStorage(filePath) {
 //#endregion
 //#region src/core/application/container/reportCli.ts
 function createReportCliContainer(config) {
-	const client = new KintoneRestAPIClient({
-		baseUrl: config.baseUrl,
-		auth: buildKintoneAuth(config.auth),
-		guestSpaceId: config.guestSpaceId
-	});
+	const client = config.client ?? createKintoneClient(config);
 	return {
 		reportConfigurator: new KintoneReportConfigurator(client, config.appId),
 		reportStorage: createLocalFileReportStorage(config.reportFilePath),
@@ -5673,11 +5668,7 @@ function createLocalFileViewStorage(filePath) {
 //#endregion
 //#region src/core/application/container/viewCli.ts
 function createViewCliContainer(config) {
-	const client = new KintoneRestAPIClient({
-		baseUrl: config.baseUrl,
-		auth: buildKintoneAuth(config.auth),
-		guestSpaceId: config.guestSpaceId
-	});
+	const client = config.client ?? createKintoneClient(config);
 	return {
 		viewConfigurator: new KintoneViewConfigurator(client, config.appId),
 		viewStorage: createLocalFileViewStorage(config.viewFilePath),
@@ -5688,11 +5679,13 @@ function createViewCliContainer(config) {
 //#endregion
 //#region src/core/application/container/captureAllCli.ts
 function createCliCaptureContainers(input) {
+	const client = createKintoneClient(input);
 	const base = {
 		baseUrl: input.baseUrl,
 		auth: input.auth,
 		appId: input.appId,
-		guestSpaceId: input.guestSpaceId
+		guestSpaceId: input.guestSpaceId,
+		client
 	};
 	const paths = buildAppFilePaths(input.appName, input.baseDir);
 	return {
@@ -5813,11 +5806,7 @@ function createLocalFileProjectConfigStorage(filePath) {
 //#region src/core/application/container/initCli.ts
 function createInitCliContainer(config) {
 	return {
-		spaceReader: new KintoneSpaceReader(new KintoneRestAPIClient({
-			baseUrl: config.baseUrl,
-			auth: buildKintoneAuth(config.auth),
-			guestSpaceId: config.guestSpaceId
-		})),
+		spaceReader: new KintoneSpaceReader(config.client ?? createKintoneClient(config)),
 		projectConfigStorage: createLocalFileProjectConfigStorage(config.configFilePath)
 	};
 }
@@ -6031,21 +6020,17 @@ function serializeConfig(config) {
 	return result;
 }
 const GeneralSettingsConfigSerializer = { serialize: (config) => {
-	return stringify(serializeConfig(config), {
-		lineWidth: 0,
-		defaultKeyType: "PLAIN",
-		defaultStringType: "PLAIN"
-	});
+	return serializeToYaml(serializeConfig(config));
 } };
 
 //#endregion
 //#region src/core/application/generalSettings/captureGeneralSettings.ts
 async function captureGeneralSettings({ container }) {
-	const { config } = await container.generalSettingsConfigurator.getGeneralSettings();
-	return {
-		configText: GeneralSettingsConfigSerializer.serialize(config),
-		hasExistingConfig: (await container.generalSettingsStorage.get()).exists
-	};
+	return captureFromConfig({
+		fetchRemote: () => container.generalSettingsConfigurator.getGeneralSettings(),
+		serialize: ({ config }) => GeneralSettingsConfigSerializer.serialize(config),
+		getStorage: () => container.generalSettingsStorage.get()
+	});
 }
 
 //#endregion
@@ -6115,9 +6100,11 @@ const NotificationConfigSerializer = { serialize: (config) => {
 //#endregion
 //#region src/core/application/notification/captureNotification.ts
 async function captureNotification({ container }) {
-	const general = await container.notificationConfigurator.getGeneralNotifications();
-	const perRecord = await container.notificationConfigurator.getPerRecordNotifications();
-	const reminder = await container.notificationConfigurator.getReminderNotifications();
+	const [general, perRecord, reminder] = await Promise.all([
+		container.notificationConfigurator.getGeneralNotifications(),
+		container.notificationConfigurator.getPerRecordNotifications(),
+		container.notificationConfigurator.getReminderNotifications()
+	]);
 	const config = {
 		general: {
 			notifyToCommenter: general.notifyToCommenter,
@@ -6154,11 +6141,11 @@ const PluginConfigSerializer = { serialize: (config) => {
 //#endregion
 //#region src/core/application/plugin/capturePlugin.ts
 async function capturePlugin({ container }) {
-	const { plugins } = await container.pluginConfigurator.getPlugins();
-	return {
-		configText: PluginConfigSerializer.serialize({ plugins }),
-		hasExistingConfig: (await container.pluginStorage.get()).exists
-	};
+	return captureFromConfig({
+		fetchRemote: () => container.pluginConfigurator.getPlugins(),
+		serialize: ({ plugins }) => PluginConfigSerializer.serialize({ plugins }),
+		getStorage: () => container.pluginStorage.get()
+	});
 }
 
 //#endregion
@@ -6184,7 +6171,7 @@ const ProcessManagementConfigSerializer = { serialize: (config) => {
 			entities: state.assignee.entities.map(serializeProcessEntity)
 		}
 	};
-	return stringify({
+	return serializeToYaml({
 		enable: config.enable,
 		states: serializedStates,
 		actions: config.actions.map((action) => {
@@ -6198,21 +6185,17 @@ const ProcessManagementConfigSerializer = { serialize: (config) => {
 			if (action.executableUser !== void 0) serializedAction.executableUser = { entities: action.executableUser.entities.map(serializeProcessEntity) };
 			return serializedAction;
 		})
-	}, {
-		lineWidth: 0,
-		defaultKeyType: "PLAIN",
-		defaultStringType: "PLAIN"
 	});
 } };
 
 //#endregion
 //#region src/core/application/processManagement/captureProcessManagement.ts
 async function captureProcessManagement({ container }) {
-	const { config } = await container.processManagementConfigurator.getProcessManagement();
-	return {
-		configText: ProcessManagementConfigSerializer.serialize(config),
-		hasExistingConfig: (await container.processManagementStorage.get()).exists
-	};
+	return captureFromConfig({
+		fetchRemote: () => container.processManagementConfigurator.getProcessManagement(),
+		serialize: ({ config }) => ProcessManagementConfigSerializer.serialize(config),
+		getStorage: () => container.processManagementStorage.get()
+	});
 }
 
 //#endregion
@@ -6236,24 +6219,20 @@ function serializeRecordRightEntity(entity) {
 	};
 }
 const RecordPermissionConfigSerializer = { serialize: (config) => {
-	return stringify({ rights: config.rights.map((right) => ({
+	return serializeToYaml({ rights: config.rights.map((right) => ({
 		filterCond: right.filterCond,
 		entities: right.entities.map(serializeRecordRightEntity)
-	})) }, {
-		lineWidth: 0,
-		defaultKeyType: "PLAIN",
-		defaultStringType: "PLAIN"
-	});
+	})) });
 } };
 
 //#endregion
 //#region src/core/application/recordPermission/captureRecordPermission.ts
 async function captureRecordPermission({ container }) {
-	const { rights } = await container.recordPermissionConfigurator.getRecordPermissions();
-	return {
-		configText: RecordPermissionConfigSerializer.serialize({ rights }),
-		hasExistingConfig: (await container.recordPermissionStorage.get()).exists
-	};
+	return captureFromConfig({
+		fetchRemote: () => container.recordPermissionConfigurator.getRecordPermissions(),
+		serialize: ({ rights }) => RecordPermissionConfigSerializer.serialize({ rights }),
+		getStorage: () => container.recordPermissionStorage.get()
+	});
 }
 
 //#endregion
@@ -6320,11 +6299,11 @@ const ReportConfigSerializer = { serialize: (config) => {
 //#endregion
 //#region src/core/application/report/captureReport.ts
 async function captureReport({ container }) {
-	const { reports } = await container.reportConfigurator.getReports();
-	return {
-		configText: ReportConfigSerializer.serialize({ reports }),
-		hasExistingConfig: (await container.reportStorage.get()).exists
-	};
+	return captureFromConfig({
+		fetchRemote: () => container.reportConfigurator.getReports(),
+		serialize: ({ reports }) => ReportConfigSerializer.serialize({ reports }),
+		getStorage: () => container.reportStorage.get()
+	});
 }
 
 //#endregion
@@ -6404,11 +6383,11 @@ const ViewConfigSerializer = { serialize: (config) => {
 //#endregion
 //#region src/core/application/view/captureView.ts
 async function captureView({ container }) {
-	const { views } = await container.viewConfigurator.getViews();
-	return {
-		configText: ViewConfigSerializer.serialize({ views }),
-		hasExistingConfig: (await container.viewStorage.get()).exists
-	};
+	return captureFromConfig({
+		fetchRemote: () => container.viewConfigurator.getViews(),
+		serialize: ({ views }) => ViewConfigSerializer.serialize({ views }),
+		getStorage: () => container.viewStorage.get()
+	});
 }
 
 //#endregion
@@ -6607,12 +6586,11 @@ function generateProjectConfig(input) {
 			files: buildAppFilePaths(name, input.baseDir)
 		};
 	}
-	const config = {
+	return stringify({
 		domain: input.domain,
+		...input.guestSpaceId !== void 0 ? { guestSpaceId: input.guestSpaceId } : {},
 		apps
-	};
-	if (input.guestSpaceId !== void 0) config.guestSpaceId = input.guestSpaceId;
-	return stringify(config, { lineWidth: 0 });
+	}, { lineWidth: 0 });
 }
 
 //#endregion
@@ -6872,6 +6850,15 @@ function parseNotificationConfigText(rawText) {
 
 //#endregion
 //#region src/core/application/notification/applyNotification.ts
+/**
+* Apply notification settings to kintone.
+*
+* Each notification section (general, perRecord, reminder) is updated
+* independently via separate API calls. If one section fails after others
+* have already been applied, the app will be in a partially-updated state.
+* This is a kintone API limitation — there is no transactional update
+* across notification types. Re-running the command is safe and idempotent.
+*/
 async function applyNotification({ container }) {
 	const result = await container.notificationStorage.get();
 	if (!result.exists) throw new ValidationError(ValidationErrorCode.InvalidInput, "Notification config file not found");
@@ -7520,85 +7507,77 @@ const VALID_ENTITY_TYPES$1 = new Set([
 const VALID_ACTION_TYPES = new Set(["PRIMARY", "SECONDARY"]);
 function parseProcessEntity(raw, index) {
 	if (!isRecord(raw)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `Entity at index ${index} must be an object`);
-	const obj = raw;
-	if (typeof obj.type !== "string" || !VALID_ENTITY_TYPES$1.has(obj.type)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidEntityType, `Entity at index ${index} has invalid type: ${String(obj.type)}. Must be USER, GROUP, ORGANIZATION, FIELD_ENTITY, CREATOR, or CUSTOM_FIELD`);
-	const result = { type: obj.type };
-	const withCode = obj.code !== void 0 && obj.code !== null ? {
+	const result = { type: parseEnum(raw.type, VALID_ENTITY_TYPES$1, ProcessManagementErrorCode.PmInvalidEntityType, `Entity at index ${index} has invalid type: ${String(raw.type)}. Must be USER, GROUP, ORGANIZATION, FIELD_ENTITY, CREATOR, or CUSTOM_FIELD`) };
+	const withCode = raw.code !== void 0 && raw.code !== null ? {
 		...result,
-		code: String(obj.code)
+		code: String(raw.code)
 	} : result;
-	if (obj.includeSubs !== void 0 && obj.includeSubs !== null) return {
+	if (raw.includeSubs !== void 0 && raw.includeSubs !== null) return {
 		...withCode,
-		includeSubs: Boolean(obj.includeSubs)
+		includeSubs: parseStrictBoolean(raw.includeSubs, "includeSubs", `Entity at index ${index}`, ProcessManagementErrorCode.PmInvalidBooleanField)
 	};
 	return withCode;
 }
 function parseAssignee(raw, stateName) {
 	if (!isRecord(raw)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `Assignee for state "${stateName}" must be an object`);
-	const obj = raw;
-	if (typeof obj.type !== "string" || !VALID_ASSIGNEE_TYPES.has(obj.type)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidAssigneeType, `Assignee for state "${stateName}" has invalid type: ${String(obj.type)}. Must be ONE, ALL, or ANY`);
-	if (!Array.isArray(obj.entities)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `Assignee for state "${stateName}" must have an "entities" array`);
-	const entities = obj.entities.map((item, i) => parseProcessEntity(item, i));
+	if (!Array.isArray(raw.entities)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `Assignee for state "${stateName}" must have an "entities" array`);
 	return {
-		type: obj.type,
-		entities
+		type: parseEnum(raw.type, VALID_ASSIGNEE_TYPES, ProcessManagementErrorCode.PmInvalidAssigneeType, `Assignee for state "${stateName}" has invalid type: ${String(raw.type)}. Must be ONE, ALL, or ANY`),
+		entities: raw.entities.map((item, i) => parseProcessEntity(item, i))
 	};
 }
 function parseState(raw, stateName) {
 	if (!isRecord(raw)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `State "${stateName}" must be an object`);
-	const obj = raw;
-	if (typeof obj.index !== "number") throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `State "${stateName}" must have a numeric "index" property`);
-	if (obj.assignee === void 0 || obj.assignee === null) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `State "${stateName}" must have an "assignee" property`);
-	const assignee = parseAssignee(obj.assignee, stateName);
+	if (typeof raw.index !== "number") throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `State "${stateName}" must have a numeric "index" property`);
+	if (raw.assignee === void 0 || raw.assignee === null) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `State "${stateName}" must have an "assignee" property`);
+	const assignee = parseAssignee(raw.assignee, stateName);
 	return {
-		index: obj.index,
+		index: raw.index,
 		assignee
 	};
 }
 function parseExecutableUser(raw, actionIndex) {
 	if (!isRecord(raw)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `Action at index ${actionIndex}: executableUser must be an object`);
-	const obj = raw;
-	if (!Array.isArray(obj.entities)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `Action at index ${actionIndex}: executableUser must have an "entities" array`);
-	return { entities: obj.entities.map((item, i) => parseProcessEntity(item, i)) };
+	if (!Array.isArray(raw.entities)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `Action at index ${actionIndex}: executableUser must have an "entities" array`);
+	return { entities: raw.entities.map((item, i) => parseProcessEntity(item, i)) };
 }
 function parseAction(raw, index) {
 	if (!isRecord(raw)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `Action at index ${index} must be an object`);
-	const obj = raw;
-	if (typeof obj.name !== "string") throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `Action at index ${index} must have a "name" string property`);
-	if (typeof obj.from !== "string") throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `Action at index ${index} must have a "from" string property`);
-	if (typeof obj.to !== "string") throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `Action at index ${index} must have a "to" string property`);
-	if (obj.type !== void 0 && obj.type !== null && (typeof obj.type !== "string" || !VALID_ACTION_TYPES.has(obj.type))) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `Action at index ${index} has invalid type: ${String(obj.type)}. Must be PRIMARY or SECONDARY`);
-	const actionType = typeof obj.type === "string" && VALID_ACTION_TYPES.has(obj.type) ? obj.type : "PRIMARY";
+	if (typeof raw.name !== "string") throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `Action at index ${index} must have a "name" string property`);
+	if (typeof raw.from !== "string") throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `Action at index ${index} must have a "from" string property`);
+	if (typeof raw.to !== "string") throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, `Action at index ${index} must have a "to" string property`);
+	const actionType = raw.type === void 0 || raw.type === null ? "PRIMARY" : parseEnum(raw.type, VALID_ACTION_TYPES, ProcessManagementErrorCode.PmInvalidConfigStructure, `Action at index ${index} has invalid type: ${String(raw.type)}. Must be PRIMARY or SECONDARY`);
 	const result = {
-		name: obj.name,
-		from: obj.from,
-		to: obj.to,
-		filterCond: typeof obj.filterCond === "string" ? obj.filterCond : "",
+		name: raw.name,
+		from: raw.from,
+		to: raw.to,
+		filterCond: typeof raw.filterCond === "string" ? raw.filterCond : "",
 		type: actionType
 	};
-	if (actionType === "SECONDARY" && obj.executableUser !== void 0 && obj.executableUser !== null) return {
+	if (actionType === "SECONDARY" && raw.executableUser !== void 0 && raw.executableUser !== null) return {
 		...result,
-		executableUser: parseExecutableUser(obj.executableUser, index)
+		executableUser: parseExecutableUser(raw.executableUser, index)
 	};
 	return result;
 }
 const ProcessManagementConfigParser = { parse: (rawText) => {
-	if (rawText.trim().length === 0) throw new BusinessRuleError(ProcessManagementErrorCode.PmEmptyConfigText, "Process management config text is empty");
-	let parsed;
-	try {
-		parsed = parse(rawText);
-	} catch (error) {
-		throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigYaml, `Failed to parse YAML: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	if (!isRecord(parsed)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, "Config must be a YAML object");
-	const obj = parsed;
-	const enable = obj.enable !== void 0 && obj.enable !== null ? Boolean(obj.enable) : false;
-	if (obj.states !== void 0 && obj.states !== null && !isRecord(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 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 states = {};
 	for (const [name, value] of Object.entries(rawStates)) states[name] = parseState(value, name);
-	if (!Array.isArray(obj.actions) && obj.actions !== void 0) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidConfigStructure, "Config \"actions\" must be an array");
-	const actions = (obj.actions ?? []).map((item, i) => parseAction(item, i));
+	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));
+	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}"`);
+		actionNames.add(action.name);
+	}
 	const stateNames = new Set(Object.keys(states));
 	for (const action of actions) {
 		if (!stateNames.has(action.from)) throw new BusinessRuleError(ProcessManagementErrorCode.PmInvalidActionReference, `Action "${action.name}" references unknown "from" state: "${action.from}"`);
@@ -7751,7 +7730,7 @@ var capture_default$6 = define({
 //#region src/core/domain/processManagement/services/diffDetector.ts
 function isEntityEqual(a, b) {
 	if (a.type !== b.type) return false;
-	if (a.code !== b.code) return false;
+	if ((a.code ?? "") !== (b.code ?? "")) return false;
 	if (Boolean(a.includeSubs) !== Boolean(b.includeSubs)) return false;
 	return true;
 }
@@ -7889,56 +7868,51 @@ const VALID_ENTITY_TYPES = new Set([
 	"ORGANIZATION",
 	"FIELD_ENTITY"
 ]);
-function parseBooleanField(value, fieldName, context) {
-	if (value === void 0) return false;
-	if (typeof value === "boolean") return value;
-	throw new BusinessRuleError(RecordPermissionErrorCode.RpInvalidPermissionValue, `${context} has invalid "${fieldName}" value: ${String(value)}. Must be a boolean`);
-}
 function parseEntity(raw, index) {
-	if (!isRecord(raw)) throw new BusinessRuleError(RecordPermissionErrorCode.RpInvalidConfigStructure, `Entity at index ${index} must be an object`);
-	const obj = raw;
-	if (typeof obj.type !== "string" || !VALID_ENTITY_TYPES.has(obj.type)) throw new BusinessRuleError(RecordPermissionErrorCode.RpInvalidEntityType, `Entity at index ${index} has invalid type: ${String(obj.type)}. Must be USER, GROUP, ORGANIZATION, or FIELD_ENTITY`);
-	if (typeof obj.code !== "string" || obj.code.length === 0) throw new BusinessRuleError(RecordPermissionErrorCode.RpEmptyEntityCode, `Entity at index ${index} must have a non-empty "code" property`);
-	return {
-		type: obj.type,
-		code: obj.code
-	};
+	return parseEntityBase(raw, index, VALID_ENTITY_TYPES, {
+		invalidStructure: RecordPermissionErrorCode.RpInvalidConfigStructure,
+		invalidType: RecordPermissionErrorCode.RpInvalidEntityType,
+		emptyCode: RecordPermissionErrorCode.RpEmptyEntityCode
+	});
 }
 function parseRecordRightEntity(raw, index) {
 	if (!isRecord(raw)) throw new BusinessRuleError(RecordPermissionErrorCode.RpInvalidConfigStructure, `Record right entity at index ${index} must be an object`);
-	const obj = raw;
-	const entity = parseEntity(obj.entity, index);
+	const entity = parseEntity(raw.entity, index);
 	const context = `Record right entity at index ${index}`;
 	return {
 		entity,
-		viewable: parseBooleanField(obj.viewable, "viewable", context),
-		editable: parseBooleanField(obj.editable, "editable", context),
-		deletable: parseBooleanField(obj.deletable, "deletable", context),
-		includeSubs: parseBooleanField(obj.includeSubs, "includeSubs", context)
+		viewable: parseStrictBoolean(raw.viewable, "viewable", context, RecordPermissionErrorCode.RpInvalidPermissionValue, false),
+		editable: parseStrictBoolean(raw.editable, "editable", context, RecordPermissionErrorCode.RpInvalidPermissionValue, false),
+		deletable: parseStrictBoolean(raw.deletable, "deletable", context, RecordPermissionErrorCode.RpInvalidPermissionValue, false),
+		includeSubs: parseStrictBoolean(raw.includeSubs, "includeSubs", context, RecordPermissionErrorCode.RpInvalidPermissionValue, false)
 	};
 }
 function parseRecordRight(raw, index) {
 	if (!isRecord(raw)) throw new BusinessRuleError(RecordPermissionErrorCode.RpInvalidConfigStructure, `Record right at index ${index} must be an object`);
-	const obj = raw;
-	if (!Array.isArray(obj.entities)) throw new BusinessRuleError(RecordPermissionErrorCode.RpInvalidConfigStructure, `Record right at index ${index} must have an "entities" array`);
-	const entities = obj.entities.map((item, i) => parseRecordRightEntity(item, i));
+	if (!Array.isArray(raw.entities)) throw new BusinessRuleError(RecordPermissionErrorCode.RpInvalidConfigStructure, `Record right at index ${index} must have an "entities" array`);
+	const entities = raw.entities.map((item, i) => parseRecordRightEntity(item, i));
 	return {
-		filterCond: typeof obj.filterCond === "string" ? obj.filterCond : "",
+		filterCond: typeof raw.filterCond === "string" ? raw.filterCond : "",
 		entities
 	};
 }
 const RecordPermissionConfigParser = { parse: (rawText) => {
-	if (rawText.trim().length === 0) throw new BusinessRuleError(RecordPermissionErrorCode.RpEmptyConfigText, "Record permission config text is empty");
-	let parsed;
-	try {
-		parsed = parse(rawText);
-	} catch (error) {
-		throw new BusinessRuleError(RecordPermissionErrorCode.RpInvalidConfigYaml, `Failed to parse YAML: ${error instanceof Error ? error.message : String(error)}`);
+	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));
+	for (const right of rights) {
+		const seenKeys = /* @__PURE__ */ new Set();
+		for (const re of right.entities) {
+			const key = `${re.entity.type}:${re.entity.code}`;
+			if (seenKeys.has(key)) throw new BusinessRuleError(RecordPermissionErrorCode.RpDuplicateEntity, `Duplicate entity in filterCond "${right.filterCond}": ${re.entity.type} ${re.entity.code}`);
+			seenKeys.add(key);
+		}
 	}
-	if (!isRecord(parsed)) throw new BusinessRuleError(RecordPermissionErrorCode.RpInvalidConfigStructure, "Config must be a YAML object");
-	const obj = parsed;
-	if (!Array.isArray(obj.rights)) throw new BusinessRuleError(RecordPermissionErrorCode.RpInvalidConfigStructure, "Config must have a \"rights\" array");
-	return { rights: obj.rights.map((item, i) => parseRecordRight(item, i)) };
+	return { rights };
 } };
 
 //#endregion
@@ -7950,13 +7924,17 @@ function parseRecordPermissionConfigText(rawText) {
 //#endregion
 //#region src/core/application/recordPermission/applyRecordPermission.ts
 async function applyRecordPermission({ container }) {
-	const result = await container.recordPermissionStorage.get();
-	if (!result.exists) throw new ValidationError(ValidationErrorCode.InvalidInput, "Record permission config file not found");
-	const config = parseRecordPermissionConfigText(result.content);
-	const current = await container.recordPermissionConfigurator.getRecordPermissions();
-	await container.recordPermissionConfigurator.updateRecordPermissions({
-		rights: config.rights,
-		revision: current.revision
+	await applyFromConfig({
+		getStorage: () => container.recordPermissionStorage.get(),
+		parseConfig: parseRecordPermissionConfigText,
+		fetchRemote: () => container.recordPermissionConfigurator.getRecordPermissions(),
+		update: async (config, current) => {
+			await container.recordPermissionConfigurator.updateRecordPermissions({
+				rights: config.rights,
+				revision: current.revision
+			});
+		},
+		notFoundMessage: "Record permission config file not found"
 	});
 }
 
@@ -8073,7 +8051,7 @@ var capture_default$5 = define({
 
 //#endregion
 //#region src/core/domain/recordPermission/services/diffDetector.ts
-function areRightsEqual(a, b) {
+function isRightEqual(a, b) {
 	return deepEqual(a.entities.map((e) => ({
 		type: e.entity.type,
 		code: e.entity.code,
@@ -8122,7 +8100,7 @@ const RecordPermissionDiffDetector = { detect: (local, remote) => {
 				details: describeRight(remoteRight)
 			});
 			else if (localRight && remoteRight) {
-				if (!areRightsEqual(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");
@@ -8332,13 +8310,17 @@ function parseReportConfigText(rawText) {
 //#endregion
 //#region src/core/application/report/applyReport.ts
 async function applyReport({ container }) {
-	const result = await container.reportStorage.get();
-	if (!result.exists) throw new ValidationError(ValidationErrorCode.InvalidInput, "Report config file not found");
-	const config = parseReportConfigText(result.content);
-	const current = await container.reportConfigurator.getReports();
-	await container.reportConfigurator.updateReports({
-		reports: config.reports,
-		revision: current.revision
+	await applyFromConfig({
+		getStorage: () => container.reportStorage.get(),
+		parseConfig: parseReportConfigText,
+		fetchRemote: () => container.reportConfigurator.getReports(),
+		update: async (config, current) => {
+			await container.reportConfigurator.updateReports({
+				reports: config.reports,
+				revision: current.revision
+			});
+		},
+		notFoundMessage: "Report config file not found"
 	});
 }
 
@@ -9132,12 +9114,25 @@ function parseSchemaText(rawText) {
 
 //#endregion
 //#region src/core/application/formSchema/detectDiff.ts
+function fieldPropertiesToDto(field) {
+	if (field.type === "SUBTABLE") {
+		const innerFields = {};
+		for (const [code, def] of field.properties.fields) innerFields[code] = {
+			code: def.code,
+			type: def.type,
+			label: def.label,
+			properties: def.properties
+		};
+		return { fields: innerFields };
+	}
+	return { ...field.properties };
+}
 function toFieldDto(field) {
 	return {
 		code: field.code,
 		type: field.type,
 		label: field.label,
-		properties: field.properties
+		properties: fieldPropertiesToDto(field)
 	};
 }
 async function detectDiff({ container }) {
@@ -9265,11 +9260,7 @@ var LocalFileDumpStorage = class {
 //#region src/core/application/container/dumpCli.ts
 function createDumpCliContainer(config) {
 	return {
-		formDumpReader: new KintoneFormDumpReader(new KintoneRestAPIClient({
-			baseUrl: config.baseUrl,
-			auth: buildKintoneAuth(config.auth),
-			guestSpaceId: config.guestSpaceId
-		}), config.appId),
+		formDumpReader: new KintoneFormDumpReader(config.client ?? createKintoneClient(config), config.appId),
 		dumpStorage: new LocalFileDumpStorage(config.filePrefix)
 	};
 }
@@ -9341,6 +9332,19 @@ var dump_default = define({
 	}
 });
 
+//#endregion
+//#region src/core/domain/formSchema/services/subtableFieldSplitter.ts
+function splitSubtableInnerFields(desired, current) {
+	const newInnerFields = /* @__PURE__ */ new Map();
+	const existingInnerFields = /* @__PURE__ */ new Map();
+	for (const [code, def] of desired.properties.fields) if (current.properties.fields.has(code)) existingInnerFields.set(code, def);
+	else newInnerFields.set(code, def);
+	return {
+		newInnerFields,
+		existingInnerFields
+	};
+}
+
 //#endregion
 //#region src/core/domain/formSchema/services/schemaValidator.ts
 const SELECTION_TYPES = new Set([
@@ -9513,10 +9517,7 @@ async function executeMigration({ container }) {
 		const after = entry.after;
 		const before = entry.before;
 		if (after.type === "SUBTABLE" && before !== void 0 && before.type === "SUBTABLE") {
-			const newInnerFields = /* @__PURE__ */ new Map();
-			const existingInnerFields = /* @__PURE__ */ new Map();
-			for (const [code, def] of after.properties.fields) if (before.properties.fields.has(code)) existingInnerFields.set(code, def);
-			else newInnerFields.set(code, def);
+			const { newInnerFields, existingInnerFields } = splitSubtableInnerFields(after, before);
 			if (newInnerFields.size > 0) fieldsToAdd.push({
 				...after,
 				properties: { fields: newInnerFields }
@@ -9651,10 +9652,7 @@ async function forceOverrideForm({ container }) {
 		if (currentFields.has(fieldCode)) if (schemaDef.type === "SUBTABLE") {
 			const currentDef = currentFields.get(fieldCode);
 			if (currentDef !== void 0 && currentDef.type === "SUBTABLE") {
-				const newInnerFields = /* @__PURE__ */ new Map();
-				const existingInnerFields = /* @__PURE__ */ new Map();
-				for (const [code, def] of schemaDef.properties.fields) if (currentDef.properties.fields.has(code)) existingInnerFields.set(code, def);
-				else newInnerFields.set(code, def);
+				const { newInnerFields, existingInnerFields } = splitSubtableInnerFields(schemaDef, currentDef);
 				if (newInnerFields.size > 0) toAdd.push({
 					...schemaDef,
 					properties: { fields: newInnerFields }
@@ -9821,9 +9819,9 @@ async function validateSchema({ container }) {
 	if (!result.exists) throw new ValidationError(ValidationErrorCode.InvalidInput, "Schema file not found");
 	let schema;
 	try {
-		schema = SchemaParser.parse(result.content);
+		schema = parseSchemaText(result.content);
 	} catch (error) {
-		if (isBusinessRuleError(error)) return {
+		if (isValidationError(error)) return {
 			parseError: error.message,
 			fieldCount: 0
 		};
@@ -9932,6 +9930,50 @@ var schema_default = define({
 	run: () => {}
 });
 
+//#endregion
+//#region src/core/domain/seedData/services/upsertPlanner.ts
+function recordsEqual(seed, existing, keyField) {
+	const seedKeys = Object.keys(seed).filter((k) => k !== keyField);
+	for (const key of seedKeys) {
+		const seedValue = seed[key];
+		const existingValue = existing[key];
+		if (seedValue === void 0 && existingValue === void 0) continue;
+		if (seedValue === void 0 || existingValue === void 0) return false;
+		if (!deepEqual(seedValue, existingValue)) return false;
+	}
+	return true;
+}
+const UpsertPlanner = { plan: (key, seedRecords, existingRecords) => {
+	const keyField = key;
+	const existingMap = /* @__PURE__ */ new Map();
+	for (const { id, record } of existingRecords) {
+		const keyValue = record[keyField];
+		if (typeof keyValue === "string") existingMap.set(keyValue, {
+			id,
+			record
+		});
+	}
+	const toAdd = [];
+	const toUpdate = [];
+	let unchanged = 0;
+	for (const seedRecord of seedRecords) {
+		const keyValue = seedRecord[keyField];
+		if (typeof keyValue !== "string") throw new BusinessRuleError(SeedDataErrorCode.SdInvalidKeyFieldValue, `Key field "${keyField}" value must be a string, got ${typeof keyValue}`);
+		const existing = existingMap.get(keyValue);
+		if (existing === void 0) toAdd.push(seedRecord);
+		else if (recordsEqual(seedRecord, existing.record, keyField)) unchanged++;
+		else toUpdate.push({
+			id: existing.id,
+			record: seedRecord
+		});
+	}
+	return {
+		toAdd,
+		toUpdate,
+		unchanged
+	};
+} };
+
 //#endregion
 //#region src/core/domain/seedData/services/seedParser.ts
 function normalizeValue(value) {
@@ -9993,55 +10035,17 @@ const SeedParser = { parse: (rawText) => {
 } };
 
 //#endregion
-//#region src/core/domain/seedData/services/upsertPlanner.ts
-function recordsEqual(seed, existing, keyField) {
-	const seedKeys = Object.keys(seed).filter((k) => k !== keyField);
-	for (const key of seedKeys) {
-		const seedValue = seed[key];
-		const existingValue = existing[key];
-		if (seedValue === void 0 && existingValue === void 0) continue;
-		if (seedValue === void 0 || existingValue === void 0) return false;
-		if (!deepEqual(seedValue, existingValue)) return false;
-	}
-	return true;
+//#region src/core/application/seedData/parseConfig.ts
+function parseSeedText(rawText) {
+	return wrapBusinessRuleError(() => SeedParser.parse(rawText));
 }
-const UpsertPlanner = { plan: (key, seedRecords, existingRecords) => {
-	const keyField = key;
-	const existingMap = /* @__PURE__ */ new Map();
-	for (const { id, record } of existingRecords) {
-		const keyValue = record[keyField];
-		if (typeof keyValue === "string") existingMap.set(keyValue, {
-			id,
-			record
-		});
-	}
-	const toAdd = [];
-	const toUpdate = [];
-	let unchanged = 0;
-	for (const seedRecord of seedRecords) {
-		const keyValue = seedRecord[keyField];
-		if (typeof keyValue !== "string") throw new BusinessRuleError(SeedDataErrorCode.SdInvalidKeyFieldValue, `Key field "${keyField}" value must be a string, got ${typeof keyValue}`);
-		const existing = existingMap.get(keyValue);
-		if (existing === void 0) toAdd.push(seedRecord);
-		else if (recordsEqual(seedRecord, existing.record, keyField)) unchanged++;
-		else toUpdate.push({
-			id: existing.id,
-			record: seedRecord
-		});
-	}
-	return {
-		toAdd,
-		toUpdate,
-		unchanged
-	};
-} };
 
 //#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 = SeedParser.parse(result.content);
+	const seedData = parseSeedText(result.content);
 	if (input.clean) {
 		const { deletedCount } = await container.recordManager.deleteAllRecords();
 		if (seedData.records.length > 0) await container.recordManager.addRecords(seedData.records);
@@ -10249,6 +10253,11 @@ var seed_default = define({
 
 //#endregion
 //#region src/core/domain/generalSettings/services/configParser.ts
+function parseOptionalBoolean(parsed, fieldName) {
+	const value = parsed[fieldName];
+	if (value === void 0 || value === null) return void 0;
+	return parseStrictBoolean(value, fieldName, "Config", GeneralSettingsErrorCode.GsInvalidBooleanField);
+}
 const VALID_THEMES = new Set([
 	"WHITE",
 	"RED",
@@ -10270,86 +10279,70 @@ const VALID_ROUNDING_MODES = new Set([
 ]);
 function parseIcon(raw) {
 	if (!isRecord(raw)) throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "icon must be an object with \"type\" and \"key\" properties");
-	const obj = raw;
-	if (typeof obj.type !== "string" || !VALID_ICON_TYPES.has(obj.type)) throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidIconType, `icon.type must be PRESET or FILE, got: ${String(obj.type)}`);
-	if (typeof obj.key !== "string" || obj.key.length === 0) throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "icon must have a non-empty \"key\" property");
+	if (typeof raw.key !== "string" || raw.key.length === 0) throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "icon must have a non-empty \"key\" property");
 	return {
-		type: obj.type,
-		key: obj.key
+		type: parseEnum(raw.type, VALID_ICON_TYPES, GeneralSettingsErrorCode.GsInvalidIconType, `icon.type must be PRESET or FILE, got: ${String(raw.type)}`),
+		key: raw.key
 	};
 }
 function parseTitleField(raw) {
 	if (!isRecord(raw)) throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "titleField must be an object with \"selectionMode\" property");
-	const obj = raw;
-	if (typeof obj.selectionMode !== "string" || !VALID_SELECTION_MODES.has(obj.selectionMode)) throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, `titleField.selectionMode must be AUTO or MANUAL, got: ${String(obj.selectionMode)}`);
-	const result = { selectionMode: obj.selectionMode };
-	if (obj.code !== void 0 && obj.code !== null) {
-		if (typeof obj.code !== "string") throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "titleField.code must be a string");
+	const result = { selectionMode: parseEnum(raw.selectionMode, VALID_SELECTION_MODES, GeneralSettingsErrorCode.GsInvalidConfigStructure, `titleField.selectionMode must be AUTO or MANUAL, got: ${String(raw.selectionMode)}`) };
+	if (raw.code !== void 0 && raw.code !== null) {
+		if (typeof raw.code !== "string") throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "titleField.code must be a string");
 		return {
 			...result,
-			code: obj.code
+			code: raw.code
 		};
 	}
 	return result;
 }
 function parseNumberPrecision(raw) {
 	if (!isRecord(raw)) throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "numberPrecision must be an object");
-	const obj = raw;
-	if (typeof obj.digits !== "number") throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "numberPrecision.digits must be a number");
-	if (typeof obj.decimalPlaces !== "number") throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "numberPrecision.decimalPlaces must be a number");
-	if (typeof obj.roundingMode !== "string" || !VALID_ROUNDING_MODES.has(obj.roundingMode)) throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, `numberPrecision.roundingMode must be HALF_EVEN, UP, or DOWN, got: ${String(obj.roundingMode)}`);
+	if (typeof raw.digits !== "number") throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "numberPrecision.digits must be a number");
+	if (!Number.isInteger(raw.digits) || raw.digits < 0) throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidNumberPrecision, `numberPrecision.digits must be a non-negative integer, got: ${raw.digits}`);
+	if (typeof raw.decimalPlaces !== "number") throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "numberPrecision.decimalPlaces must be a number");
+	if (!Number.isInteger(raw.decimalPlaces) || raw.decimalPlaces < 0) throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidNumberPrecision, `numberPrecision.decimalPlaces must be a non-negative integer, got: ${raw.decimalPlaces}`);
 	return {
-		digits: obj.digits,
-		decimalPlaces: obj.decimalPlaces,
-		roundingMode: obj.roundingMode
+		digits: raw.digits,
+		decimalPlaces: raw.decimalPlaces,
+		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) => {
-	if (rawText.trim().length === 0) throw new BusinessRuleError(GeneralSettingsErrorCode.GsEmptyConfigText, "General settings config text is empty");
-	let parsed;
-	try {
-		parsed = parse(rawText);
-	} catch (error) {
-		throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigYaml, `Failed to parse YAML: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	if (!isRecord(parsed)) throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "Config must be a YAML object");
-	const obj = parsed;
+	const parsed = parseYamlConfig(rawText, {
+		emptyConfigText: GeneralSettingsErrorCode.GsEmptyConfigText,
+		invalidConfigYaml: GeneralSettingsErrorCode.GsInvalidConfigYaml,
+		invalidConfigStructure: GeneralSettingsErrorCode.GsInvalidConfigStructure
+	}, "General settings");
 	let name;
-	if (obj.name !== void 0 && obj.name !== null) {
-		if (typeof obj.name !== "string") throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "name must be a string");
-		name = obj.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 (obj.description !== void 0 && obj.description !== null) {
-		if (typeof obj.description !== "string") throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "description must be a string");
-		description = obj.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 (obj.icon !== void 0 && obj.icon !== null) icon = parseIcon(obj.icon);
+	if (parsed.icon !== void 0 && parsed.icon !== null) icon = parseIcon(parsed.icon);
 	let theme;
-	if (obj.theme !== void 0 && obj.theme !== null) {
-		if (typeof obj.theme !== "string" || !VALID_THEMES.has(obj.theme)) throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidTheme, `theme must be WHITE, RED, GREEN, BLUE, YELLOW, BLACK, CLIPBOARD, BINDER, PENCIL, or CLIPS, got: ${String(obj.theme)}`);
-		theme = obj.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 (obj.titleField !== void 0 && obj.titleField !== null) titleField = parseTitleField(obj.titleField);
-	let enableThumbnails;
-	if (obj.enableThumbnails !== void 0 && obj.enableThumbnails !== null) enableThumbnails = Boolean(obj.enableThumbnails);
-	let enableBulkDeletion;
-	if (obj.enableBulkDeletion !== void 0 && obj.enableBulkDeletion !== null) enableBulkDeletion = Boolean(obj.enableBulkDeletion);
-	let enableComments;
-	if (obj.enableComments !== void 0 && obj.enableComments !== null) enableComments = Boolean(obj.enableComments);
-	let enableDuplicateRecord;
-	if (obj.enableDuplicateRecord !== void 0 && obj.enableDuplicateRecord !== null) enableDuplicateRecord = Boolean(obj.enableDuplicateRecord);
-	let enableInlineRecordEditing;
-	if (obj.enableInlineRecordEditing !== void 0 && obj.enableInlineRecordEditing !== null) enableInlineRecordEditing = Boolean(obj.enableInlineRecordEditing);
+	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 (obj.numberPrecision !== void 0 && obj.numberPrecision !== null) numberPrecision = parseNumberPrecision(obj.numberPrecision);
+	if (parsed.numberPrecision !== void 0 && parsed.numberPrecision !== null) numberPrecision = parseNumberPrecision(parsed.numberPrecision);
 	let firstMonthOfFiscalYear;
-	if (obj.firstMonthOfFiscalYear !== void 0 && obj.firstMonthOfFiscalYear !== null) {
-		if (typeof obj.firstMonthOfFiscalYear !== "number") throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, "firstMonthOfFiscalYear must be a number");
-		if (obj.firstMonthOfFiscalYear < 1 || obj.firstMonthOfFiscalYear > 12 || !Number.isInteger(obj.firstMonthOfFiscalYear)) throw new BusinessRuleError(GeneralSettingsErrorCode.GsInvalidConfigStructure, `firstMonthOfFiscalYear must be an integer between 1 and 12, got: ${obj.firstMonthOfFiscalYear}`);
-		firstMonthOfFiscalYear = obj.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;
 	}
 	return {
 		...name !== void 0 ? { name } : {},
@@ -10376,13 +10369,17 @@ function parseGeneralSettingsConfigText(rawText) {
 //#endregion
 //#region src/core/application/generalSettings/applyGeneralSettings.ts
 async function applyGeneralSettings({ container }) {
-	const result = await container.generalSettingsStorage.get();
-	if (!result.exists) throw new ValidationError(ValidationErrorCode.InvalidInput, "General settings config file not found");
-	const config = parseGeneralSettingsConfigText(result.content);
-	const current = await container.generalSettingsConfigurator.getGeneralSettings();
-	await container.generalSettingsConfigurator.updateGeneralSettings({
-		config,
-		revision: current.revision
+	await applyFromConfig({
+		getStorage: () => container.generalSettingsStorage.get(),
+		parseConfig: parseGeneralSettingsConfigText,
+		fetchRemote: () => container.generalSettingsConfigurator.getGeneralSettings(),
+		update: async (config, current) => {
+			await container.generalSettingsConfigurator.updateGeneralSettings({
+				config,
+				revision: current.revision
+			});
+		},
+		notFoundMessage: "General settings config file not found"
 	});
 }
 
@@ -10531,11 +10528,14 @@ function compareConfigs(local, remote) {
 			details: `${rv} -> ${lv}`
 		});
 	}
+	function formatValue(v) {
+		return v === void 0 ? "(none)" : JSON.stringify(v);
+	}
 	function compareDeepEqual(field, l, r) {
 		if (!deepEqual(l, r)) entries.push({
 			type: "modified",
 			field,
-			details: `${field} changed`
+			details: `${formatValue(r)} -> ${formatValue(l)}`
 		});
 	}
 	compareString("name", local.name, remote.name, DEFAULT_STRING);