kintone-migrator 0.24.1 → 0.24.3

package/dist/index.mjs

@@ -25,7 +25,8 @@ const ActionErrorCode = {
 	AcInvalidConfigStructure: "AC_INVALID_CONFIG_STRUCTURE",
 	AcInvalidSrcType: "AC_INVALID_SRC_TYPE",
 	AcInvalidEntityType: "AC_INVALID_ENTITY_TYPE",
-	AcEmptyActionName: "AC_EMPTY_ACTION_NAME"
+	AcEmptyActionName: "AC_EMPTY_ACTION_NAME",
+	AcDuplicateIndex: "AC_DUPLICATE_INDEX"
 };
 
 //#endregion
@@ -67,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"
@@ -94,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
@@ -106,7 +110,9 @@ const NotificationErrorCode = {
 	NtInvalidEntityType: "NT_INVALID_ENTITY_TYPE",
 	NtEmptyEntityCode: "NT_EMPTY_ENTITY_CODE",
 	NtMissingRequiredField: "NT_MISSING_REQUIRED_FIELD",
-	NtConflictingTimingFields: "NT_CONFLICTING_TIMING_FIELDS"
+	NtConflictingTimingFields: "NT_CONFLICTING_TIMING_FIELDS",
+	NtInvalidHoursLater: "NT_INVALID_HOURS_LATER",
+	NtInvalidDaysLater: "NT_INVALID_DAYS_LATER"
 };
 
 //#endregion
@@ -115,7 +121,8 @@ const PluginErrorCode = {
 	PlEmptyConfigText: "PL_EMPTY_CONFIG_TEXT",
 	PlInvalidConfigYaml: "PL_INVALID_CONFIG_YAML",
 	PlInvalidConfigStructure: "PL_INVALID_CONFIG_STRUCTURE",
-	PlEmptyPluginId: "PL_EMPTY_PLUGIN_ID"
+	PlEmptyPluginId: "PL_EMPTY_PLUGIN_ID",
+	PlDuplicatePluginId: "PL_DUPLICATE_PLUGIN_ID"
 };
 
 //#endregion
@@ -126,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
@@ -150,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
@@ -176,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 = {
@@ -184,7 +198,8 @@ const ViewErrorCode = {
 	VwInvalidConfigStructure: "VW_INVALID_CONFIG_STRUCTURE",
 	VwInvalidViewType: "VW_INVALID_VIEW_TYPE",
 	VwInvalidDeviceType: "VW_INVALID_DEVICE_TYPE",
-	VwEmptyViewName: "VW_EMPTY_VIEW_NAME"
+	VwEmptyViewName: "VW_EMPTY_VIEW_NAME",
+	VwInvalidIndex: "VW_INVALID_INDEX"
 };
 
 //#endregion
@@ -204,6 +219,7 @@ const BusinessRuleErrorCode = {
 	...RecordPermissionErrorCode,
 	...ReportErrorCode,
 	...SeedDataErrorCode,
+	...DomainServiceErrorCode,
 	...ViewErrorCode
 };
 /**
@@ -339,10 +355,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) {
@@ -364,61 +376,121 @@ 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
+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`);
+	return parsed;
+}
 
 //#endregion
 //#region src/core/domain/action/valueObject.ts
-const VALID_SRC_TYPES = new Set(["FIELD", "RECORD_URL"]);
-const VALID_ENTITY_TYPES$10 = new Set([
+const SRC_TYPES = ["FIELD", "RECORD_URL"];
+const VALID_SRC_TYPES = new Set(SRC_TYPES);
+function isActionMappingSrcType(value) {
+	return VALID_SRC_TYPES.has(value);
+}
+const ENTITY_TYPES$1 = [
 	"USER",
 	"GROUP",
 	"ORGANIZATION"
-]);
+];
+const VALID_ENTITY_TYPES$9 = new Set(ENTITY_TYPES$1);
+function isActionEntityType(value) {
+	return VALID_ENTITY_TYPES$9.has(value);
+}
 
 //#endregion
 //#region src/core/domain/action/services/configParser.ts
 function parseDestApp(raw, actionName) {
 	if (!isRecord(raw)) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" destApp must be an object`);
-	const obj = raw;
 	const result = {};
-	if (obj.app !== void 0 && obj.app !== null) result.app = String(obj.app);
-	if (obj.code !== void 0 && obj.code !== null) result.code = String(obj.code);
+	if (raw.app !== void 0 && raw.app !== null) result.app = String(raw.app);
+	if (raw.code !== void 0 && raw.code !== null) result.code = String(raw.code);
+	if (result.app === void 0 && result.code === void 0) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" destApp must have at least "app" or "code" property`);
 	return result;
 }
 function parseMapping(raw, index, actionName) {
 	if (!isRecord(raw)) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" mapping at index ${index} must be an object`);
-	const obj = raw;
-	if (typeof obj.srcType !== "string" || !VALID_SRC_TYPES.has(obj.srcType)) throw new BusinessRuleError(ActionErrorCode.AcInvalidSrcType, `Action "${actionName}" mapping at index ${index} has invalid srcType: ${String(obj.srcType)}. Must be FIELD or RECORD_URL`);
-	if (typeof obj.destField !== "string" || obj.destField.length === 0) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" mapping at index ${index} must have a non-empty "destField" property`);
-	return {
-		srcType: obj.srcType,
-		destField: obj.destField,
-		...obj.srcField !== void 0 && obj.srcField !== null && typeof obj.srcField === "string" ? { srcField: obj.srcField } : {}
+	if (typeof raw.srcType !== "string" || !isActionMappingSrcType(raw.srcType)) throw new BusinessRuleError(ActionErrorCode.AcInvalidSrcType, `Action "${actionName}" mapping at index ${index} has invalid srcType: ${String(raw.srcType)}. Must be FIELD or RECORD_URL`);
+	if (typeof raw.destField !== "string" || raw.destField.length === 0) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" mapping at index ${index} must have a non-empty "destField" property`);
+	const result = {
+		srcType: raw.srcType,
+		destField: raw.destField,
+		...raw.srcField !== void 0 && raw.srcField !== null && typeof raw.srcField === "string" ? { srcField: raw.srcField } : {}
 	};
+	if (result.srcType === "FIELD" && result.srcField === void 0) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" mapping at index ${index} with srcType "FIELD" must have a "srcField" property`);
+	return result;
 }
 function parseEntity$4(raw, index, actionName) {
 	if (!isRecord(raw)) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" entity at index ${index} must be an object`);
-	const obj = raw;
-	if (typeof obj.type !== "string" || !VALID_ENTITY_TYPES$10.has(obj.type)) throw new BusinessRuleError(ActionErrorCode.AcInvalidEntityType, `Action "${actionName}" entity at index ${index} has invalid type: ${String(obj.type)}. Must be USER, GROUP, or ORGANIZATION`);
-	if (typeof obj.code !== "string" || obj.code.length === 0) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" entity at index ${index} must have a non-empty "code" property`);
+	if (typeof raw.type !== "string" || !isActionEntityType(raw.type)) throw new BusinessRuleError(ActionErrorCode.AcInvalidEntityType, `Action "${actionName}" entity at index ${index} has invalid type: ${String(raw.type)}. Must be USER, GROUP, or ORGANIZATION`);
+	if (typeof raw.code !== "string" || raw.code.length === 0) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" entity at index ${index} must have a non-empty "code" property`);
 	return {
-		type: obj.type,
-		code: obj.code
+		type: raw.type,
+		code: raw.code
 	};
 }
 function parseActionConfig(raw, actionName) {
-	if (!isRecord(raw)) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" must be an object`);
-	const obj = raw;
 	if (actionName.length === 0) throw new BusinessRuleError(ActionErrorCode.AcEmptyActionName, "Action name (key) must not be empty");
-	if (typeof obj.index !== "number") throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" must have a numeric "index" property`);
-	if (!isRecord(obj.destApp)) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" must have a "destApp" object`);
-	const destApp = parseDestApp(obj.destApp, actionName);
-	if (!Array.isArray(obj.mappings)) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" must have a "mappings" array`);
-	const mappings = obj.mappings.map((item, i) => parseMapping(item, i, actionName));
-	if (!Array.isArray(obj.entities)) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" must have an "entities" array`);
-	const entities = obj.entities.map((item, i) => parseEntity$4(item, i, actionName));
-	const filterCond = typeof obj.filterCond === "string" ? obj.filterCond : "";
-	return {
-		index: obj.index,
+	if (!isRecord(raw)) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" must be an object`);
+	if (typeof raw.index !== "number" || !Number.isInteger(raw.index) || raw.index < 0) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" must have a non-negative integer "index" property`);
+	if (!isRecord(raw.destApp)) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" must have a "destApp" object`);
+	const destApp = parseDestApp(raw.destApp, actionName);
+	if (!Array.isArray(raw.mappings)) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" must have a "mappings" array`);
+	const mappings = raw.mappings.map((item, i) => parseMapping(item, i, actionName));
+	if (!Array.isArray(raw.entities)) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, `Action "${actionName}" must have an "entities" array`);
+	const entities = raw.entities.map((item, i) => parseEntity$4(item, i, actionName));
+	const filterCond = typeof raw.filterCond === "string" ? raw.filterCond : "";
+	return {
+		index: raw.index,
 		name: actionName,
 		destApp,
 		mappings,
@@ -427,19 +499,20 @@ function parseActionConfig(raw, actionName) {
 	};
 }
 const ActionConfigParser = { parse: (rawText) => {
-	if (rawText.trim().length === 0) throw new BusinessRuleError(ActionErrorCode.AcEmptyConfigText, "Action config text is empty");
-	let parsed;
-	try {
-		parsed = parse(rawText);
-	} catch (error) {
-		throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigYaml, `Failed to parse YAML: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	if (!isRecord(parsed)) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, "Config must be a YAML object");
-	const obj = parsed;
+	const obj = parseYamlConfig(rawText, {
+		emptyConfigText: ActionErrorCode.AcEmptyConfigText,
+		invalidConfigYaml: ActionErrorCode.AcInvalidConfigYaml,
+		invalidConfigStructure: ActionErrorCode.AcInvalidConfigStructure
+	}, "Action");
 	if (!isRecord(obj.actions)) throw new BusinessRuleError(ActionErrorCode.AcInvalidConfigStructure, "Config must have an \"actions\" object");
 	const rawActions = obj.actions;
 	const actions = {};
 	for (const [key, value] of Object.entries(rawActions)) actions[key] = parseActionConfig(value, key);
+	const seenIndices = /* @__PURE__ */ new Set();
+	for (const [key, action] of Object.entries(actions)) {
+		if (seenIndices.has(action.index)) throw new BusinessRuleError(ActionErrorCode.AcDuplicateIndex, `Duplicate action index ${action.index} found in action "${key}"`);
+		seenIndices.add(action.index);
+	}
 	return { actions };
 } };
 
@@ -471,7 +544,7 @@ function fromKintoneDestApp(raw) {
 	return result;
 }
 function fromKintoneMapping(raw) {
-	if (!VALID_SRC_TYPES.has(raw.srcType)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected srcType value from kintone API: ${raw.srcType}`);
+	if (!isActionMappingSrcType(raw.srcType)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected srcType value from kintone API: ${raw.srcType}`);
 	return {
 		srcType: raw.srcType,
 		destField: raw.destField,
@@ -479,15 +552,17 @@ function fromKintoneMapping(raw) {
 	};
 }
 function fromKintoneEntity$4(raw) {
-	if (!VALID_ENTITY_TYPES$10.has(raw.type)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected entity type from kintone API: ${raw.type}`);
+	if (!isActionEntityType(raw.type)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected entity type from kintone API: ${raw.type}`);
 	return {
 		type: raw.type,
 		code: raw.code
 	};
 }
 function fromKintoneAction$1(raw) {
+	const index = Number(raw.index);
+	if (!Number.isFinite(index)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected non-numeric index from kintone API: ${raw.index}`);
 	return {
-		index: Number(raw.index),
+		index,
 		name: raw.name,
 		destApp: fromKintoneDestApp(raw.destApp),
 		mappings: raw.mappings.map(fromKintoneMapping),
@@ -665,25 +740,42 @@ function createLocalFileActionStorage(filePath) {
 }
 
 //#endregion
-//#region src/core/adapters/kintone/customizationConfigurator.ts
-const VALID_SCOPES$1 = new Set([
+//#region src/core/domain/customization/valueObject.ts
+const SCOPES = [
 	"ALL",
 	"ADMIN",
 	"NONE"
-]);
+];
+const VALID_SCOPES = new Set(SCOPES);
+function isCustomizationScope(value) {
+	return VALID_SCOPES.has(value);
+}
+const RESOURCE_TYPES = ["FILE", "URL"];
+const VALID_RESOURCE_TYPES = new Set(RESOURCE_TYPES);
+function isResourceType(value) {
+	return VALID_RESOURCE_TYPES.has(value);
+}
+const DEFAULT_CUSTOMIZATION_SCOPE = "ALL";
+
+//#endregion
+//#region src/core/adapters/kintone/customizationConfigurator.ts
 function fromKintoneResource(raw) {
-	if (raw.type === "FILE" && raw.file) return {
-		type: "FILE",
-		file: {
-			fileKey: raw.file.fileKey,
-			name: raw.file.name,
-			contentType: raw.file.contentType,
-			size: raw.file.size
-		}
-	};
+	if (raw.type === "FILE") {
+		if (!raw.file) throw new SystemError(SystemErrorCode.ExternalApiError, "FILE resource from kintone API is missing file metadata");
+		return {
+			type: "FILE",
+			file: {
+				fileKey: raw.file.fileKey,
+				name: raw.file.name,
+				contentType: raw.file.contentType,
+				size: raw.file.size
+			}
+		};
+	}
+	if (!raw.url) throw new SystemError(SystemErrorCode.ExternalApiError, "URL resource from kintone API is missing url property");
 	return {
 		type: "URL",
-		url: raw.url ?? ""
+		url: raw.url
 	};
 }
 function fromKintoneResourceList(raw) {
@@ -714,7 +806,7 @@ var KintoneCustomizationConfigurator = class {
 				preview: true
 			});
 			const rawScope = String(response.scope);
-			if (!VALID_SCOPES$1.has(rawScope)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected scope value from kintone API: ${rawScope}`);
+			if (!isCustomizationScope(rawScope)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected scope value from kintone API: ${rawScope}`);
 			return {
 				scope: rawScope,
 				desktop: {
@@ -1799,7 +1891,7 @@ function parseAuth(raw) {
 	}
 	throw new BusinessRuleError(ProjectConfigErrorCode.PcInvalidAuthConfig, "Auth must have either apiToken or username/password");
 }
-const ConfigParser$1 = { parse: parseProjectConfig };
+const ConfigParser = { parse: parseProjectConfig };
 
 //#endregion
 //#region src/core/application/projectConfig/loadProjectConfig.ts
@@ -1815,7 +1907,7 @@ function loadProjectConfig(input) {
 	} catch (cause) {
 		throw new ValidationError(ValidationErrorCode.InvalidInput, "Invalid YAML syntax in config file", cause);
 	}
-	return ConfigParser$1.parse(raw);
+	return ConfigParser.parse(raw);
 }
 
 //#endregion
@@ -2397,6 +2489,20 @@ var apply_default$12 = define({
 	}
 });
 
+//#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);
+	}
+}
+
 //#endregion
 //#region src/core/domain/action/services/configSerializer.ts
 function serializeDestApp(destApp) {
@@ -2433,11 +2539,7 @@ const ActionConfigSerializer = { serialize: (config) => {
 	const actions = {};
 	for (const [key, value] of Object.entries(config.actions)) actions[key] = serializeActionConfig(value);
 	serialized.actions = actions;
-	return stringify(serialized, {
-		lineWidth: 0,
-		defaultKeyType: "PLAIN",
-		defaultStringType: "PLAIN"
-	});
+	return serializeToYaml(serialized);
 } };
 
 //#endregion
@@ -2611,12 +2713,24 @@ function buildDiffResult(entries, warnings = []) {
 	};
 }
 
+//#endregion
+//#region src/core/domain/services/recordDiffDetector.ts
+function detectRecordDiff(localRecord, remoteRecord, callbacks) {
+	const entries = [];
+	for (const [key, localValue] of Object.entries(localRecord)) if (!Object.hasOwn(remoteRecord, key)) entries.push(callbacks.onAdded(key, localValue));
+	else {
+		const entry = callbacks.onModified(key, localValue, remoteRecord[key]);
+		if (entry !== void 0) entries.push(entry);
+	}
+	for (const [key, remoteValue] of Object.entries(remoteRecord)) if (!Object.hasOwn(localRecord, key)) entries.push(callbacks.onDeleted(key, remoteValue));
+	return entries;
+}
+
 //#endregion
 //#region src/core/domain/action/services/diffDetector.ts
 function compareActions$1(local, remote) {
 	const diffs = [];
 	if (local.index !== remote.index) diffs.push(`index: ${remote.index} -> ${local.index}`);
-	if (local.name !== remote.name) diffs.push(`name: "${remote.name}" -> "${local.name}"`);
 	if (!deepEqual(local.destApp, remote.destApp)) diffs.push("destApp changed");
 	if (local.filterCond !== remote.filterCond) diffs.push("filterCond changed");
 	if (!deepEqual(local.mappings, remote.mappings)) if (local.mappings.length !== remote.mappings.length) diffs.push(`mappings: ${remote.mappings.length} -> ${local.mappings.length}`);
@@ -2624,30 +2738,30 @@ function compareActions$1(local, remote) {
 	if (!deepEqual(local.entities, remote.entities)) diffs.push("entities changed");
 	return diffs;
 }
+function destAppLabel(action) {
+	return `dest: ${action.destApp.app ?? action.destApp.code ?? "(unspecified)"}`;
+}
 const ActionDiffDetector = { detect: (local, remote) => {
-	const entries = [];
-	for (const [name, localAction] of Object.entries(local.actions)) {
-		const remoteAction = remote.actions[name];
-		if (!remoteAction) entries.push({
+	return buildDiffResult(detectRecordDiff(local.actions, remote.actions, {
+		onAdded: (name, localAction) => ({
 			type: "added",
 			actionName: name,
-			details: `dest: ${localAction.destApp.app ?? localAction.destApp.code ?? "(unspecified)"}`
-		});
-		else {
+			details: destAppLabel(localAction)
+		}),
+		onModified: (name, localAction, remoteAction) => {
 			const diffs = compareActions$1(localAction, remoteAction);
-			if (diffs.length > 0) entries.push({
+			if (diffs.length > 0) return {
 				type: "modified",
 				actionName: name,
 				details: diffs.join(", ")
-			});
-		}
-	}
-	for (const [name, remoteAction] of Object.entries(remote.actions)) if (!local.actions[name]) entries.push({
-		type: "deleted",
-		actionName: name,
-		details: `dest: ${remoteAction.destApp.app ?? remoteAction.destApp.code ?? "(unspecified)"}`
-	});
-	return buildDiffResult(entries);
+			};
+		},
+		onDeleted: (name, remoteAction) => ({
+			type: "deleted",
+			actionName: name,
+			details: destAppLabel(remoteAction)
+		})
+	}));
 } };
 
 //#endregion
@@ -2747,20 +2861,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
 	};
 } };
 
@@ -2918,13 +3028,9 @@ 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"
 	});
 } };
 
@@ -3048,59 +3154,41 @@ var admin_notes_default = define({
 
 //#endregion
 //#region src/core/domain/appPermission/services/configParser.ts
-const VALID_ENTITY_TYPES$9 = new Set([
+const VALID_ENTITY_TYPES$8 = new Set([
 	"USER",
 	"GROUP",
 	"ORGANIZATION",
 	"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$9.has(obj.type)) throw new BusinessRuleError(AppPermissionErrorCode.ApInvalidEntityType, `Entity at index ${index} has invalid type: ${String(obj.type)}. Must be USER, GROUP, ORGANIZATION, or CREATOR`);
-	const type = obj.type;
-	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}`;
@@ -3131,14 +3219,14 @@ async function applyAppPermission({ container }) {
 
 //#endregion
 //#region src/core/adapters/kintone/appPermissionConfigurator.ts
-const VALID_ENTITY_TYPES$8 = new Set([
+const VALID_ENTITY_TYPES$7 = new Set([
 	"USER",
 	"GROUP",
 	"ORGANIZATION",
 	"CREATOR"
 ]);
 function fromKintoneRight$2(raw) {
-	if (!VALID_ENTITY_TYPES$8.has(raw.entity.type)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected entity type from kintone API: ${raw.entity.type}`);
+	if (!VALID_ENTITY_TYPES$7.has(raw.entity.type)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected entity type from kintone API: ${raw.entity.type}`);
 	const type = raw.entity.type;
 	let code;
 	if (type === "CREATOR") code = raw.entity.code ?? "";
@@ -3322,11 +3410,7 @@ 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
@@ -3509,28 +3593,21 @@ const ResourceMerger = {
 
 //#endregion
 //#region src/core/domain/customization/services/configParser.ts
-const VALID_SCOPES = new Set([
-	"ALL",
-	"ADMIN",
-	"NONE"
-]);
-const VALID_RESOURCE_TYPES = new Set(["FILE", "URL"]);
 function parseResource(raw, index) {
 	if (!isRecord(raw)) throw new BusinessRuleError(CustomizationErrorCode.CzInvalidConfigStructure, `Resource at index ${index} must be an object`);
-	const obj = raw;
-	const type = obj.type;
-	if (typeof type !== "string" || !VALID_RESOURCE_TYPES.has(type)) throw new BusinessRuleError(CustomizationErrorCode.CzInvalidResourceType, `Resource at index ${index} has invalid type: ${String(type)}. Must be FILE or URL`);
+	const type = raw.type;
+	if (typeof type !== "string" || !isResourceType(type)) throw new BusinessRuleError(CustomizationErrorCode.CzInvalidResourceType, `Resource at index ${index} has invalid type: ${String(type)}. Must be FILE or URL`);
 	if (type === "FILE") {
-		if (typeof obj.path !== "string" || obj.path.length === 0) throw new BusinessRuleError(CustomizationErrorCode.CzInvalidConfigStructure, `FILE resource at index ${index} must have a non-empty "path" property`);
+		if (typeof raw.path !== "string" || raw.path.length === 0) throw new BusinessRuleError(CustomizationErrorCode.CzInvalidConfigStructure, `FILE resource at index ${index} must have a non-empty "path" property`);
 		return {
 			type: "FILE",
-			path: obj.path
+			path: raw.path
 		};
 	}
-	if (typeof obj.url !== "string" || obj.url.length === 0) throw new BusinessRuleError(CustomizationErrorCode.CzInvalidConfigStructure, `URL resource at index ${index} must have a non-empty "url" property`);
+	if (typeof raw.url !== "string" || raw.url.length === 0) throw new BusinessRuleError(CustomizationErrorCode.CzInvalidConfigStructure, `URL resource at index ${index} must have a non-empty "url" property`);
 	return {
 		type: "URL",
-		url: obj.url
+		url: raw.url
 	};
 }
 function parseResourceList(raw) {
@@ -3539,25 +3616,20 @@ function parseResourceList(raw) {
 }
 function parsePlatform(raw) {
 	if (!isRecord(raw)) throw new BusinessRuleError(CustomizationErrorCode.CzInvalidConfigStructure, "Platform configuration must be an object");
-	const obj = raw;
 	return {
-		js: obj.js === void 0 || obj.js === null ? [] : parseResourceList(obj.js),
-		css: obj.css === void 0 || obj.css === null ? [] : parseResourceList(obj.css)
+		js: raw.js === void 0 || raw.js === null ? [] : parseResourceList(raw.js),
+		css: raw.css === void 0 || raw.css === null ? [] : parseResourceList(raw.css)
 	};
 }
-const ConfigParser = { parse: (rawText) => {
-	if (rawText.trim().length === 0) throw new BusinessRuleError(CustomizationErrorCode.CzEmptyConfigText, "Customization config text is empty");
-	let parsed;
-	try {
-		parsed = parse(rawText);
-	} catch (error) {
-		throw new BusinessRuleError(CustomizationErrorCode.CzInvalidConfigYaml, `Failed to parse YAML: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	if (!isRecord(parsed)) throw new BusinessRuleError(CustomizationErrorCode.CzInvalidConfigStructure, "Config must be a YAML object");
-	const obj = parsed;
+const CustomizationConfigParser = { parse: (rawText) => {
+	const obj = parseYamlConfig(rawText, {
+		emptyConfigText: CustomizationErrorCode.CzEmptyConfigText,
+		invalidConfigYaml: CustomizationErrorCode.CzInvalidConfigYaml,
+		invalidConfigStructure: CustomizationErrorCode.CzInvalidConfigStructure
+	}, "Customization");
 	let scope;
 	if (obj.scope !== void 0 && obj.scope !== null) {
-		if (typeof obj.scope !== "string" || !VALID_SCOPES.has(obj.scope)) throw new BusinessRuleError(CustomizationErrorCode.CzInvalidScope, `Invalid scope: ${String(obj.scope)}. Must be ALL, ADMIN, or NONE`);
+		if (typeof obj.scope !== "string" || !isCustomizationScope(obj.scope)) throw new BusinessRuleError(CustomizationErrorCode.CzInvalidScope, `Invalid scope: ${String(obj.scope)}. Must be ALL, ADMIN, or NONE`);
 		scope = obj.scope;
 	}
 	const desktop = obj.desktop === void 0 || obj.desktop === null ? {
@@ -3578,7 +3650,7 @@ const ConfigParser = { parse: (rawText) => {
 //#endregion
 //#region src/core/application/customization/parseConfig.ts
 function parseConfigText(rawText) {
-	return wrapBusinessRuleError(() => ConfigParser.parse(rawText));
+	return wrapBusinessRuleError(() => CustomizationConfigParser.parse(rawText));
 }
 
 //#endregion
@@ -3681,14 +3753,10 @@ function serializePlatform(platform) {
 	};
 }
 const CustomizationConfigSerializer = { serialize: (config) => {
-	return stringify({
+	return serializeToYaml({
 		...config.scope !== void 0 ? { scope: config.scope } : {},
 		...hasPlatformResources(config.desktop) ? { desktop: serializePlatform(config.desktop) } : {},
 		...hasPlatformResources(config.mobile) ? { mobile: serializePlatform(config.mobile) } : {}
-	}, {
-		lineWidth: 0,
-		defaultKeyType: "PLAIN",
-		defaultStringType: "PLAIN"
 	});
 } };
 
@@ -3950,15 +4018,11 @@ var apply_default$9 = define({
 	}
 });
 
-//#endregion
-//#region src/core/domain/customization/valueObject.ts
-const DEFAULT_CUSTOMIZATION_SCOPE = "ALL";
-
 //#endregion
 //#region src/core/domain/customization/services/diffDetector.ts
 function resourceName(resource) {
 	if (resource.type === "URL") return resource.url;
-	const parts = resource.path.replace(/\\/g, "/").split("/");
+	const parts = resource.path.replace(/\\/g, "/").split("/").filter(Boolean);
 	return parts[parts.length - 1];
 }
 function remoteResourceName(resource) {
@@ -4069,7 +4133,7 @@ const VALID_ACCESSIBILITIES$1 = new Set([
 	"WRITE",
 	"NONE"
 ]);
-const VALID_ENTITY_TYPES$7 = new Set([
+const VALID_ENTITY_TYPES$6 = new Set([
 	"USER",
 	"GROUP",
 	"ORGANIZATION",
@@ -4077,7 +4141,7 @@ const VALID_ENTITY_TYPES$7 = new Set([
 ]);
 function fromKintoneEntity$3(raw) {
 	if (!VALID_ACCESSIBILITIES$1.has(raw.accessibility)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected accessibility value from kintone API: ${raw.accessibility}`);
-	if (!VALID_ENTITY_TYPES$7.has(raw.entity.type)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected entity type from kintone API: ${raw.entity.type}`);
+	if (!VALID_ENTITY_TYPES$6.has(raw.entity.type)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected entity type from kintone API: ${raw.entity.type}`);
 	const result = {
 		accessibility: raw.accessibility,
 		entity: {
@@ -4179,60 +4243,49 @@ const VALID_ACCESSIBILITIES = new Set([
 	"WRITE",
 	"NONE"
 ]);
-const VALID_ENTITY_TYPES$6 = new Set([
+const VALID_ENTITY_TYPES$5 = new Set([
 	"USER",
 	"GROUP",
 	"ORGANIZATION",
 	"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$6.has(obj.type)) throw new BusinessRuleError(FieldPermissionErrorCode.FpInvalidEntityType, `Entity at index ${index} has invalid type: ${String(obj.type)}. Must be USER, GROUP, ORGANIZATION, or FIELD_ENTITY`);
-	if (typeof obj.code !== "string" || obj.code.length === 0) throw new BusinessRuleError(FieldPermissionErrorCode.FpEmptyEntityCode, `Entity at index ${index} must have a non-empty "code" property`);
-	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}`);
@@ -4342,14 +4395,10 @@ 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
@@ -4413,7 +4462,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,
@@ -4437,7 +4486,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"
@@ -4649,18 +4698,22 @@ function createGeneralSettingsCliContainer(config) {
 }
 
 //#endregion
-//#region src/core/adapters/kintone/notificationConfigurator.ts
-const VALID_ENTITY_TYPES$5 = new Set([
+//#region src/core/domain/notification/valueObject.ts
+const ENTITY_TYPES = [
 	"USER",
 	"GROUP",
 	"ORGANIZATION",
 	"FIELD_ENTITY"
-]);
-function validateEntityType(type, context) {
-	if (!VALID_ENTITY_TYPES$5.has(type)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected entity type from kintone API (${context}): ${type}`);
+];
+const VALID_ENTITY_TYPES$4 = new Set(ENTITY_TYPES);
+function isNotificationEntityType(value) {
+	return VALID_ENTITY_TYPES$4.has(value);
 }
+
+//#endregion
+//#region src/core/adapters/kintone/notificationConfigurator.ts
 function fromKintoneEntity$2(raw) {
-	validateEntityType(raw.type, "entity");
+	if (!isNotificationEntityType(raw.type)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected entity type from kintone API (entity): ${raw.type}`);
 	return {
 		type: raw.type,
 		code: raw.code
@@ -4681,7 +4734,7 @@ function fromKintoneGeneralNotification(raw) {
 	};
 	return result;
 }
-function fromKintonePerRecordTarget(raw) {
+function fromKintoneTarget(raw) {
 	const result = { entity: fromKintoneEntity$2(raw.entity) };
 	if (raw.includeSubs !== void 0) return {
 		...result,
@@ -4693,29 +4746,27 @@ function fromKintonePerRecordNotification(raw) {
 	return {
 		filterCond: raw.filterCond,
 		title: raw.title,
-		targets: raw.targets.map(fromKintonePerRecordTarget)
-	};
-}
-function fromKintoneReminderTarget(raw) {
-	const result = { entity: fromKintoneEntity$2(raw.entity) };
-	if (raw.includeSubs !== void 0) return {
-		...result,
-		includeSubs: raw.includeSubs
+		targets: raw.targets.map(fromKintoneTarget)
 	};
-	return result;
 }
 function fromKintoneReminderNotification(raw) {
+	const daysLater = Number(raw.timing.daysLater);
+	if (!Number.isFinite(daysLater)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected non-numeric daysLater from kintone API: ${raw.timing.daysLater}`);
 	const result = {
 		code: raw.timing.code,
-		daysLater: Number(raw.timing.daysLater),
+		daysLater,
 		filterCond: raw.filterCond,
 		title: raw.title,
-		targets: raw.targets.map(fromKintoneReminderTarget)
-	};
-	if ("hoursLater" in raw.timing) return {
-		...result,
-		hoursLater: Number(raw.timing.hoursLater)
+		targets: raw.targets.map(fromKintoneTarget)
 	};
+	if ("hoursLater" in raw.timing) {
+		const hoursLater = Number(raw.timing.hoursLater);
+		if (!Number.isFinite(hoursLater)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected non-numeric hoursLater from kintone API: ${raw.timing.hoursLater}`);
+		return {
+			...result,
+			hoursLater
+		};
+	}
 	if ("time" in raw.timing) return {
 		...result,
 		time: raw.timing.time
@@ -4740,7 +4791,7 @@ function toKintoneGeneralNotification(notification) {
 	if (notification.includeSubs !== void 0) result.includeSubs = notification.includeSubs;
 	return result;
 }
-function toKintonePerRecordTarget(target) {
+function toKintoneTarget(target) {
 	const result = { entity: toKintoneEntity$2(target.entity) };
 	if (target.includeSubs !== void 0) result.includeSubs = target.includeSubs;
 	return result;
@@ -4749,14 +4800,9 @@ function toKintonePerRecordNotification(notification) {
 	return {
 		filterCond: notification.filterCond,
 		title: notification.title,
-		targets: notification.targets.map(toKintonePerRecordTarget)
+		targets: notification.targets.map(toKintoneTarget)
 	};
 }
-function toKintoneReminderTarget(target) {
-	const result = { entity: toKintoneEntity$2(target.entity) };
-	if (target.includeSubs !== void 0) result.includeSubs = target.includeSubs;
-	return result;
-}
 function toKintoneReminderNotification(notification) {
 	if (notification.hoursLater !== void 0 && notification.time !== void 0) throw new SystemError(SystemErrorCode.ExternalApiError, `Reminder notification "${notification.code}" must not have both "hoursLater" and "time"`);
 	const timing = {
@@ -4769,7 +4815,7 @@ function toKintoneReminderNotification(notification) {
 		timing,
 		filterCond: notification.filterCond,
 		title: notification.title,
-		targets: notification.targets.map(toKintoneReminderTarget)
+		targets: notification.targets.map(toKintoneTarget)
 	};
 }
 var KintoneNotificationConfigurator = class {
@@ -4966,7 +5012,7 @@ const VALID_ASSIGNEE_TYPES$1 = new Set([
 	"ALL",
 	"ANY"
 ]);
-const VALID_ENTITY_TYPES$4 = new Set([
+const VALID_ENTITY_TYPES$3 = new Set([
 	"USER",
 	"GROUP",
 	"ORGANIZATION",
@@ -4976,7 +5022,7 @@ const VALID_ENTITY_TYPES$4 = new Set([
 ]);
 const VALID_ACTION_TYPES$1 = new Set(["PRIMARY", "SECONDARY"]);
 function fromKintoneEntity$1(raw) {
-	if (!VALID_ENTITY_TYPES$4.has(raw.entity.type)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected entity type from kintone API: ${raw.entity.type}`);
+	if (!VALID_ENTITY_TYPES$3.has(raw.entity.type)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected entity type from kintone API: ${raw.entity.type}`);
 	const result = { type: raw.entity.type };
 	const withCode = raw.entity.code !== void 0 ? {
 		...result,
@@ -5118,14 +5164,14 @@ function createProcessManagementCliContainer(config) {
 
 //#endregion
 //#region src/core/adapters/kintone/recordPermissionConfigurator.ts
-const VALID_ENTITY_TYPES$3 = new Set([
+const VALID_ENTITY_TYPES$2 = new Set([
 	"USER",
 	"GROUP",
 	"ORGANIZATION",
 	"FIELD_ENTITY"
 ]);
 function fromKintoneEntity(raw) {
-	if (!VALID_ENTITY_TYPES$3.has(raw.entity.type)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected entity type from kintone API: ${raw.entity.type}`);
+	if (!VALID_ENTITY_TYPES$2.has(raw.entity.type)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected entity type from kintone API: ${raw.entity.type}`);
 	return {
 		entity: {
 			type: raw.entity.type,
@@ -5220,8 +5266,8 @@ function createRecordPermissionCliContainer(config) {
 }
 
 //#endregion
-//#region src/core/adapters/kintone/reportConfigurator.ts
-const VALID_CHART_TYPES$1 = new Set([
+//#region src/core/domain/report/valueObject.ts
+const CHART_TYPES = [
 	"BAR",
 	"COLUMN",
 	"PIE",
@@ -5231,13 +5277,21 @@ const VALID_CHART_TYPES$1 = new Set([
 	"AREA",
 	"SPLINE",
 	"SPLINE_AREA"
-]);
-const VALID_CHART_MODES$1 = new Set([
+];
+const VALID_CHART_TYPES = new Set(CHART_TYPES);
+function isChartType(value) {
+	return VALID_CHART_TYPES.has(value);
+}
+const CHART_MODES = [
 	"NORMAL",
 	"STACKED",
 	"PERCENTAGE"
-]);
-const VALID_GROUP_PERS = new Set([
+];
+const VALID_CHART_MODES = new Set(CHART_MODES);
+function isChartMode(value) {
+	return VALID_CHART_MODES.has(value);
+}
+const GROUP_PERS = [
 	"YEAR",
 	"QUARTER",
 	"MONTH",
@@ -5245,38 +5299,78 @@ const VALID_GROUP_PERS = new Set([
 	"DAY",
 	"HOUR",
 	"MINUTE"
-]);
-const VALID_AGGREGATION_TYPES$1 = new Set([
+];
+const VALID_GROUP_PERS = new Set(GROUP_PERS);
+function isGroupPer(value) {
+	return VALID_GROUP_PERS.has(value);
+}
+const AGGREGATION_TYPES = [
 	"COUNT",
 	"SUM",
 	"AVERAGE",
 	"MAX",
 	"MIN"
-]);
-const VALID_SORT_BYS = new Set([
+];
+const VALID_AGGREGATION_TYPES = new Set(AGGREGATION_TYPES);
+function isAggregationType(value) {
+	return VALID_AGGREGATION_TYPES.has(value);
+}
+const SORT_BYS = [
 	"TOTAL",
 	"GROUP1",
 	"GROUP2",
 	"GROUP3"
-]);
-const VALID_SORT_ORDERS = new Set(["ASC", "DESC"]);
-const VALID_PERIODIC_REPORT_EVERYS = new Set([
+];
+const VALID_SORT_BYS = new Set(SORT_BYS);
+function isSortBy(value) {
+	return VALID_SORT_BYS.has(value);
+}
+const SORT_ORDERS = ["ASC", "DESC"];
+const VALID_SORT_ORDERS = new Set(SORT_ORDERS);
+function isSortOrder(value) {
+	return VALID_SORT_ORDERS.has(value);
+}
+const PERIODIC_REPORT_EVERYS = [
 	"YEAR",
 	"QUARTER",
 	"MONTH",
 	"WEEK",
 	"DAY",
 	"HOUR"
-]);
-const VALID_PERIODIC_REPORT_PATTERNS = new Set([
+];
+const VALID_PERIODIC_REPORT_EVERYS = new Set(PERIODIC_REPORT_EVERYS);
+function isPeriodicReportEvery(value) {
+	return VALID_PERIODIC_REPORT_EVERYS.has(value);
+}
+const PERIODIC_REPORT_PATTERNS = [
 	"JAN_APR_JUL_OCT",
 	"FEB_MAY_AUG_NOV",
 	"MAR_JUN_SEP_DEC"
-]);
+];
+const VALID_PERIODIC_REPORT_PATTERNS = new Set(PERIODIC_REPORT_PATTERNS);
+function isPeriodicReportPattern(value) {
+	return VALID_PERIODIC_REPORT_PATTERNS.has(value);
+}
+const DAYS_OF_WEEK = [
+	"SUNDAY",
+	"MONDAY",
+	"TUESDAY",
+	"WEDNESDAY",
+	"THURSDAY",
+	"FRIDAY",
+	"SATURDAY"
+];
+const VALID_DAYS_OF_WEEK = new Set(DAYS_OF_WEEK);
+function isDayOfWeek(value) {
+	return VALID_DAYS_OF_WEEK.has(value);
+}
+
+//#endregion
+//#region src/core/adapters/kintone/reportConfigurator.ts
 function fromKintoneGroup(raw) {
 	const result = { code: raw.code };
 	if (raw.per !== void 0) {
-		if (!VALID_GROUP_PERS.has(raw.per)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected group per value from kintone API: ${raw.per}`);
+		if (!isGroupPer(raw.per)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected group per value from kintone API: ${raw.per}`);
 		return {
 			...result,
 			per: raw.per
@@ -5285,7 +5379,7 @@ function fromKintoneGroup(raw) {
 	return result;
 }
 function fromKintoneAggregation(raw) {
-	if (!VALID_AGGREGATION_TYPES$1.has(raw.type)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected aggregation type value from kintone API: ${raw.type}`);
+	if (!isAggregationType(raw.type)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected aggregation type value from kintone API: ${raw.type}`);
 	const result = { type: raw.type };
 	if (raw.code !== void 0) return {
 		...result,
@@ -5294,30 +5388,37 @@ function fromKintoneAggregation(raw) {
 	return result;
 }
 function fromKintoneSort(raw) {
-	if (!VALID_SORT_BYS.has(raw.by)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected sort by value from kintone API: ${raw.by}`);
-	if (!VALID_SORT_ORDERS.has(raw.order)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected sort order value from kintone API: ${raw.order}`);
+	if (!isSortBy(raw.by)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected sort by value from kintone API: ${raw.by}`);
+	if (!isSortOrder(raw.order)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected sort order value from kintone API: ${raw.order}`);
 	return {
 		by: raw.by,
 		order: raw.order
 	};
 }
 function fromKintonePeriodicReportPeriod(raw) {
-	if (!VALID_PERIODIC_REPORT_EVERYS.has(raw.every)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected periodicReport every value from kintone API: ${raw.every}`);
-	if (raw.pattern !== void 0 && !VALID_PERIODIC_REPORT_PATTERNS.has(raw.pattern)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected periodicReport pattern value from kintone API: ${raw.pattern}`);
+	if (!isPeriodicReportEvery(raw.every)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected periodicReport every value from kintone API: ${raw.every}`);
+	if (raw.pattern !== void 0 && !isPeriodicReportPattern(raw.pattern)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected periodicReport pattern value from kintone API: ${raw.pattern}`);
 	let dayOfMonth;
 	if (raw.dayOfMonth !== void 0) if (String(raw.dayOfMonth) === "END_OF_MONTH") dayOfMonth = "END_OF_MONTH";
 	else {
 		const parsed = Number(raw.dayOfMonth);
-		if (Number.isNaN(parsed)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected periodicReport dayOfMonth value from kintone API: ${String(raw.dayOfMonth)}`);
+		if (!Number.isFinite(parsed) || !Number.isInteger(parsed)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected periodicReport dayOfMonth value from kintone API: ${String(raw.dayOfMonth)}`);
 		dayOfMonth = parsed;
 	}
 	return {
 		every: raw.every,
-		...raw.month !== void 0 ? { month: Number(raw.month) } : {},
-		...raw.pattern !== void 0 ? { pattern: raw.pattern } : {},
+		...raw.month !== void 0 ? { month: (() => {
+			const m = Number(raw.month);
+			if (!Number.isFinite(m)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected non-numeric month from kintone API: ${raw.month}`);
+			return m;
+		})() } : {},
+		...raw.pattern !== void 0 && isPeriodicReportPattern(raw.pattern) ? { pattern: raw.pattern } : {},
 		...dayOfMonth !== void 0 ? { dayOfMonth } : {},
 		...raw.time !== void 0 ? { time: raw.time } : {},
-		...raw.dayOfWeek !== void 0 ? { dayOfWeek: raw.dayOfWeek } : {},
+		...raw.dayOfWeek !== void 0 ? (() => {
+			if (!isDayOfWeek(raw.dayOfWeek)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected periodicReport dayOfWeek value from kintone API: ${raw.dayOfWeek}`);
+			return { dayOfWeek: raw.dayOfWeek };
+		})() : {},
 		...raw.minute !== void 0 ? { minute: raw.minute } : {}
 	};
 }
@@ -5328,12 +5429,16 @@ function fromKintonePeriodicReport(raw) {
 	};
 }
 function fromKintoneReportConfig(raw) {
-	if (!VALID_CHART_TYPES$1.has(raw.chartType)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected chartType value from kintone API: ${raw.chartType}`);
-	if (raw.chartMode !== void 0 && raw.chartMode !== "" && !VALID_CHART_MODES$1.has(raw.chartMode)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected chartMode value from kintone API: ${raw.chartMode}`);
+	if (!isChartType(raw.chartType)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected chartType value from kintone API: ${raw.chartType}`);
+	if (raw.chartMode !== void 0 && raw.chartMode !== "" && !isChartMode(raw.chartMode)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected chartMode value from kintone API: ${raw.chartMode}`);
 	const result = {
 		chartType: raw.chartType,
-		...raw.chartMode !== void 0 && raw.chartMode !== "" && VALID_CHART_MODES$1.has(raw.chartMode) ? { chartMode: raw.chartMode } : {},
-		index: Number(raw.index),
+		...raw.chartMode !== void 0 && raw.chartMode !== "" && isChartMode(raw.chartMode) ? { chartMode: raw.chartMode } : {},
+		index: (() => {
+			const idx = Number(raw.index);
+			if (!Number.isFinite(idx)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected non-numeric index from kintone API: ${raw.index}`);
+			return idx;
+		})(),
 		name: raw.name,
 		groups: raw.groups.map(fromKintoneGroup),
 		aggregations: raw.aggregations.map(fromKintoneAggregation),
@@ -5366,7 +5471,7 @@ function toKintonePeriodicReportPeriod(period) {
 	const result = { every: period.every };
 	if (period.month !== void 0) result.month = String(period.month);
 	if (period.pattern !== void 0) result.pattern = period.pattern;
-	if (period.dayOfMonth !== void 0) result.dayOfMonth = period.dayOfMonth;
+	if (period.dayOfMonth !== void 0) result.dayOfMonth = typeof period.dayOfMonth === "number" ? String(period.dayOfMonth) : period.dayOfMonth;
 	if (period.time !== void 0) result.time = period.time;
 	if (period.dayOfWeek !== void 0) result.dayOfWeek = period.dayOfWeek;
 	if (period.minute !== void 0) result.minute = period.minute;
@@ -5463,16 +5568,31 @@ const VIEW_TYPES = [
 	"CUSTOM"
 ];
 const VALID_VIEW_TYPES = new Set(VIEW_TYPES);
+function isViewType(value) {
+	return VALID_VIEW_TYPES.has(value);
+}
 const DEVICE_TYPES = ["DESKTOP", "ANY"];
 const VALID_DEVICE_TYPES = new Set(DEVICE_TYPES);
+function isDeviceType(value) {
+	return VALID_DEVICE_TYPES.has(value);
+}
 
 //#endregion
 //#region src/core/adapters/kintone/viewConfigurator.ts
 function fromKintoneView(name, raw) {
-	if (!VALID_VIEW_TYPES.has(raw.type)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected view type from kintone API: ${raw.type}`);
+	if (!isViewType(raw.type)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected view type from kintone API: ${raw.type}`);
+	let device;
+	if (raw.device !== void 0) {
+		if (!isDeviceType(raw.device)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected device type from kintone API: ${raw.device}`);
+		device = raw.device;
+	}
 	return {
 		type: raw.type,
-		index: typeof raw.index === "string" ? Number(raw.index) : raw.index,
+		index: (() => {
+			const idx = typeof raw.index === "string" ? Number(raw.index) : raw.index;
+			if (!Number.isFinite(idx)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected non-numeric index from kintone API: ${raw.index}`);
+			return idx;
+		})(),
 		name,
 		...raw.builtinType !== void 0 && { builtinType: raw.builtinType },
 		...raw.fields !== void 0 && { fields: raw.fields },
@@ -5480,10 +5600,7 @@ function fromKintoneView(name, raw) {
 		...raw.title !== void 0 && { title: raw.title },
 		...raw.html !== void 0 && { html: raw.html },
 		...raw.pager !== void 0 && { pager: raw.pager },
-		...raw.device !== void 0 && { device: (() => {
-			if (!VALID_DEVICE_TYPES.has(raw.device)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected device type from kintone API: ${raw.device}`);
-			return raw.device;
-		})() },
+		...device !== void 0 && { device },
 		...raw.filterCond !== void 0 && { filterCond: raw.filterCond },
 		...raw.sort !== void 0 && { sort: raw.sort }
 	};
@@ -5915,11 +6032,7 @@ function serializeConfig(config) {
 	return result;
 }
 const GeneralSettingsConfigSerializer = { serialize: (config) => {
-	return stringify(serializeConfig(config), {
-		lineWidth: 0,
-		defaultKeyType: "PLAIN",
-		defaultStringType: "PLAIN"
-	});
+	return serializeToYaml(serializeConfig(config));
 } };
 
 //#endregion
@@ -5958,7 +6071,7 @@ function serializeGeneralNotification(notification) {
 	if (notification.includeSubs !== void 0) result.includeSubs = notification.includeSubs;
 	return result;
 }
-function serializePerRecordTarget(target) {
+function serializeTarget(target) {
 	const result = { entity: serializeEntity$1(target.entity) };
 	if (target.includeSubs !== void 0) result.includeSubs = target.includeSubs;
 	return result;
@@ -5967,21 +6080,16 @@ function serializePerRecordNotification(notification) {
 	return {
 		filterCond: notification.filterCond,
 		title: notification.title,
-		targets: notification.targets.map(serializePerRecordTarget)
+		targets: notification.targets.map(serializeTarget)
 	};
 }
-function serializeReminderTarget(target) {
-	const result = { entity: serializeEntity$1(target.entity) };
-	if (target.includeSubs !== void 0) result.includeSubs = target.includeSubs;
-	return result;
-}
 function serializeReminderNotification(notification) {
 	const result = {
 		code: notification.code,
 		daysLater: notification.daysLater,
 		filterCond: notification.filterCond,
 		title: notification.title,
-		targets: notification.targets.map(serializeReminderTarget)
+		targets: notification.targets.map(serializeTarget)
 	};
 	if (notification.hoursLater !== void 0) result.hoursLater = notification.hoursLater;
 	if (notification.time !== void 0) result.time = notification.time;
@@ -5998,11 +6106,7 @@ const NotificationConfigSerializer = { serialize: (config) => {
 		timezone: config.reminder.timezone,
 		notifications: config.reminder.notifications.map(serializeReminderNotification)
 	};
-	return stringify(serialized, {
-		lineWidth: 0,
-		defaultKeyType: "PLAIN",
-		defaultStringType: "PLAIN"
-	});
+	return serializeToYaml(serialized);
 } };
 
 //#endregion
@@ -6037,15 +6141,11 @@ async function saveNotification({ container, input }) {
 //#endregion
 //#region src/core/domain/plugin/services/configSerializer.ts
 const PluginConfigSerializer = { serialize: (config) => {
-	return stringify({ plugins: config.plugins.map((plugin) => ({
+	return serializeToYaml({ plugins: config.plugins.map((plugin) => ({
 		id: plugin.id,
 		name: plugin.name,
 		enabled: plugin.enabled
-	})) }, {
-		lineWidth: 0,
-		defaultKeyType: "PLAIN",
-		defaultStringType: "PLAIN"
-	});
+	})) });
 } };
 
 //#endregion
@@ -6081,7 +6181,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) => {
@@ -6095,10 +6195,6 @@ 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"
 	});
 } };
 
@@ -6133,14 +6229,10 @@ 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
@@ -6211,11 +6303,7 @@ const ReportConfigSerializer = { serialize: (config) => {
 	const reports = {};
 	for (const [name, reportConfig] of Object.entries(config.reports)) reports[name] = serializeReportConfig(reportConfig);
 	serialized.reports = reports;
-	return stringify(serialized, {
-		lineWidth: 0,
-		defaultKeyType: "PLAIN",
-		defaultStringType: "PLAIN"
-	});
+	return serializeToYaml(serialized);
 } };
 
 //#endregion
@@ -6299,11 +6387,7 @@ function serializeViewConfig(config) {
 const ViewConfigSerializer = { serialize: (config) => {
 	const serialized = {};
 	for (const [name, viewConfig] of Object.entries(config.views)) serialized[name] = serializeViewConfig(viewConfig);
-	return stringify({ views: serialized }, {
-		lineWidth: 0,
-		defaultKeyType: "PLAIN",
-		defaultStringType: "PLAIN"
-	});
+	return serializeToYaml({ views: serialized });
 } };
 
 //#endregion
@@ -6660,68 +6744,57 @@ var init_default = define({
 
 //#endregion
 //#region src/core/domain/notification/services/configParser.ts
-const VALID_ENTITY_TYPES$2 = new Set([
-	"USER",
-	"GROUP",
-	"ORGANIZATION",
-	"FIELD_ENTITY"
-]);
 function parseEntity$1(raw, context) {
 	if (!isRecord(raw)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, `${context}: entity must be an object`);
-	const obj = raw;
-	if (typeof obj.type !== "string" || !VALID_ENTITY_TYPES$2.has(obj.type)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidEntityType, `${context}: entity has invalid type: ${String(obj.type)}. Must be USER, GROUP, ORGANIZATION, or FIELD_ENTITY`);
-	if (typeof obj.code !== "string" || obj.code.length === 0) throw new BusinessRuleError(NotificationErrorCode.NtEmptyEntityCode, `${context}: entity must have a non-empty "code" property`);
+	if (typeof raw.type !== "string" || !isNotificationEntityType(raw.type)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidEntityType, `${context}: entity has invalid type: ${String(raw.type)}. Must be USER, GROUP, ORGANIZATION, or FIELD_ENTITY`);
+	if (typeof raw.code !== "string" || raw.code.length === 0) throw new BusinessRuleError(NotificationErrorCode.NtEmptyEntityCode, `${context}: entity must have a non-empty "code" property`);
 	return {
-		type: obj.type,
-		code: obj.code
+		type: raw.type,
+		code: raw.code
 	};
 }
 function parseGeneralNotification(raw, index) {
 	if (!isRecord(raw)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, `General notification at index ${index} must be an object`);
-	const obj = raw;
 	const result = {
-		entity: parseEntity$1(obj.entity, `General notification at index ${index}`),
-		recordAdded: Boolean(obj.recordAdded),
-		recordEdited: Boolean(obj.recordEdited),
-		commentAdded: Boolean(obj.commentAdded),
-		statusChanged: Boolean(obj.statusChanged),
-		fileImported: Boolean(obj.fileImported)
-	};
-	if (obj.includeSubs !== void 0 && obj.includeSubs !== null) return {
+		entity: parseEntity$1(raw.entity, `General notification at index ${index}`),
+		recordAdded: Boolean(raw.recordAdded),
+		recordEdited: Boolean(raw.recordEdited),
+		commentAdded: Boolean(raw.commentAdded),
+		statusChanged: Boolean(raw.statusChanged),
+		fileImported: Boolean(raw.fileImported)
+	};
+	if (raw.includeSubs !== void 0 && raw.includeSubs !== null) return {
 		...result,
-		includeSubs: Boolean(obj.includeSubs)
+		includeSubs: Boolean(raw.includeSubs)
 	};
 	return result;
 }
 function parseGeneralConfig(raw) {
 	if (!isRecord(raw)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, "\"general\" must be an object");
-	const obj = raw;
-	if (!Array.isArray(obj.notifications)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, "\"general\" must have a \"notifications\" array");
-	const notifications = obj.notifications.map((item, i) => parseGeneralNotification(item, i));
+	if (!Array.isArray(raw.notifications)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, "\"general\" must have a \"notifications\" array");
+	const notifications = raw.notifications.map((item, i) => parseGeneralNotification(item, i));
 	return {
-		notifyToCommenter: Boolean(obj.notifyToCommenter),
+		notifyToCommenter: Boolean(raw.notifyToCommenter),
 		notifications
 	};
 }
-function parsePerRecordTarget(raw, index) {
-	if (!isRecord(raw)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, `Per-record target at index ${index} must be an object`);
-	const obj = raw;
-	const result = { entity: parseEntity$1(obj.entity, `Per-record target at index ${index}`) };
-	if (obj.includeSubs !== void 0 && obj.includeSubs !== null) return {
+function parseTarget(raw, index, context) {
+	if (!isRecord(raw)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, `${context} target at index ${index} must be an object`);
+	const result = { entity: parseEntity$1(raw.entity, `${context} target at index ${index}`) };
+	if (raw.includeSubs !== void 0 && raw.includeSubs !== null) return {
 		...result,
-		includeSubs: Boolean(obj.includeSubs)
+		includeSubs: Boolean(raw.includeSubs)
 	};
 	return result;
 }
 function parsePerRecordNotification(raw, index) {
 	if (!isRecord(raw)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, `Per-record notification at index ${index} must be an object`);
-	const obj = raw;
-	if (!Array.isArray(obj.targets)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, `Per-record notification at index ${index} must have a "targets" array`);
-	const targets = obj.targets.map((item, i) => parsePerRecordTarget(item, i));
-	if (typeof obj.filterCond !== "string") throw new BusinessRuleError(NotificationErrorCode.NtMissingRequiredField, `Per-record notification at index ${index} must have a "filterCond" string property`);
+	if (!Array.isArray(raw.targets)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, `Per-record notification at index ${index} must have a "targets" array`);
+	const targets = raw.targets.map((item, i) => parseTarget(item, i, "Per-record"));
+	if (typeof raw.filterCond !== "string") throw new BusinessRuleError(NotificationErrorCode.NtMissingRequiredField, `Per-record notification at index ${index} must have a "filterCond" string property`);
 	return {
-		filterCond: obj.filterCond,
-		title: typeof obj.title === "string" ? obj.title : "",
+		filterCond: raw.filterCond,
+		title: typeof raw.title === "string" ? raw.title : "",
 		targets
 	};
 }
@@ -6729,63 +6802,50 @@ function parsePerRecordConfig(raw) {
 	if (!Array.isArray(raw)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, "\"perRecord\" must be an array");
 	return raw.map((item, i) => parsePerRecordNotification(item, i));
 }
-function parseReminderTarget(raw, index) {
-	if (!isRecord(raw)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, `Reminder target at index ${index} must be an object`);
-	const obj = raw;
-	const result = { entity: parseEntity$1(obj.entity, `Reminder target at index ${index}`) };
-	if (obj.includeSubs !== void 0 && obj.includeSubs !== null) return {
-		...result,
-		includeSubs: Boolean(obj.includeSubs)
-	};
-	return result;
-}
 function parseReminderNotification(raw, index) {
 	if (!isRecord(raw)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, `Reminder notification at index ${index} must be an object`);
-	const obj = raw;
-	if (typeof obj.code !== "string" || obj.code.length === 0) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, `Reminder notification at index ${index} must have a non-empty "code" property`);
-	if (!Array.isArray(obj.targets)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, `Reminder notification at index ${index} must have a "targets" array`);
-	const targets = obj.targets.map((item, i) => parseReminderTarget(item, i));
-	if (typeof obj.daysLater !== "number") throw new BusinessRuleError(NotificationErrorCode.NtMissingRequiredField, `Reminder notification at index ${index} must have a "daysLater" number property`);
-	const hasHoursLater = obj.hoursLater !== void 0 && obj.hoursLater !== null;
-	const hasTime = obj.time !== void 0 && obj.time !== null;
+	if (typeof raw.code !== "string" || raw.code.length === 0) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, `Reminder notification at index ${index} must have a non-empty "code" property`);
+	if (!Array.isArray(raw.targets)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, `Reminder notification at index ${index} must have a "targets" array`);
+	const targets = raw.targets.map((item, i) => parseTarget(item, i, "Reminder"));
+	if (typeof raw.daysLater !== "number") throw new BusinessRuleError(NotificationErrorCode.NtMissingRequiredField, `Reminder notification at index ${index} must have a "daysLater" property`);
+	if (!Number.isInteger(raw.daysLater) || raw.daysLater < 0) throw new BusinessRuleError(NotificationErrorCode.NtInvalidDaysLater, `Reminder notification at index ${index} has invalid "daysLater": ${raw.daysLater}. Must be a non-negative integer`);
+	const hasHoursLater = raw.hoursLater !== void 0 && raw.hoursLater !== null;
+	const hasTime = raw.time !== void 0 && raw.time !== null;
 	if (hasHoursLater && hasTime) throw new BusinessRuleError(NotificationErrorCode.NtConflictingTimingFields, `Reminder notification at index ${index} must not have both "hoursLater" and "time"`);
+	if (hasHoursLater && (typeof raw.hoursLater !== "number" || !Number.isInteger(raw.hoursLater) || raw.hoursLater < 0)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidHoursLater, `Reminder notification at index ${index} has invalid "hoursLater": ${String(raw.hoursLater)}. Must be a non-negative integer`);
+	if (hasTime && typeof raw.time !== "string") throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, `Reminder notification at index ${index} has non-string "time": ${String(raw.time)}`);
 	const result = {
-		code: obj.code,
-		daysLater: obj.daysLater,
-		filterCond: typeof obj.filterCond === "string" ? obj.filterCond : "",
-		title: typeof obj.title === "string" ? obj.title : "",
+		code: raw.code,
+		daysLater: raw.daysLater,
+		filterCond: typeof raw.filterCond === "string" ? raw.filterCond : "",
+		title: typeof raw.title === "string" ? raw.title : "",
 		targets
 	};
-	if (hasHoursLater) return {
+	if (hasHoursLater && typeof raw.hoursLater === "number") return {
 		...result,
-		hoursLater: typeof obj.hoursLater === "number" ? obj.hoursLater : 0
+		hoursLater: raw.hoursLater
 	};
 	if (hasTime) return {
 		...result,
-		time: typeof obj.time === "string" ? obj.time : ""
+		time: typeof raw.time === "string" ? raw.time : ""
 	};
 	return result;
 }
 function parseReminderConfig(raw) {
 	if (!isRecord(raw)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, "\"reminder\" must be an object");
-	const obj = raw;
-	if (!Array.isArray(obj.notifications)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, "\"reminder\" must have a \"notifications\" array");
-	const notifications = obj.notifications.map((item, i) => parseReminderNotification(item, i));
+	if (!Array.isArray(raw.notifications)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, "\"reminder\" must have a \"notifications\" array");
+	const notifications = raw.notifications.map((item, i) => parseReminderNotification(item, i));
 	return {
-		timezone: typeof obj.timezone === "string" ? obj.timezone : "Asia/Tokyo",
+		timezone: typeof raw.timezone === "string" ? raw.timezone : "Asia/Tokyo",
 		notifications
 	};
 }
 const NotificationConfigParser = { parse: (rawText) => {
-	if (rawText.trim().length === 0) throw new BusinessRuleError(NotificationErrorCode.NtEmptyConfigText, "Notification config text is empty");
-	let parsed;
-	try {
-		parsed = parse(rawText);
-	} catch (error) {
-		throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigYaml, `Failed to parse YAML: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	if (!isRecord(parsed)) throw new BusinessRuleError(NotificationErrorCode.NtInvalidConfigStructure, "Config must be a YAML object");
-	const obj = parsed;
+	const obj = parseYamlConfig(rawText, {
+		emptyConfigText: NotificationErrorCode.NtEmptyConfigText,
+		invalidConfigYaml: NotificationErrorCode.NtInvalidConfigYaml,
+		invalidConfigStructure: 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);
@@ -7204,26 +7264,28 @@ var notification_default = define({
 //#region src/core/domain/plugin/services/configParser.ts
 function parsePluginEntry(raw, index) {
 	if (!isRecord(raw)) throw new BusinessRuleError(PluginErrorCode.PlInvalidConfigStructure, `Plugin at index ${index} must be an object`);
-	const obj = raw;
-	if (typeof obj.id !== "string" || obj.id.length === 0) throw new BusinessRuleError(PluginErrorCode.PlEmptyPluginId, `Plugin at index ${index} must have a non-empty "id" property`);
+	if (typeof raw.id !== "string" || raw.id.length === 0) throw new BusinessRuleError(PluginErrorCode.PlEmptyPluginId, `Plugin at index ${index} must have a non-empty "id" property`);
+	if (raw.enabled !== void 0 && raw.enabled !== null && typeof raw.enabled !== "boolean") throw new BusinessRuleError(PluginErrorCode.PlInvalidConfigStructure, `Plugin at index ${index} has invalid "enabled": must be a boolean`);
 	return {
-		id: obj.id,
-		name: typeof obj.name === "string" ? obj.name : "",
-		enabled: typeof obj.enabled === "boolean" ? obj.enabled : true
+		id: raw.id,
+		name: typeof raw.name === "string" ? raw.name : "",
+		enabled: typeof raw.enabled === "boolean" ? raw.enabled : true
 	};
 }
 const PluginConfigParser = { parse: (rawText) => {
-	if (rawText.trim().length === 0) throw new BusinessRuleError(PluginErrorCode.PlEmptyConfigText, "Plugin config text is empty");
-	let parsed;
-	try {
-		parsed = parse(rawText);
-	} catch (error) {
-		throw new BusinessRuleError(PluginErrorCode.PlInvalidConfigYaml, `Failed to parse YAML: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	if (!isRecord(parsed)) throw new BusinessRuleError(PluginErrorCode.PlInvalidConfigStructure, "Config must be a YAML object");
-	const obj = parsed;
+	const obj = parseYamlConfig(rawText, {
+		emptyConfigText: PluginErrorCode.PlEmptyConfigText,
+		invalidConfigYaml: PluginErrorCode.PlInvalidConfigYaml,
+		invalidConfigStructure: PluginErrorCode.PlInvalidConfigStructure
+	}, "Plugin");
 	if (!Array.isArray(obj.plugins)) throw new BusinessRuleError(PluginErrorCode.PlInvalidConfigStructure, "Config must have a \"plugins\" array");
-	return { plugins: obj.plugins.map((item, i) => parsePluginEntry(item, i)) };
+	const plugins = obj.plugins.map((item, i) => parsePluginEntry(item, i));
+	const seenIds = /* @__PURE__ */ new Set();
+	for (const plugin of plugins) {
+		if (seenIds.has(plugin.id)) throw new BusinessRuleError(PluginErrorCode.PlDuplicatePluginId, `Duplicate plugin ID: "${plugin.id}"`);
+		seenIds.add(plugin.id);
+	}
+	return { plugins };
 } };
 
 //#endregion
@@ -7447,85 +7509,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}"`);
@@ -7678,7 +7732,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;
 }
@@ -7816,56 +7870,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
@@ -8000,7 +8049,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,
@@ -8049,7 +8098,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");
@@ -8111,140 +8160,76 @@ var record_acl_default = define({
 
 //#endregion
 //#region src/core/domain/report/services/configParser.ts
-const VALID_CHART_TYPES = new Set([
-	"BAR",
-	"COLUMN",
-	"PIE",
-	"LINE",
-	"PIVOT_TABLE",
-	"TABLE",
-	"AREA",
-	"SPLINE",
-	"SPLINE_AREA"
-]);
-const VALID_CHART_MODES = new Set([
-	"NORMAL",
-	"STACKED",
-	"PERCENTAGE"
-]);
-const VALID_GROUP_PER = new Set([
-	"YEAR",
-	"QUARTER",
-	"MONTH",
-	"WEEK",
-	"DAY",
-	"HOUR",
-	"MINUTE"
-]);
-const VALID_AGGREGATION_TYPES = new Set([
-	"COUNT",
-	"SUM",
-	"AVERAGE",
-	"MAX",
-	"MIN"
-]);
-const VALID_SORT_BY = new Set([
-	"TOTAL",
-	"GROUP1",
-	"GROUP2",
-	"GROUP3"
-]);
-const VALID_DAY_OF_WEEK = new Set([
-	"SUNDAY",
-	"MONDAY",
-	"TUESDAY",
-	"WEDNESDAY",
-	"THURSDAY",
-	"FRIDAY",
-	"SATURDAY"
-]);
-const VALID_PERIODIC_PATTERN = new Set([
-	"JAN_APR_JUL_OCT",
-	"FEB_MAY_AUG_NOV",
-	"MAR_JUN_SEP_DEC"
-]);
-const VALID_SORT_ORDER = new Set(["ASC", "DESC"]);
-const VALID_PERIODIC_EVERY = new Set([
-	"YEAR",
-	"QUARTER",
-	"MONTH",
-	"WEEK",
-	"DAY",
-	"HOUR"
-]);
 function parseGroup(raw, index) {
 	if (!isRecord(raw)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Group at index ${index} must be an object`);
-	const obj = raw;
-	if (typeof obj.code !== "string" || obj.code.length === 0) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Group at index ${index} must have a non-empty "code" property`);
-	const result = { code: obj.code };
-	if (obj.per !== void 0 && obj.per !== null) {
-		if (typeof obj.per !== "string" || !VALID_GROUP_PER.has(obj.per)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Group at index ${index} has invalid per: ${String(obj.per)}. Must be YEAR, QUARTER, MONTH, WEEK, DAY, HOUR, or MINUTE`);
+	if (typeof raw.code !== "string" || raw.code.length === 0) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Group at index ${index} must have a non-empty "code" property`);
+	const result = { code: raw.code };
+	if (raw.per !== void 0 && raw.per !== null) {
+		if (typeof raw.per !== "string" || !isGroupPer(raw.per)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Group at index ${index} has invalid per: ${String(raw.per)}. Must be YEAR, QUARTER, MONTH, WEEK, DAY, HOUR, or MINUTE`);
 		return {
 			...result,
-			per: obj.per
+			per: raw.per
 		};
 	}
 	return result;
 }
 function parseAggregation(raw, index) {
 	if (!isRecord(raw)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Aggregation at index ${index} must be an object`);
-	const obj = raw;
-	if (typeof obj.type !== "string" || !VALID_AGGREGATION_TYPES.has(obj.type)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Aggregation at index ${index} has invalid type: ${String(obj.type)}. Must be COUNT, SUM, AVERAGE, MAX, or MIN`);
-	const result = { type: obj.type };
-	if (obj.code !== void 0 && obj.code !== null) {
-		if (typeof obj.code !== "string") throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Aggregation at index ${index} has invalid code: must be a string`);
+	if (typeof raw.type !== "string" || !isAggregationType(raw.type)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Aggregation at index ${index} has invalid type: ${String(raw.type)}. Must be COUNT, SUM, AVERAGE, MAX, or MIN`);
+	const result = { type: raw.type };
+	if (raw.code !== void 0 && raw.code !== null) {
+		if (typeof raw.code !== "string") throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Aggregation at index ${index} has invalid code: must be a string`);
 		return {
 			...result,
-			code: obj.code
+			code: raw.code
 		};
 	}
 	return result;
 }
 function parseSort(raw, index) {
 	if (!isRecord(raw)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Sort at index ${index} must be an object`);
-	const obj = raw;
-	if (typeof obj.by !== "string" || !VALID_SORT_BY.has(obj.by)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Sort at index ${index} has invalid by: ${String(obj.by)}. Must be TOTAL, GROUP1, GROUP2, or GROUP3`);
-	if (typeof obj.order !== "string" || !VALID_SORT_ORDER.has(obj.order)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Sort at index ${index} has invalid order: ${String(obj.order)}. Must be ASC or DESC`);
+	if (typeof raw.by !== "string" || !isSortBy(raw.by)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Sort at index ${index} has invalid by: ${String(raw.by)}. Must be TOTAL, GROUP1, GROUP2, or GROUP3`);
+	if (typeof raw.order !== "string" || !isSortOrder(raw.order)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `Sort at index ${index} has invalid order: ${String(raw.order)}. Must be ASC or DESC`);
 	return {
-		by: obj.by,
-		order: obj.order
+		by: raw.by,
+		order: raw.order
 	};
 }
 function parsePeriodicReportPeriod(raw) {
 	if (!isRecord(raw)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, "periodicReport.period must be an object");
-	const obj = raw;
-	if (typeof obj.every !== "string" || !VALID_PERIODIC_EVERY.has(obj.every)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `periodicReport.period has invalid every: ${String(obj.every)}. Must be YEAR, QUARTER, MONTH, WEEK, DAY, or HOUR`);
-	const every = obj.every;
+	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 (obj.month !== void 0 && obj.month !== null) {
-		const parsed = Number(obj.month);
-		if (Number.isNaN(parsed)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `periodicReport.period has invalid month: ${String(obj.month)}. Must be a number`);
+	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 (obj.pattern !== void 0 && obj.pattern !== null) {
-		if (typeof obj.pattern !== "string" || !VALID_PERIODIC_PATTERN.has(obj.pattern)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `periodicReport.period has invalid pattern: ${String(obj.pattern)}. Must be JAN_APR_JUL_OCT, FEB_MAY_AUG_NOV, or MAR_JUN_SEP_DEC`);
-		pattern = obj.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 (obj.dayOfMonth !== void 0 && obj.dayOfMonth !== null) if (obj.dayOfMonth === "END_OF_MONTH") dayOfMonth = "END_OF_MONTH";
+	if (raw.dayOfMonth !== void 0 && raw.dayOfMonth !== null) if (raw.dayOfMonth === "END_OF_MONTH") dayOfMonth = "END_OF_MONTH";
 	else {
-		const parsed = Number(obj.dayOfMonth);
-		if (Number.isNaN(parsed)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `periodicReport.period has invalid dayOfMonth: ${String(obj.dayOfMonth)}. Must be a number or "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`);
 		dayOfMonth = parsed;
 	}
 	let time;
-	if (obj.time !== void 0 && obj.time !== null) time = String(obj.time);
+	if (raw.time !== void 0 && raw.time !== null) time = String(raw.time);
 	let dayOfWeek;
-	if (obj.dayOfWeek !== void 0 && obj.dayOfWeek !== null) {
-		const dayStr = String(obj.dayOfWeek);
-		if (!VALID_DAY_OF_WEEK.has(dayStr)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `periodicReport.period has invalid dayOfWeek: ${dayStr}. Must be SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, or SATURDAY`);
+	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 (obj.minute !== void 0 && obj.minute !== null) {
-		const parsed = Number(obj.minute);
-		if (Number.isNaN(parsed)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, `periodicReport.period has invalid minute: ${String(obj.minute)}. Must be a number`);
+	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;
 	}
 	return {
@@ -8259,32 +8244,34 @@ function parsePeriodicReportPeriod(raw) {
 }
 function parsePeriodicReport(raw) {
 	if (!isRecord(raw)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, "periodicReport must be an object");
-	const obj = raw;
-	if (typeof obj.active !== "boolean") throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, "periodicReport.active must be a boolean");
-	const period = parsePeriodicReportPeriod(obj.period);
+	const active = raw.active;
+	if (typeof active !== "boolean") throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, "periodicReport.active must be a boolean");
 	return {
-		active: obj.active,
-		period
+		active,
+		period: parsePeriodicReportPeriod(raw.period)
 	};
 }
 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`);
-	const obj = raw;
-	if (typeof obj.chartType !== "string" || !VALID_CHART_TYPES.has(obj.chartType)) throw new BusinessRuleError(ReportErrorCode.RtInvalidChartType, `Report "${reportName}" has invalid chartType: ${String(obj.chartType)}. Must be BAR, COLUMN, PIE, LINE, PIVOT_TABLE, TABLE, AREA, SPLINE, or SPLINE_AREA`);
+	if (typeof raw.chartType !== "string" || !isChartType(raw.chartType)) throw new BusinessRuleError(ReportErrorCode.RtInvalidChartType, `Report "${reportName}" has invalid chartType: ${String(raw.chartType)}. Must be BAR, COLUMN, PIE, LINE, PIVOT_TABLE, TABLE, AREA, SPLINE, or SPLINE_AREA`);
 	let chartMode;
-	if (obj.chartMode !== void 0 && obj.chartMode !== null) {
-		if (typeof obj.chartMode !== "string" || !VALID_CHART_MODES.has(obj.chartMode)) throw new BusinessRuleError(ReportErrorCode.RtInvalidChartMode, `Report "${reportName}" has invalid chartMode: ${String(obj.chartMode)}. Must be NORMAL, STACKED, or PERCENTAGE`);
-		chartMode = obj.chartMode;
-	}
-	const name = typeof obj.name === "string" && obj.name.length > 0 ? obj.name : reportName;
-	if (name.length === 0) throw new BusinessRuleError(ReportErrorCode.RtEmptyReportName, "Report must have a non-empty name");
-	const index = obj.index !== void 0 && obj.index !== null ? Number(obj.index) : 0;
-	const groups = Array.isArray(obj.groups) ? obj.groups.map((item, i) => parseGroup(item, i)) : [];
-	const aggregations = Array.isArray(obj.aggregations) ? obj.aggregations.map((item, i) => parseAggregation(item, i)) : [];
-	const filterCond = typeof obj.filterCond === "string" ? obj.filterCond : "";
-	const sorts = Array.isArray(obj.sorts) ? obj.sorts.map((item, i) => parseSort(item, i)) : [];
+	if (raw.chartMode !== void 0 && raw.chartMode !== null) {
+		if (typeof raw.chartMode !== "string" || !isChartMode(raw.chartMode)) throw new BusinessRuleError(ReportErrorCode.RtInvalidChartMode, `Report "${reportName}" has invalid chartMode: ${String(raw.chartMode)}. Must be NORMAL, STACKED, or PERCENTAGE`);
+		chartMode = raw.chartMode;
+	}
+	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 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 result = {
-		chartType: obj.chartType,
+		chartType: raw.chartType,
 		...chartMode !== void 0 ? { chartMode } : {},
 		index,
 		name,
@@ -8293,22 +8280,18 @@ function parseReportConfig(raw, reportName) {
 		filterCond,
 		sorts
 	};
-	if (obj.periodicReport !== void 0 && obj.periodicReport !== null) return {
+	if (raw.periodicReport !== void 0 && raw.periodicReport !== null) return {
 		...result,
-		periodicReport: parsePeriodicReport(obj.periodicReport)
+		periodicReport: parsePeriodicReport(raw.periodicReport)
 	};
 	return result;
 }
 const ReportConfigParser = { parse: (rawText) => {
-	if (rawText.trim().length === 0) throw new BusinessRuleError(ReportErrorCode.RtEmptyConfigText, "Report config text is empty");
-	let parsed;
-	try {
-		parsed = parse(rawText);
-	} catch (error) {
-		throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigYaml, `Failed to parse YAML: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	if (!isRecord(parsed)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, "Config must be a YAML object");
-	const obj = parsed;
+	const obj = parseYamlConfig(rawText, {
+		emptyConfigText: ReportErrorCode.RtEmptyConfigText,
+		invalidConfigYaml: ReportErrorCode.RtInvalidConfigYaml,
+		invalidConfigStructure: ReportErrorCode.RtInvalidConfigStructure
+	}, "Report");
 	if (!isRecord(obj.reports)) throw new BusinessRuleError(ReportErrorCode.RtInvalidConfigStructure, "Config must have a \"reports\" object");
 	const rawReports = obj.reports;
 	const reports = {};
@@ -8462,29 +8445,26 @@ function compareReports(local, remote) {
 	return diffs;
 }
 const ReportDiffDetector = { detect: (local, remote) => {
-	const entries = [];
-	for (const [name, localReport] of Object.entries(local.reports)) {
-		const remoteReport = remote.reports[name];
-		if (!remoteReport) entries.push({
+	return buildDiffResult(detectRecordDiff(local.reports, remote.reports, {
+		onAdded: (name, localReport) => ({
 			type: "added",
 			reportName: name,
 			details: `chartType: ${localReport.chartType}`
-		});
-		else {
+		}),
+		onModified: (name, localReport, remoteReport) => {
 			const diffs = compareReports(localReport, remoteReport);
-			if (diffs.length > 0) entries.push({
+			if (diffs.length > 0) return {
 				type: "modified",
 				reportName: name,
 				details: diffs.join(", ")
-			});
-		}
-	}
-	for (const [name, remoteReport] of Object.entries(remote.reports)) if (!local.reports[name]) entries.push({
-		type: "deleted",
-		reportName: name,
-		details: `chartType: ${remoteReport.chartType}`
-	});
-	return buildDiffResult(entries);
+			};
+		},
+		onDeleted: (name, remoteReport) => ({
+			type: "deleted",
+			reportName: name,
+			details: `chartType: ${remoteReport.chartType}`
+		})
+	}));
 } };
 
 //#endregion
@@ -10245,6 +10225,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",
@@ -10266,86 +10251,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 } : {},
@@ -10527,11 +10496,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);
@@ -10593,39 +10565,43 @@ var settings_default = define({
 
 //#endregion
 //#region src/core/domain/view/services/configParser.ts
+function parseDeviceType(name, raw) {
+	if (raw === void 0 || raw === null) return void 0;
+	const deviceStr = String(raw);
+	if (!isDeviceType(deviceStr)) throw new BusinessRuleError(ViewErrorCode.VwInvalidDeviceType, `View "${name}" has invalid device type: ${deviceStr}. Must be DESKTOP or ANY`);
+	return deviceStr;
+}
 function parseViewConfig(name, raw) {
 	if (!isRecord(raw)) throw new BusinessRuleError(ViewErrorCode.VwInvalidConfigStructure, `View "${name}" must be an object`);
-	const obj = raw;
-	if (typeof obj.type !== "string" || !VALID_VIEW_TYPES.has(obj.type)) throw new BusinessRuleError(ViewErrorCode.VwInvalidViewType, `View "${name}" has invalid type: ${String(obj.type)}. Must be LIST, CALENDAR, or CUSTOM`);
+	if (typeof raw.type !== "string" || !isViewType(raw.type)) throw new BusinessRuleError(ViewErrorCode.VwInvalidViewType, `View "${name}" has invalid type: ${String(raw.type)}. Must be LIST, CALENDAR, or CUSTOM`);
+	if (raw.index !== void 0 && (typeof raw.index !== "number" || !Number.isInteger(raw.index) || raw.index < 0)) throw new BusinessRuleError(ViewErrorCode.VwInvalidIndex, `View "${name}" has invalid index: ${String(raw.index)}. Must be a non-negative integer`);
+	if (raw.fields !== void 0 && !Array.isArray(raw.fields)) throw new BusinessRuleError(ViewErrorCode.VwInvalidConfigStructure, `View "${name}" has invalid fields: must be an array`);
+	if (raw.pager !== void 0 && typeof raw.pager !== "boolean") throw new BusinessRuleError(ViewErrorCode.VwInvalidConfigStructure, `View "${name}" has invalid pager: must be a boolean`);
+	const device = parseDeviceType(name, raw.device);
 	return {
-		type: obj.type,
-		index: typeof obj.index === "number" ? obj.index : 0,
+		type: raw.type,
+		index: typeof raw.index === "number" ? raw.index : 0,
 		name,
-		...obj.builtinType !== void 0 && { builtinType: String(obj.builtinType) },
-		...Array.isArray(obj.fields) && { fields: obj.fields.map(String) },
-		...obj.date !== void 0 && { date: String(obj.date) },
-		...obj.title !== void 0 && { title: String(obj.title) },
-		...obj.html !== void 0 && { html: String(obj.html) },
-		...obj.pager !== void 0 && { pager: Boolean(obj.pager) },
-		...obj.device !== void 0 && { device: (() => {
-			const deviceStr = String(obj.device);
-			if (!VALID_DEVICE_TYPES.has(deviceStr)) throw new BusinessRuleError(ViewErrorCode.VwInvalidDeviceType, `View "${name}" has invalid device type: ${deviceStr}. Must be DESKTOP or ANY`);
-			return deviceStr;
-		})() },
-		...obj.filterCond !== void 0 && { filterCond: String(obj.filterCond) },
-		...obj.sort !== void 0 && { sort: String(obj.sort) }
+		...raw.builtinType !== void 0 && { builtinType: String(raw.builtinType) },
+		...Array.isArray(raw.fields) && { fields: raw.fields.map((f, i) => {
+			if (typeof f !== "string") throw new BusinessRuleError(ViewErrorCode.VwInvalidConfigStructure, `View "${name}" has non-string field at index ${i}: ${String(f)}`);
+			return f;
+		}) },
+		...raw.date !== void 0 && { date: String(raw.date) },
+		...raw.title !== void 0 && { title: String(raw.title) },
+		...raw.html !== void 0 && { html: String(raw.html) },
+		...raw.pager !== void 0 && { pager: raw.pager },
+		...device !== void 0 && { device },
+		...raw.filterCond !== void 0 && { filterCond: String(raw.filterCond) },
+		...raw.sort !== void 0 && { sort: String(raw.sort) }
 	};
 }
 const ViewConfigParser = { parse: (rawText) => {
-	if (rawText.trim().length === 0) throw new BusinessRuleError(ViewErrorCode.VwEmptyConfigText, "View config text is empty");
-	let parsed;
-	try {
-		parsed = parse(rawText);
-	} catch (error) {
-		throw new BusinessRuleError(ViewErrorCode.VwInvalidConfigYaml, `Failed to parse YAML: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	if (!isRecord(parsed)) throw new BusinessRuleError(ViewErrorCode.VwInvalidConfigStructure, "Config must be a YAML object");
-	const obj = parsed;
+	const obj = parseYamlConfig(rawText, {
+		emptyConfigText: ViewErrorCode.VwEmptyConfigText,
+		invalidConfigYaml: ViewErrorCode.VwInvalidConfigYaml,
+		invalidConfigStructure: ViewErrorCode.VwInvalidConfigStructure
+	}, "View");
 	if (!isRecord(obj.views)) throw new BusinessRuleError(ViewErrorCode.VwInvalidConfigStructure, "Config must have a \"views\" object");
 	const viewsObj = obj.views;
 	const views = {};
@@ -10777,7 +10753,6 @@ var capture_default = define({
 //#region src/core/domain/view/services/diffDetector.ts
 function describeChanges(local, remote) {
 	const changes = [];
-	if (local.name !== remote.name) changes.push(`name: "${remote.name}" -> "${local.name}"`);
 	if (local.type !== remote.type) changes.push(`type: ${remote.type} -> ${local.type}`);
 	if ((local.builtinType ?? "") !== (remote.builtinType ?? "")) changes.push("builtinType changed");
 	if (local.index !== remote.index) changes.push(`index: ${remote.index} -> ${local.index}`);
@@ -10792,29 +10767,26 @@ function describeChanges(local, remote) {
 	return changes;
 }
 const ViewDiffDetector = { detect: (localViews, remoteViews) => {
-	const entries = [];
-	for (const [name, localView] of Object.entries(localViews)) {
-		const remoteView = remoteViews[name];
-		if (remoteView === void 0) entries.push({
+	return buildDiffResult(detectRecordDiff(localViews, remoteViews, {
+		onAdded: (name) => ({
 			type: "added",
 			viewName: name,
 			details: "new view"
-		});
-		else {
+		}),
+		onModified: (name, localView, remoteView) => {
 			const changes = describeChanges(localView, remoteView);
-			if (changes.length > 0) entries.push({
+			if (changes.length > 0) return {
 				type: "modified",
 				viewName: name,
 				details: changes.join(", ")
-			});
-		}
-	}
-	for (const name of Object.keys(remoteViews)) if (localViews[name] === void 0) entries.push({
-		type: "deleted",
-		viewName: name,
-		details: "removed"
-	});
-	return buildDiffResult(entries);
+			};
+		},
+		onDeleted: (name) => ({
+			type: "deleted",
+			viewName: name,
+			details: "removed"
+		})
+	}));
 } };
 
 //#endregion