kintone-migrator 0.1.0

package/dist/index.js

@@ -0,0 +1,1656 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { cli, define } from "gunshi";
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { KintoneRestAPIClient, KintoneRestAPIError } from "@kintone/rest-api-client";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { parse, stringify } from "yaml";
+import * as v from "valibot";
+
+//#region src/lib/error.ts
+var AnyError = class extends Error {
+	constructor(message, cause) {
+		super(message, { cause });
+	}
+};
+
+//#endregion
+//#region src/core/application/error.ts
+var ApplicationError = class extends AnyError {
+	name = "ApplicationError";
+	constructor(code, message, cause) {
+		super(message, cause);
+		this.code = code;
+	}
+};
+const ConflictErrorCode = { Conflict: "CONFLICT" };
+var ConflictError = class extends ApplicationError {
+	name = "ConflictError";
+	constructor(code, message, cause) {
+		super(code, message, cause);
+		this.code = code;
+	}
+};
+const ValidationErrorCode = { InvalidInput: "INVALID_INPUT" };
+var ValidationError = class extends ApplicationError {
+	name = "ValidationError";
+	constructor(code, message, cause) {
+		super(code, message, cause);
+		this.code = code;
+	}
+};
+function isValidationError(error) {
+	return error instanceof ValidationError;
+}
+const SystemErrorCode = {
+	InternalServerError: "INTERNAL_SERVER_ERROR",
+	DatabaseError: "DATABASE_ERROR",
+	NetworkError: "NETWORK_ERROR",
+	StorageError: "STORAGE_ERROR",
+	DocumentGenerationError: "DOCUMENT_GENERATION_ERROR",
+	ExternalApiError: "EXTERNAL_API_ERROR"
+};
+var SystemError = class extends ApplicationError {
+	name = "SystemError";
+	constructor(code, message, cause) {
+		super(code, message, cause);
+		this.code = code;
+	}
+};
+function isSystemError(error) {
+	return error instanceof SystemError;
+}
+
+//#endregion
+//#region src/core/domain/formSchema/errorCode.ts
+const FormSchemaErrorCode = {
+	EmptyFieldCode: "EMPTY_FIELD_CODE",
+	EmptySchemaText: "EMPTY_SCHEMA_TEXT",
+	InvalidSchemaJson: "INVALID_SCHEMA_JSON",
+	InvalidSchemaStructure: "INVALID_SCHEMA_STRUCTURE",
+	DuplicateFieldCode: "DUPLICATE_FIELD_CODE",
+	InvalidFieldType: "INVALID_FIELD_TYPE",
+	InvalidLayoutStructure: "INVALID_LAYOUT_STRUCTURE",
+	InvalidDecorationElement: "INVALID_DECORATION_ELEMENT"
+};
+
+//#endregion
+//#region src/core/domain/error.ts
+const BusinessRuleErrorCode = { ...FormSchemaErrorCode };
+/**
+* Domain Layer - Business Rule Error
+*
+* Represents a violation of business rules in the domain layer.
+* This error is thrown when domain logic determines that an operation cannot proceed.
+*/
+var BusinessRuleError = class extends AnyError {
+	name = "BusinessRuleError";
+	constructor(code, message, cause) {
+		super(message, cause);
+		this.code = code;
+	}
+};
+function isBusinessRuleError(error) {
+	return error instanceof BusinessRuleError;
+}
+
+//#endregion
+//#region src/core/adapters/kintone/appDeployer.ts
+const DEFAULT_POLL_INTERVAL_MS = 1e3;
+const DEFAULT_MAX_RETRIES = 180;
+var KintoneAppDeployer = class {
+	pollIntervalMs;
+	maxRetries;
+	constructor(client, appId, config) {
+		this.client = client;
+		this.appId = appId;
+		this.pollIntervalMs = config?.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+		this.maxRetries = config?.maxRetries ?? DEFAULT_MAX_RETRIES;
+	}
+	async deploy() {
+		try {
+			await this.client.app.deployApp({ apps: [{ app: this.appId }] });
+			await this.waitForDeployment();
+		} catch (error) {
+			if (isBusinessRuleError(error)) throw error;
+			if (error instanceof SystemError) throw error;
+			throw new SystemError(SystemErrorCode.ExternalApiError, "Failed to deploy app", error);
+		}
+	}
+	async waitForDeployment() {
+		for (let i = 0; i < this.maxRetries; i++) {
+			await this.sleep(this.pollIntervalMs);
+			const { apps } = await this.client.app.getDeployStatus({ apps: [this.appId] });
+			const status = apps[0]?.status;
+			switch (status) {
+				case "SUCCESS": return;
+				case "FAIL": throw new SystemError(SystemErrorCode.ExternalApiError, "App deployment failed");
+				case "CANCEL": throw new SystemError(SystemErrorCode.ExternalApiError, "App deployment was cancelled");
+				case "PROCESSING": continue;
+				case void 0: throw new SystemError(SystemErrorCode.ExternalApiError, "Deploy status unavailable");
+				default: throw new SystemError(SystemErrorCode.ExternalApiError, `Unexpected deploy status: ${status}`);
+			}
+		}
+		throw new SystemError(SystemErrorCode.ExternalApiError, "App deployment timed out");
+	}
+	sleep(ms) {
+		return new Promise((resolve) => setTimeout(resolve, ms));
+	}
+};
+
+//#endregion
+//#region src/core/domain/formSchema/valueObject.ts
+const FieldCode = { create: (code) => {
+	if (code.length === 0) throw new BusinessRuleError(FormSchemaErrorCode.EmptyFieldCode, "Field code cannot be empty");
+	return code;
+} };
+
+//#endregion
+//#region src/core/adapters/kintone/formConfigurator.ts
+const KNOWN_FIELD_TYPES = new Set([
+	"SINGLE_LINE_TEXT",
+	"MULTI_LINE_TEXT",
+	"RICH_TEXT",
+	"NUMBER",
+	"CALC",
+	"CHECK_BOX",
+	"RADIO_BUTTON",
+	"MULTI_SELECT",
+	"DROP_DOWN",
+	"DATE",
+	"TIME",
+	"DATETIME",
+	"LINK",
+	"USER_SELECT",
+	"ORGANIZATION_SELECT",
+	"GROUP_SELECT",
+	"FILE",
+	"GROUP",
+	"SUBTABLE",
+	"REFERENCE_TABLE"
+]);
+const SYSTEM_FIELD_TYPES$1 = new Set([
+	"RECORD_NUMBER",
+	"CREATOR",
+	"CREATED_TIME",
+	"MODIFIER",
+	"UPDATED_TIME",
+	"CATEGORY",
+	"STATUS",
+	"STATUS_ASSIGNEE"
+]);
+const DECORATION_TYPES$1 = new Set([
+	"LABEL",
+	"SPACER",
+	"HR"
+]);
+const KINTONE_REVISION_CONFLICT_CODE = "GAIA_CO02";
+function isRevisionConflict(error) {
+	return error instanceof KintoneRestAPIError && error.code === KINTONE_REVISION_CONFLICT_CODE;
+}
+function fromKintoneProperty(prop) {
+	const { type, code, label, noLabel, ...rest } = prop;
+	const base = {
+		code: FieldCode.create(code),
+		label,
+		...noLabel !== void 0 ? { noLabel } : {}
+	};
+	if (type === "SUBTABLE" && "fields" in rest) {
+		const kintoneSubFields = rest.fields;
+		const subFields = /* @__PURE__ */ new Map();
+		for (const [subCode, subProp] of Object.entries(kintoneSubFields)) subFields.set(FieldCode.create(subCode), fromKintoneProperty(subProp));
+		return {
+			...base,
+			type: "SUBTABLE",
+			properties: { fields: subFields }
+		};
+	}
+	if (type === "REFERENCE_TABLE" && "referenceTable" in rest) {
+		const rt = rest.referenceTable;
+		const condition = rt.condition;
+		const displayFields = rt.displayFields.map((f) => FieldCode.create(f));
+		return {
+			...base,
+			type: "REFERENCE_TABLE",
+			properties: { referenceTable: {
+				relatedApp: rt.relatedApp,
+				condition: {
+					field: FieldCode.create(condition.field),
+					relatedField: FieldCode.create(condition.relatedField)
+				},
+				...rt.filterCond !== void 0 ? { filterCond: rt.filterCond } : {},
+				displayFields,
+				...rt.sort !== void 0 ? { sort: rt.sort } : {},
+				...rt.size !== void 0 ? { size: rt.size } : {}
+			} }
+		};
+	}
+	if (!KNOWN_FIELD_TYPES.has(type)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unknown field type: ${type}`);
+	return {
+		...base,
+		type,
+		properties: rest
+	};
+}
+function toKintoneProperty(field) {
+	const base = {
+		type: field.type,
+		code: field.code,
+		label: field.label,
+		...field.noLabel !== void 0 ? { noLabel: field.noLabel } : {}
+	};
+	if (field.type === "SUBTABLE") {
+		const subFields = {};
+		for (const [code, subField] of field.properties.fields) subFields[code] = toKintoneProperty(subField);
+		return {
+			...base,
+			fields: subFields
+		};
+	}
+	if (field.type === "REFERENCE_TABLE") {
+		const ref = field.properties.referenceTable;
+		return {
+			...base,
+			referenceTable: {
+				relatedApp: ref.relatedApp,
+				condition: {
+					field: ref.condition.field,
+					relatedField: ref.condition.relatedField
+				},
+				...ref.filterCond !== void 0 ? { filterCond: ref.filterCond } : {},
+				displayFields: ref.displayFields.map((f) => f),
+				...ref.sort !== void 0 ? { sort: ref.sort } : {},
+				...ref.size !== void 0 ? { size: ref.size } : {}
+			}
+		};
+	}
+	return {
+		...base,
+		...field.properties
+	};
+}
+function parseElementSize(raw) {
+	if (!raw) return void 0;
+	return {
+		...raw.width !== void 0 ? { width: raw.width } : {},
+		...raw.height !== void 0 ? { height: raw.height } : {},
+		...raw.innerHeight !== void 0 ? { innerHeight: raw.innerHeight } : {}
+	};
+}
+function fromKintoneLayoutElement(raw) {
+	const type = raw.type;
+	if (DECORATION_TYPES$1.has(type)) {
+		const size$1 = parseElementSize(raw.size) ?? {};
+		const elementId = String(raw.elementId ?? "");
+		switch (type) {
+			case "LABEL": return {
+				type: "LABEL",
+				label: String(raw.label ?? ""),
+				elementId,
+				size: size$1
+			};
+			case "SPACER": return {
+				type: "SPACER",
+				elementId,
+				size: size$1
+			};
+			case "HR": return {
+				type: "HR",
+				elementId,
+				size: size$1
+			};
+			default: throw new SystemError(SystemErrorCode.ExternalApiError, `Unknown decoration type: ${type}`);
+		}
+	}
+	if (SYSTEM_FIELD_TYPES$1.has(type)) return {
+		code: String(raw.code ?? ""),
+		type,
+		...raw.size !== void 0 ? { size: parseElementSize(raw.size) } : {}
+	};
+	if (!KNOWN_FIELD_TYPES.has(type)) throw new SystemError(SystemErrorCode.ExternalApiError, `Unknown field type: ${type}`);
+	const fieldType = type;
+	const code = FieldCode.create(String(raw.code ?? ""));
+	const size = parseElementSize(raw.size);
+	return {
+		field: {
+			type: fieldType,
+			code,
+			label: "",
+			properties: {}
+		},
+		...size !== void 0 ? { size } : {}
+	};
+}
+function fromKintoneLayoutRow(raw) {
+	return {
+		type: "ROW",
+		fields: (raw.fields ?? []).map(fromKintoneLayoutElement)
+	};
+}
+function fromKintoneLayoutItem(raw) {
+	switch (raw.type) {
+		case "ROW": return fromKintoneLayoutRow(raw);
+		case "GROUP": return {
+			type: "GROUP",
+			code: FieldCode.create(String(raw.code ?? "")),
+			label: String(raw.label ?? ""),
+			...raw.openGroup !== void 0 ? { openGroup: raw.openGroup } : {},
+			layout: (raw.layout ?? []).map(fromKintoneLayoutRow)
+		};
+		case "SUBTABLE": return {
+			type: "SUBTABLE",
+			code: FieldCode.create(String(raw.code ?? "")),
+			label: String(raw.label ?? ""),
+			fields: (raw.fields ?? []).map(fromKintoneLayoutElement)
+		};
+		default: throw new SystemError(SystemErrorCode.ExternalApiError, `Unknown layout item type: ${raw.type}`);
+	}
+}
+function toKintoneLayoutElement(element) {
+	if ("field" in element) {
+		const lf = element;
+		const result = {
+			type: lf.field.type,
+			code: lf.field.code
+		};
+		if (lf.size !== void 0) result.size = lf.size;
+		return result;
+	}
+	if ("elementId" in element && !("code" in element)) {
+		const dec = element;
+		const result = {
+			type: dec.type,
+			elementId: dec.elementId,
+			size: dec.size
+		};
+		if (dec.type === "LABEL") result.label = dec.label;
+		return result;
+	}
+	const sys = element;
+	return {
+		type: sys.type,
+		code: sys.code,
+		...sys.size !== void 0 ? { size: sys.size } : {}
+	};
+}
+function toKintoneLayoutRow(row) {
+	return {
+		type: "ROW",
+		fields: row.fields.map(toKintoneLayoutElement)
+	};
+}
+function toKintoneLayoutItem(item) {
+	switch (item.type) {
+		case "ROW": return toKintoneLayoutRow(item);
+		case "GROUP": {
+			const group = item;
+			return {
+				type: "GROUP",
+				code: group.code,
+				...group.openGroup !== void 0 ? { openGroup: group.openGroup } : {},
+				layout: group.layout.map(toKintoneLayoutRow)
+			};
+		}
+		case "SUBTABLE": {
+			const subtable = item;
+			return {
+				type: "SUBTABLE",
+				code: subtable.code,
+				fields: subtable.fields.map(toKintoneLayoutElement)
+			};
+		}
+		default: throw new SystemError(SystemErrorCode.ExternalApiError, `Unknown layout item type: ${item.type}`);
+	}
+}
+var KintoneFormConfigurator = class {
+	latestRevision = void 0;
+	constructor(client, appId) {
+		this.client = client;
+		this.appId = appId;
+	}
+	trackRevision(revision) {
+		if (this.latestRevision === void 0 || Number(revision) > Number(this.latestRevision)) this.latestRevision = revision;
+	}
+	async getFields() {
+		try {
+			const { properties, revision } = await this.client.app.getFormFields({
+				app: this.appId,
+				preview: true
+			});
+			this.trackRevision(revision);
+			const fields = /* @__PURE__ */ new Map();
+			for (const [code, prop] of Object.entries(properties)) {
+				const kintoneProp = prop;
+				if (SYSTEM_FIELD_TYPES$1.has(kintoneProp.type)) continue;
+				const fieldDef = fromKintoneProperty(kintoneProp);
+				fields.set(FieldCode.create(code), fieldDef);
+				if (fieldDef.type === "SUBTABLE") for (const [subCode, subDef] of fieldDef.properties.fields) fields.set(subCode, subDef);
+			}
+			return fields;
+		} catch (error) {
+			if (isBusinessRuleError(error)) throw error;
+			if (error instanceof SystemError) throw error;
+			throw new SystemError(SystemErrorCode.ExternalApiError, "Failed to get form fields", error);
+		}
+	}
+	async addFields(fields) {
+		try {
+			const properties = {};
+			for (const field of fields) properties[field.code] = toKintoneProperty(field);
+			const response = await this.client.app.addFormFields({
+				app: this.appId,
+				properties,
+				...this.latestRevision !== void 0 ? { revision: this.latestRevision } : {}
+			});
+			if (response.revision) this.trackRevision(response.revision);
+		} catch (error) {
+			if (isBusinessRuleError(error)) throw error;
+			if (error instanceof SystemError) throw error;
+			if (isRevisionConflict(error)) throw new ConflictError(ConflictErrorCode.Conflict, "Form configuration was modified by another process. Please retry the operation.", error);
+			throw new SystemError(SystemErrorCode.ExternalApiError, "Failed to add form fields", error);
+		}
+	}
+	async updateFields(fields) {
+		try {
+			const properties = {};
+			for (const field of fields) properties[field.code] = toKintoneProperty(field);
+			const response = await this.client.app.updateFormFields({
+				app: this.appId,
+				properties,
+				...this.latestRevision !== void 0 ? { revision: this.latestRevision } : {}
+			});
+			if (response.revision) this.trackRevision(response.revision);
+		} catch (error) {
+			if (isBusinessRuleError(error)) throw error;
+			if (error instanceof SystemError) throw error;
+			if (isRevisionConflict(error)) throw new ConflictError(ConflictErrorCode.Conflict, "Form configuration was modified by another process. Please retry the operation.", error);
+			throw new SystemError(SystemErrorCode.ExternalApiError, "Failed to update form fields", error);
+		}
+	}
+	async deleteFields(fieldCodes) {
+		try {
+			const response = await this.client.app.deleteFormFields({
+				app: this.appId,
+				fields: fieldCodes.map((code) => code),
+				...this.latestRevision !== void 0 ? { revision: this.latestRevision } : {}
+			});
+			if (response.revision) this.trackRevision(response.revision);
+		} catch (error) {
+			if (isBusinessRuleError(error)) throw error;
+			if (error instanceof SystemError) throw error;
+			if (isRevisionConflict(error)) throw new ConflictError(ConflictErrorCode.Conflict, "Form configuration was modified by another process. Please retry the operation.", error);
+			throw new SystemError(SystemErrorCode.ExternalApiError, "Failed to delete form fields", error);
+		}
+	}
+	async getLayout() {
+		try {
+			const response = await this.client.app.getFormLayout({
+				app: this.appId,
+				preview: true
+			});
+			this.trackRevision(response.revision);
+			return response.layout.map(fromKintoneLayoutItem);
+		} catch (error) {
+			if (isBusinessRuleError(error)) throw error;
+			if (error instanceof SystemError) throw error;
+			throw new SystemError(SystemErrorCode.ExternalApiError, "Failed to get form layout", error);
+		}
+	}
+	async updateLayout(layout) {
+		try {
+			const kintoneLayout = layout.map(toKintoneLayoutItem);
+			const response = await this.client.app.updateFormLayout({
+				app: this.appId,
+				layout: kintoneLayout,
+				revision: this.latestRevision !== void 0 ? Number(this.latestRevision) : -1
+			});
+			if (response.revision) this.trackRevision(response.revision);
+		} catch (error) {
+			if (isBusinessRuleError(error)) throw error;
+			if (error instanceof SystemError) throw error;
+			if (isRevisionConflict(error)) throw new ConflictError(ConflictErrorCode.Conflict, "Form configuration was modified by another process. Please retry the operation.", error);
+			throw new SystemError(SystemErrorCode.ExternalApiError, "Failed to update form layout", error);
+		}
+	}
+};
+
+//#endregion
+//#region src/core/adapters/local/schemaStorage.ts
+var LocalFileSchemaStorage = class {
+	constructor(filePath) {
+		this.filePath = filePath;
+	}
+	async get() {
+		try {
+			return await readFile(this.filePath, "utf-8");
+		} catch (error) {
+			if (isNodeError(error) && error.code === "ENOENT") return "";
+			throw new SystemError(SystemErrorCode.StorageError, `Failed to read schema file: ${this.filePath}`, error);
+		}
+	}
+	async update(content) {
+		try {
+			await mkdir(dirname(this.filePath), { recursive: true });
+			await writeFile(this.filePath, content, "utf-8");
+		} catch (error) {
+			throw new SystemError(SystemErrorCode.StorageError, `Failed to write schema file: ${this.filePath}`, error);
+		}
+	}
+};
+function isNodeError(error) {
+	return error instanceof Error && "code" in error;
+}
+
+//#endregion
+//#region src/core/application/container/cli.ts
+function createCliContainer(config) {
+	const client = new KintoneRestAPIClient({
+		baseUrl: config.baseUrl,
+		auth: {
+			username: config.username,
+			password: config.password
+		}
+	});
+	return {
+		formConfigurator: new KintoneFormConfigurator(client, config.appId),
+		schemaStorage: new LocalFileSchemaStorage(config.schemaFilePath),
+		appDeployer: new KintoneAppDeployer(client, config.appId)
+	};
+}
+
+//#endregion
+//#region src/core/domain/formSchema/entity.ts
+function enrichLayoutElement(element, fields) {
+	if (!("field" in element)) return element;
+	const lf = element;
+	const fullField = fields.get(lf.field.code);
+	if (fullField === void 0) return element;
+	return {
+		field: fullField,
+		...lf.size !== void 0 ? { size: lf.size } : {}
+	};
+}
+function enrichLayoutRow(row, fields) {
+	return {
+		type: "ROW",
+		fields: row.fields.map((e) => enrichLayoutElement(e, fields))
+	};
+}
+function enrichLayoutItem(item, fields) {
+	switch (item.type) {
+		case "ROW": return enrichLayoutRow(item, fields);
+		case "GROUP": {
+			const groupDef = fields.get(item.code);
+			return {
+				...item,
+				...groupDef !== void 0 ? { label: groupDef.label } : {},
+				...groupDef !== void 0 && groupDef.noLabel !== void 0 ? { noLabel: groupDef.noLabel } : {},
+				...groupDef !== void 0 && groupDef.type === "GROUP" && groupDef.properties.openGroup !== void 0 ? { openGroup: groupDef.properties.openGroup } : {},
+				layout: item.layout.map((r) => enrichLayoutRow(r, fields))
+			};
+		}
+		case "SUBTABLE": {
+			const subtableDef = fields.get(item.code);
+			const subFieldsMap = subtableDef !== void 0 && subtableDef.type === "SUBTABLE" ? subtableDef.properties.fields : /* @__PURE__ */ new Map();
+			return {
+				...item,
+				...subtableDef !== void 0 ? { label: subtableDef.label } : {},
+				...subtableDef !== void 0 && subtableDef.noLabel !== void 0 ? { noLabel: subtableDef.noLabel } : {},
+				fields: item.fields.map((e) => enrichLayoutElement(e, subFieldsMap))
+			};
+		}
+	}
+}
+function enrichLayoutWithFields(layout, fields) {
+	return layout.map((item) => enrichLayoutItem(item, fields));
+}
+function collectSubtableInnerFieldCodes(fields) {
+	const innerCodes = /* @__PURE__ */ new Set();
+	for (const def of fields.values()) if (def.type === "SUBTABLE") for (const subCode of def.properties.fields.keys()) innerCodes.add(subCode);
+	return innerCodes;
+}
+const FormDiff = { create: (entries) => {
+	const summary = {
+		added: entries.filter((e) => e.type === "added").length,
+		modified: entries.filter((e) => e.type === "modified").length,
+		deleted: entries.filter((e) => e.type === "deleted").length,
+		total: entries.length
+	};
+	const sortOrder = {
+		added: 0,
+		modified: 1,
+		deleted: 2
+	};
+	return {
+		entries: [...entries].sort((a, b) => sortOrder[a.type] - sortOrder[b.type]),
+		summary,
+		isEmpty: entries.length === 0
+	};
+} };
+
+//#endregion
+//#region src/core/domain/formSchema/services/schemaSerializer.ts
+function isLayoutField(element) {
+	return "field" in element;
+}
+function isDecorationElement(element) {
+	return "elementId" in element;
+}
+function isSystemFieldLayout(element) {
+	return !("field" in element) && !("elementId" in element);
+}
+function serializeSize(size) {
+	const result = {};
+	if (size.width !== void 0) result.width = size.width;
+	if (size.height !== void 0) result.height = size.height;
+	if (size.innerHeight !== void 0) result.innerHeight = size.innerHeight;
+	return result;
+}
+function serializeFlatField(field, size) {
+	const result = {
+		code: field.code,
+		type: field.type,
+		label: field.label
+	};
+	if (field.noLabel !== void 0) result.noLabel = field.noLabel;
+	if (size !== void 0) result.size = serializeSize(size);
+	if (field.type === "REFERENCE_TABLE") {
+		const ref = field.properties.referenceTable;
+		result.referenceTable = {
+			relatedApp: ref.relatedApp,
+			condition: {
+				field: ref.condition.field,
+				relatedField: ref.condition.relatedField
+			},
+			...ref.filterCond !== void 0 ? { filterCond: ref.filterCond } : {},
+			displayFields: ref.displayFields.map((f) => f),
+			...ref.sort !== void 0 ? { sort: ref.sort } : {},
+			...ref.size !== void 0 ? { size: ref.size } : {}
+		};
+		return result;
+	}
+	if (field.type !== "SUBTABLE" && field.type !== "GROUP") {
+		const properties = field.properties;
+		for (const [key, value] of Object.entries(properties)) result[key] = value;
+	}
+	return result;
+}
+function serializeLayoutElement(element) {
+	if (isLayoutField(element)) return serializeFlatField(element.field, element.size);
+	if (isDecorationElement(element)) {
+		const dec = element;
+		const result = { type: dec.type };
+		if (dec.type === "LABEL") result.label = dec.label;
+		result.elementId = dec.elementId;
+		if (dec.size !== void 0) result.size = serializeSize(dec.size);
+		return result;
+	}
+	if (isSystemFieldLayout(element)) {
+		const sys = element;
+		const result = {
+			code: sys.code,
+			type: sys.type
+		};
+		if (sys.size !== void 0) result.size = serializeSize(sys.size);
+		return result;
+	}
+	return element;
+}
+function serializeLayoutRow(row) {
+	return {
+		type: "ROW",
+		fields: row.fields.map(serializeLayoutElement)
+	};
+}
+function serializeLayoutItem(item) {
+	switch (item.type) {
+		case "ROW": return serializeLayoutRow(item);
+		case "GROUP": return {
+			type: "GROUP",
+			code: item.code,
+			label: item.label,
+			...item.noLabel !== void 0 ? { noLabel: item.noLabel } : {},
+			...item.openGroup !== void 0 ? { openGroup: item.openGroup } : {},
+			layout: item.layout.map(serializeLayoutRow)
+		};
+		case "SUBTABLE": return {
+			type: "SUBTABLE",
+			code: item.code,
+			label: item.label,
+			...item.noLabel !== void 0 ? { noLabel: item.noLabel } : {},
+			fields: item.fields.map(serializeLayoutElement)
+		};
+	}
+}
+const SchemaSerializer = { serialize: (layout) => {
+	return stringify({ layout: layout.map(serializeLayoutItem) }, {
+		lineWidth: 0,
+		defaultKeyType: "PLAIN",
+		defaultStringType: "PLAIN"
+	});
+} };
+
+//#endregion
+//#region src/core/application/formSchema/captureSchema.ts
+async function captureSchema({ container }) {
+	const [currentFields, currentLayout] = await Promise.all([container.formConfigurator.getFields(), container.formConfigurator.getLayout()]);
+	const enrichedLayout = enrichLayoutWithFields(currentLayout, currentFields);
+	return {
+		schemaText: SchemaSerializer.serialize(enrichedLayout),
+		hasExistingSchema: (await container.schemaStorage.get()).length > 0
+	};
+}
+
+//#endregion
+//#region src/core/application/formSchema/saveSchema.ts
+async function saveSchema({ container, input }) {
+	await container.schemaStorage.update(input.schemaText);
+}
+
+//#endregion
+//#region src/cli/config.ts
+const CliConfigSchema = v.object({
+	KINTONE_DOMAIN: v.pipe(v.string(), v.nonEmpty("KINTONE_DOMAIN is required")),
+	KINTONE_USERNAME: v.pipe(v.string(), v.nonEmpty("KINTONE_USERNAME is required")),
+	KINTONE_PASSWORD: v.pipe(v.string(), v.nonEmpty("KINTONE_PASSWORD is required")),
+	KINTONE_APP_ID: v.pipe(v.string(), v.nonEmpty("KINTONE_APP_ID is required")),
+	SCHEMA_FILE_PATH: v.optional(v.string(), "schema.yaml")
+});
+const kintoneArgs = {
+	domain: {
+		type: "string",
+		short: "d",
+		description: "kintone domain (overrides KINTONE_DOMAIN env var)"
+	},
+	username: {
+		type: "string",
+		short: "u",
+		description: "kintone username (overrides KINTONE_USERNAME env var)"
+	},
+	password: {
+		type: "string",
+		short: "p",
+		description: "kintone password (overrides KINTONE_PASSWORD env var)"
+	},
+	"app-id": {
+		type: "string",
+		short: "a",
+		description: "kintone app ID (overrides KINTONE_APP_ID env var)"
+	},
+	"schema-file": {
+		type: "string",
+		short: "f",
+		description: "Schema file path (default: schema.yaml)"
+	}
+};
+function resolveConfig(cliValues) {
+	const result = v.safeParse(CliConfigSchema, {
+		KINTONE_DOMAIN: cliValues.domain ?? process.env.KINTONE_DOMAIN ?? "",
+		KINTONE_USERNAME: cliValues.username ?? process.env.KINTONE_USERNAME ?? "",
+		KINTONE_PASSWORD: cliValues.password ?? process.env.KINTONE_PASSWORD ?? "",
+		KINTONE_APP_ID: cliValues["app-id"] ?? process.env.KINTONE_APP_ID ?? "",
+		SCHEMA_FILE_PATH: cliValues["schema-file"] ?? process.env.SCHEMA_FILE_PATH
+	});
+	if (!result.success) {
+		const missing = result.issues.map((issue) => issue.message).join("\n  ");
+		throw new Error(`Missing required configuration:\n  ${missing}`);
+	}
+	return {
+		baseUrl: `https://${result.output.KINTONE_DOMAIN}`,
+		username: result.output.KINTONE_USERNAME,
+		password: result.output.KINTONE_PASSWORD,
+		appId: result.output.KINTONE_APP_ID,
+		schemaFilePath: result.output.SCHEMA_FILE_PATH
+	};
+}
+
+//#endregion
+//#region src/cli/handleError.ts
+function handleCliError(error) {
+	if (isBusinessRuleError(error)) {
+		p.log.error(`[BusinessRuleError] ${error.code}: ${error.message}`);
+		logErrorDetails(error);
+		p.outro("Failed.");
+		process.exit(1);
+	}
+	if (isValidationError(error)) {
+		p.log.error(`[ValidationError] ${error.message}`);
+		logErrorDetails(error);
+		p.outro("Failed.");
+		process.exit(1);
+	}
+	if (isSystemError(error)) {
+		p.log.error(`[SystemError] ${error.code}: ${error.message}`);
+		logErrorDetails(error);
+		p.outro("Failed.");
+		process.exit(1);
+	}
+	if (isApplicationError(error)) {
+		p.log.error(`[${error.name}] ${error.code}: ${error.message}`);
+		logErrorDetails(error);
+		p.outro("Failed.");
+		process.exit(1);
+	}
+	if (error instanceof Error) {
+		p.log.error(`[Error] ${error.message}`);
+		logErrorDetails(error);
+		p.outro("Failed.");
+		process.exit(1);
+	}
+	p.log.error(`[Error] 予期しないエラーが発生しました: ${String(error)}`);
+	p.outro("Failed.");
+	process.exit(1);
+}
+function logErrorDetails(error) {
+	if (error.cause) {
+		p.log.warn(`Cause: ${String(error.cause)}`);
+		const cause = error.cause;
+		if (cause.errors) p.log.warn(`Details: ${JSON.stringify(cause.errors, null, 2)}`);
+	}
+	if (error.stack) p.log.warn(`Stack: ${error.stack}`);
+}
+function isApplicationError(error) {
+	return error instanceof Error && "code" in error && error.name !== "BusinessRuleError";
+}
+
+//#endregion
+//#region src/cli/commands/capture.ts
+var capture_default = define({
+	name: "capture",
+	description: "Capture current kintone form schema to file",
+	args: { ...kintoneArgs },
+	run: async (ctx) => {
+		try {
+			const config = resolveConfig(ctx.values);
+			const container = createCliContainer(config);
+			const s = p.spinner();
+			s.start("Capturing current form schema...");
+			const result = await captureSchema({ container });
+			s.stop("Form schema captured.");
+			await saveSchema({
+				container,
+				input: { schemaText: result.schemaText }
+			});
+			p.log.success(`Schema saved to: ${pc.cyan(config.schemaFilePath)}`);
+			if (result.hasExistingSchema) p.log.warn("Existing schema was overwritten.");
+		} catch (error) {
+			handleCliError(error);
+		}
+	}
+});
+
+//#endregion
+//#region src/core/domain/formSchema/services/diffDetector.ts
+function isArrayEqual(a, b) {
+	if (!Array.isArray(a) || !Array.isArray(b)) return false;
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (!isValueEqual(a[i], b[i])) return false;
+	return true;
+}
+function isRecordEqual(a, b) {
+	const keysA = Object.keys(a);
+	const keysB = Object.keys(b);
+	if (keysA.length !== keysB.length) return false;
+	for (const key of keysA) {
+		if (!Object.hasOwn(b, key)) return false;
+		if (!isValueEqual(a[key], b[key])) return false;
+	}
+	return true;
+}
+function isValueEqual(a, b) {
+	if (a === b) return true;
+	if (a === null || b === null) return a === b;
+	if (typeof a !== typeof b) return false;
+	if (Array.isArray(a)) return isArrayEqual(a, b);
+	if (typeof a === "object") return isRecordEqual(a, b);
+	return false;
+}
+function isMapEqual(a, b) {
+	if (a.size !== b.size) return false;
+	for (const [key, valA] of a) {
+		const valB = b.get(key);
+		if (valB === void 0) return false;
+		if (!isFieldEqual(valA, valB)) return false;
+	}
+	return true;
+}
+function isPropertiesEqual(a, b) {
+	if (a.type === "SUBTABLE" && b.type === "SUBTABLE") return isMapEqual(a.properties.fields, b.properties.fields);
+	if (a.type === "REFERENCE_TABLE" && b.type === "REFERENCE_TABLE") {
+		const refA = a.properties.referenceTable;
+		const refB = b.properties.referenceTable;
+		return isValueEqual({
+			...refA,
+			displayFields: [...refA.displayFields]
+		}, {
+			...refB,
+			displayFields: [...refB.displayFields]
+		});
+	}
+	return isValueEqual(a.properties, b.properties);
+}
+function isFieldEqual(a, b) {
+	if (a.type !== b.type) return false;
+	if (a.label !== b.label) return false;
+	if (a.code !== b.code) return false;
+	if (Boolean(a.noLabel) !== Boolean(b.noLabel)) return false;
+	return isPropertiesEqual(a, b);
+}
+function hasPropertiesChanged(before, after) {
+	if (before.type === "SUBTABLE" && after.type === "SUBTABLE") return !isMapEqual(before.properties.fields, after.properties.fields);
+	if (before.type === "REFERENCE_TABLE" && after.type === "REFERENCE_TABLE") {
+		const refB = before.properties.referenceTable;
+		const refA = after.properties.referenceTable;
+		return !isValueEqual({
+			...refB,
+			displayFields: [...refB.displayFields]
+		}, {
+			...refA,
+			displayFields: [...refA.displayFields]
+		});
+	}
+	return !isValueEqual(before.properties, after.properties);
+}
+function describeChanges(before, after) {
+	const changes = [];
+	if (before.type !== after.type) changes.push(`type: ${before.type} -> ${after.type}`);
+	if (before.label !== after.label) changes.push(`label: ${before.label} -> ${after.label}`);
+	if (Boolean(before.noLabel) !== Boolean(after.noLabel)) changes.push(`noLabel: ${before.noLabel ?? false} -> ${after.noLabel ?? false}`);
+	if (hasPropertiesChanged(before, after)) changes.push("properties changed");
+	return changes.length > 0 ? changes.join(", ") : "no visible changes";
+}
+function isLayoutEqual(a, b) {
+	return isValueEqual(a, b);
+}
+const DiffDetector = {
+	detectLayoutChanges: (schemaLayout, currentLayout) => {
+		return !isLayoutEqual(schemaLayout, currentLayout);
+	},
+	detect: (schema, current) => {
+		const entries = [];
+		for (const [fieldCode, schemaDef] of schema.fields) {
+			const currentDef = current.get(fieldCode);
+			if (currentDef === void 0) entries.push({
+				type: "added",
+				fieldCode,
+				fieldLabel: schemaDef.label,
+				details: "new field",
+				after: schemaDef
+			});
+			else if (!isFieldEqual(schemaDef, currentDef)) entries.push({
+				type: "modified",
+				fieldCode,
+				fieldLabel: schemaDef.label,
+				details: describeChanges(currentDef, schemaDef),
+				before: currentDef,
+				after: schemaDef
+			});
+		}
+		for (const [fieldCode, currentDef] of current) if (!schema.fields.has(fieldCode)) entries.push({
+			type: "deleted",
+			fieldCode,
+			fieldLabel: currentDef.label,
+			details: "deleted",
+			before: currentDef
+		});
+		return FormDiff.create(entries);
+	}
+};
+
+//#endregion
+//#region src/core/domain/formSchema/services/schemaParser.ts
+const VALID_UNIT_POSITIONS = new Set(["BEFORE", "AFTER"]);
+const VALID_CALC_FORMATS = new Set([
+	"NUMBER",
+	"NUMBER_DIGIT",
+	"DATE",
+	"TIME",
+	"DATETIME",
+	"HOUR_MINUTE",
+	"DAY_HOUR_MINUTE"
+]);
+const VALID_SELECTION_ALIGNS = new Set(["HORIZONTAL", "VERTICAL"]);
+const VALID_LINK_PROTOCOLS = new Set([
+	"WEB",
+	"CALL",
+	"MAIL"
+]);
+function validateEnumProperty(fieldCode, propName, value, validValues) {
+	if (value !== void 0 && !validValues.has(value)) throw new BusinessRuleError(FormSchemaErrorCode.InvalidSchemaStructure, `Invalid ${propName} "${String(value)}" for field "${fieldCode}". Expected one of: ${[...validValues].join(", ")}`);
+}
+function validateFieldProperties(code, fieldType, properties) {
+	switch (fieldType) {
+		case "NUMBER":
+			validateEnumProperty(code, "unitPosition", properties.unitPosition, VALID_UNIT_POSITIONS);
+			break;
+		case "CALC":
+			validateEnumProperty(code, "format", properties.format, VALID_CALC_FORMATS);
+			validateEnumProperty(code, "unitPosition", properties.unitPosition, VALID_UNIT_POSITIONS);
+			break;
+		case "CHECK_BOX":
+		case "RADIO_BUTTON":
+		case "MULTI_SELECT":
+		case "DROP_DOWN":
+			validateEnumProperty(code, "align", properties.align, VALID_SELECTION_ALIGNS);
+			break;
+		case "LINK":
+			validateEnumProperty(code, "protocol", properties.protocol, VALID_LINK_PROTOCOLS);
+			break;
+	}
+}
+const VALID_FIELD_TYPES = new Set([
+	"SINGLE_LINE_TEXT",
+	"MULTI_LINE_TEXT",
+	"RICH_TEXT",
+	"NUMBER",
+	"CALC",
+	"CHECK_BOX",
+	"RADIO_BUTTON",
+	"MULTI_SELECT",
+	"DROP_DOWN",
+	"DATE",
+	"TIME",
+	"DATETIME",
+	"LINK",
+	"USER_SELECT",
+	"ORGANIZATION_SELECT",
+	"GROUP_SELECT",
+	"FILE",
+	"GROUP",
+	"SUBTABLE",
+	"REFERENCE_TABLE"
+]);
+const DECORATION_TYPES = new Set([
+	"LABEL",
+	"SPACER",
+	"HR"
+]);
+const SYSTEM_FIELD_TYPES = new Set([
+	"RECORD_NUMBER",
+	"CREATOR",
+	"CREATED_TIME",
+	"MODIFIER",
+	"UPDATED_TIME",
+	"CATEGORY",
+	"STATUS",
+	"STATUS_ASSIGNEE"
+]);
+const BASE_ATTRIBUTES = new Set([
+	"code",
+	"type",
+	"label",
+	"noLabel"
+]);
+const LAYOUT_ATTRIBUTES = new Set(["size"]);
+const DECORATION_ATTRIBUTES = new Set(["elementId"]);
+const GROUP_ATTRIBUTES = new Set(["openGroup", "layout"]);
+const SUBTABLE_ATTRIBUTES = new Set(["fields"]);
+function parseSize(raw) {
+	if (raw === void 0 || raw === null) return void 0;
+	if (typeof raw !== "object") return void 0;
+	const obj = raw;
+	return {
+		...obj.width !== void 0 ? { width: String(obj.width) } : {},
+		...obj.height !== void 0 ? { height: String(obj.height) } : {},
+		...obj.innerHeight !== void 0 ? { innerHeight: String(obj.innerHeight) } : {}
+	};
+}
+function normalizePropertyValue(value) {
+	if (typeof value === "number") return String(value);
+	return value;
+}
+function extractProperties(raw) {
+	const properties = {};
+	for (const [key, value] of Object.entries(raw)) {
+		if (BASE_ATTRIBUTES.has(key)) continue;
+		if (LAYOUT_ATTRIBUTES.has(key)) continue;
+		if (DECORATION_ATTRIBUTES.has(key)) continue;
+		if (GROUP_ATTRIBUTES.has(key)) continue;
+		if (SUBTABLE_ATTRIBUTES.has(key)) continue;
+		properties[key] = normalizePropertyValue(value);
+	}
+	return properties;
+}
+function buildFieldDefinition(base, fieldType, properties) {
+	switch (fieldType) {
+		case "SINGLE_LINE_TEXT": return {
+			...base,
+			type: fieldType,
+			properties
+		};
+		case "MULTI_LINE_TEXT": return {
+			...base,
+			type: fieldType,
+			properties
+		};
+		case "RICH_TEXT": return {
+			...base,
+			type: fieldType,
+			properties
+		};
+		case "NUMBER": return {
+			...base,
+			type: fieldType,
+			properties
+		};
+		case "CALC": return {
+			...base,
+			type: fieldType,
+			properties
+		};
+		case "CHECK_BOX":
+		case "RADIO_BUTTON":
+		case "MULTI_SELECT":
+		case "DROP_DOWN": return {
+			...base,
+			type: fieldType,
+			properties
+		};
+		case "DATE": return {
+			...base,
+			type: fieldType,
+			properties
+		};
+		case "TIME": return {
+			...base,
+			type: fieldType,
+			properties
+		};
+		case "DATETIME": return {
+			...base,
+			type: fieldType,
+			properties
+		};
+		case "LINK": return {
+			...base,
+			type: fieldType,
+			properties
+		};
+		case "USER_SELECT":
+		case "ORGANIZATION_SELECT":
+		case "GROUP_SELECT": return {
+			...base,
+			type: fieldType,
+			properties
+		};
+		case "FILE": return {
+			...base,
+			type: fieldType,
+			properties
+		};
+		case "GROUP": return {
+			...base,
+			type: fieldType,
+			properties
+		};
+	}
+}
+function parseFieldDefinitionFromFlat(raw) {
+	const code = String(raw.code);
+	const type = String(raw.type);
+	if (!VALID_FIELD_TYPES.has(type)) throw new BusinessRuleError(FormSchemaErrorCode.InvalidFieldType, `Invalid field type "${type}" for field "${code}"`);
+	const fieldCode = FieldCode.create(code);
+	const fieldType = type;
+	const base = {
+		code: fieldCode,
+		label: String(raw.label ?? ""),
+		...raw.noLabel !== void 0 ? { noLabel: raw.noLabel } : {}
+	};
+	if (fieldType === "SUBTABLE") {
+		const rawFields = raw.fields ?? [];
+		const subFields = /* @__PURE__ */ new Map();
+		for (const subRaw of rawFields) {
+			const subDef = parseFieldDefinitionFromFlat(subRaw);
+			subFields.set(subDef.code, subDef);
+		}
+		return {
+			...base,
+			type: "SUBTABLE",
+			properties: { fields: subFields }
+		};
+	}
+	if (fieldType === "REFERENCE_TABLE") {
+		if (raw.referenceTable === void 0 || raw.referenceTable === null || typeof raw.referenceTable !== "object") throw new BusinessRuleError(FormSchemaErrorCode.InvalidSchemaStructure, `Field "${code}" of type REFERENCE_TABLE must have a "referenceTable" property`);
+		const refTable = raw.referenceTable;
+		if (refTable.relatedApp === void 0 || refTable.relatedApp === null || typeof refTable.relatedApp !== "object") throw new BusinessRuleError(FormSchemaErrorCode.InvalidSchemaStructure, `Field "${code}" of type REFERENCE_TABLE must have "referenceTable.relatedApp"`);
+		if (refTable.condition === void 0 || refTable.condition === null || typeof refTable.condition !== "object") throw new BusinessRuleError(FormSchemaErrorCode.InvalidSchemaStructure, `Field "${code}" of type REFERENCE_TABLE must have "referenceTable.condition"`);
+		if (!Array.isArray(refTable.displayFields)) throw new BusinessRuleError(FormSchemaErrorCode.InvalidSchemaStructure, `Field "${code}" of type REFERENCE_TABLE must have "referenceTable.displayFields" array`);
+		const condition = refTable.condition;
+		const displayFields = refTable.displayFields.map((f) => FieldCode.create(f));
+		return {
+			...base,
+			type: "REFERENCE_TABLE",
+			properties: { referenceTable: {
+				relatedApp: refTable.relatedApp,
+				condition: {
+					field: FieldCode.create(condition.field),
+					relatedField: FieldCode.create(condition.relatedField)
+				},
+				...refTable.filterCond !== void 0 ? { filterCond: refTable.filterCond } : {},
+				displayFields,
+				...refTable.sort !== void 0 ? { sort: refTable.sort } : {},
+				...refTable.size !== void 0 ? { size: String(refTable.size) } : {}
+			} }
+		};
+	}
+	const properties = extractProperties(raw);
+	validateFieldProperties(code, fieldType, properties);
+	return buildFieldDefinition(base, fieldType, properties);
+}
+function parseDecorationElement(raw) {
+	const type = String(raw.type);
+	const elementId = String(raw.elementId ?? "");
+	const size = parseSize(raw.size) ?? {};
+	switch (type) {
+		case "LABEL": return {
+			type: "LABEL",
+			label: String(raw.label ?? ""),
+			elementId,
+			size
+		};
+		case "SPACER": return {
+			type: "SPACER",
+			elementId,
+			size
+		};
+		case "HR": return {
+			type: "HR",
+			elementId,
+			size
+		};
+		default: throw new BusinessRuleError(FormSchemaErrorCode.InvalidDecorationElement, `Unknown decoration element type: "${type}"`);
+	}
+}
+function parseLayoutElement(raw) {
+	const type = String(raw.type);
+	if (DECORATION_TYPES.has(type)) return parseDecorationElement(raw);
+	if (SYSTEM_FIELD_TYPES.has(type)) return {
+		code: String(raw.code),
+		type,
+		...raw.size !== void 0 ? { size: parseSize(raw.size) } : {}
+	};
+	const field = parseFieldDefinitionFromFlat(raw);
+	const size = parseSize(raw.size);
+	return {
+		field,
+		...size !== void 0 ? { size } : {}
+	};
+}
+function parseLayoutRow(raw) {
+	if (raw.type !== "ROW") throw new BusinessRuleError(FormSchemaErrorCode.InvalidLayoutStructure, `Expected layout row type "ROW", got "${String(raw.type)}"`);
+	return {
+		type: "ROW",
+		fields: (raw.fields ?? []).map(parseLayoutElement)
+	};
+}
+function parseLayoutItem(raw, fieldMap) {
+	const type = String(raw.type);
+	switch (type) {
+		case "ROW": {
+			const row = parseLayoutRow(raw);
+			collectFieldsFromElements(row.fields, fieldMap);
+			return row;
+		}
+		case "GROUP": {
+			const code = FieldCode.create(String(raw.code));
+			const label = String(raw.label ?? "");
+			const noLabel = raw.noLabel !== void 0 ? raw.noLabel : void 0;
+			const openGroup = raw.openGroup !== void 0 ? raw.openGroup : void 0;
+			const layout = (raw.layout ?? []).map((r) => {
+				const row = parseLayoutRow(r);
+				collectFieldsFromElements(row.fields, fieldMap);
+				return row;
+			});
+			addFieldToMap(fieldMap, code, {
+				code,
+				label,
+				...noLabel !== void 0 ? { noLabel } : {},
+				type: "GROUP",
+				properties: { ...openGroup !== void 0 ? { openGroup } : {} }
+			});
+			return {
+				type: "GROUP",
+				code,
+				label,
+				...noLabel !== void 0 ? { noLabel } : {},
+				...openGroup !== void 0 ? { openGroup } : {},
+				layout
+			};
+		}
+		case "SUBTABLE": {
+			const code = FieldCode.create(String(raw.code));
+			const label = String(raw.label ?? "");
+			const noLabel = raw.noLabel !== void 0 ? raw.noLabel : void 0;
+			const elements = (raw.fields ?? []).map(parseLayoutElement);
+			const subFields = /* @__PURE__ */ new Map();
+			collectFieldsFromElements(elements, subFields);
+			for (const [subCode, subDef] of subFields) addFieldToMap(fieldMap, subCode, subDef);
+			addFieldToMap(fieldMap, code, {
+				code,
+				label,
+				...noLabel !== void 0 ? { noLabel } : {},
+				type: "SUBTABLE",
+				properties: { fields: subFields }
+			});
+			return {
+				type: "SUBTABLE",
+				code,
+				label,
+				...noLabel !== void 0 ? { noLabel } : {},
+				fields: elements
+			};
+		}
+		default: throw new BusinessRuleError(FormSchemaErrorCode.InvalidLayoutStructure, `Unknown layout item type: "${type}"`);
+	}
+}
+function addFieldToMap(fieldMap, code, definition) {
+	if (fieldMap.has(code)) throw new BusinessRuleError(FormSchemaErrorCode.DuplicateFieldCode, `Duplicate field code: "${code}"`);
+	fieldMap.set(code, definition);
+}
+function collectFieldsFromElements(elements, fieldMap) {
+	for (const element of elements) if ("field" in element) addFieldToMap(fieldMap, element.field.code, element.field);
+}
+const SchemaParser = { parse: (rawText) => {
+	if (rawText.trim().length === 0) throw new BusinessRuleError(FormSchemaErrorCode.EmptySchemaText, "Schema text cannot be empty");
+	let parsed;
+	try {
+		parsed = parse(rawText);
+	} catch {
+		throw new BusinessRuleError(FormSchemaErrorCode.InvalidSchemaJson, "Schema text is not valid YAML/JSON");
+	}
+	if (typeof parsed !== "object" || parsed === null) throw new BusinessRuleError(FormSchemaErrorCode.InvalidSchemaStructure, "Schema must be an object");
+	const obj = parsed;
+	if ("fields" in obj && !("layout" in obj)) throw new BusinessRuleError(FormSchemaErrorCode.InvalidSchemaStructure, "\"fields\" キーが検出されました。スキーマフォーマットが変更されています。「現在の設定を取り込む」で新しいフォーマットのスキーマを生成してください。");
+	if (!("layout" in obj) || !Array.isArray(obj.layout)) throw new BusinessRuleError(FormSchemaErrorCode.InvalidLayoutStructure, "Schema must have a \"layout\" array");
+	const rawLayout = obj.layout;
+	const fieldMap = /* @__PURE__ */ new Map();
+	const layout = [];
+	for (const rawItem of rawLayout) layout.push(parseLayoutItem(rawItem, fieldMap));
+	return {
+		fields: fieldMap,
+		layout
+	};
+} };
+
+//#endregion
+//#region src/core/application/formSchema/parseSchema.ts
+function parseSchemaText(rawText) {
+	try {
+		return SchemaParser.parse(rawText);
+	} catch (error) {
+		if (isBusinessRuleError(error)) throw new ValidationError(ValidationErrorCode.InvalidInput, error.message, error);
+		throw error;
+	}
+}
+
+//#endregion
+//#region src/core/application/formSchema/detectDiff.ts
+function toFieldDto(field) {
+	return {
+		code: field.code,
+		type: field.type,
+		label: field.label,
+		properties: field.properties
+	};
+}
+async function detectDiff({ container }) {
+	const schema = parseSchemaText(await container.schemaStorage.get());
+	const [currentFields, currentLayout] = await Promise.all([container.formConfigurator.getFields(), container.formConfigurator.getLayout()]);
+	const diff = DiffDetector.detect(schema, currentFields);
+	const enrichedCurrentLayout = enrichLayoutWithFields(currentLayout, currentFields);
+	const hasLayoutChanges = DiffDetector.detectLayoutChanges(schema.layout, enrichedCurrentLayout);
+	return {
+		entries: diff.entries.map((entry) => ({
+			type: entry.type,
+			fieldCode: entry.fieldCode,
+			fieldLabel: entry.fieldLabel,
+			details: entry.details,
+			...entry.before ? { before: toFieldDto(entry.before) } : {},
+			...entry.after ? { after: toFieldDto(entry.after) } : {}
+		})),
+		schemaFields: Array.from(schema.fields.entries()).map(([code, def]) => ({
+			fieldCode: code,
+			fieldLabel: def.label,
+			fieldType: def.type
+		})),
+		summary: diff.summary,
+		isEmpty: diff.isEmpty && !hasLayoutChanges,
+		hasLayoutChanges
+	};
+}
+
+//#endregion
+//#region src/core/application/formSchema/deployApp.ts
+async function deployApp({ container }) {
+	await container.appDeployer.deploy();
+}
+
+//#endregion
+//#region src/cli/output.ts
+function printDiffResult(result) {
+	const { summary } = result;
+	if (result.isEmpty) {
+		p.log.info("No changes detected.");
+		return;
+	}
+	const summaryParts = [
+		summary.added > 0 ? pc.green(`+${summary.added} added`) : null,
+		summary.modified > 0 ? pc.yellow(`~${summary.modified} modified`) : null,
+		summary.deleted > 0 ? pc.red(`-${summary.deleted} deleted`) : null
+	].filter(Boolean).join(pc.dim("  |  "));
+	p.log.info(`Changes: ${summaryParts}`);
+	if (result.hasLayoutChanges) p.log.info("Layout changes detected.");
+	const lines = result.entries.map((entry) => {
+		const colorize = entry.type === "added" ? pc.green : entry.type === "deleted" ? pc.red : pc.yellow;
+		return `${colorize(entry.type === "added" ? "+" : entry.type === "deleted" ? "-" : "~")} ${pc.dim("[")}${colorize(entry.fieldCode)}${pc.dim("]")} ${entry.fieldLabel}${pc.dim(":")} ${entry.details}`;
+	});
+	p.note(lines.join("\n"), "Diff Details");
+}
+async function promptDeploy(container) {
+	const shouldDeploy = await p.confirm({ message: "運用環境に反映しますか？" });
+	if (p.isCancel(shouldDeploy) || !shouldDeploy) {
+		p.log.warn("テスト環境に反映済みですが、運用環境には反映されていません。");
+		return;
+	}
+	const ds = p.spinner();
+	ds.start("運用環境に反映しています...");
+	await deployApp({ container });
+	ds.stop("運用環境への反映が完了しました。");
+	p.log.success("運用環境への反映が完了しました。");
+}
+
+//#endregion
+//#region src/cli/commands/diff.ts
+var diff_default = define({
+	name: "diff",
+	description: "Detect differences between schema file and current kintone form",
+	args: { ...kintoneArgs },
+	run: async (ctx) => {
+		try {
+			const container = createCliContainer(resolveConfig(ctx.values));
+			const s = p.spinner();
+			s.start("Fetching form schema...");
+			const result = await detectDiff({ container });
+			s.stop("Form schema fetched.");
+			printDiffResult(result);
+		} catch (error) {
+			handleCliError(error);
+		}
+	}
+});
+
+//#endregion
+//#region src/cli/commands/dump.ts
+var dump_default = define({
+	name: "dump",
+	description: "Dump current kintone form fields and layout as JSON",
+	args: { ...kintoneArgs },
+	run: async (ctx) => {
+		try {
+			const config = resolveConfig(ctx.values);
+			const client = new KintoneRestAPIClient({
+				baseUrl: config.baseUrl,
+				auth: {
+					username: config.username,
+					password: config.password
+				}
+			});
+			const s = p.spinner();
+			s.start("Fetching form fields and layout...");
+			const [fields, layout] = await Promise.all([client.app.getFormFields({ app: config.appId }), client.app.getFormLayout({ app: config.appId })]);
+			s.stop("Form data fetched.");
+			await Promise.all([writeFile("fields.json", JSON.stringify(fields, null, 2)), writeFile("layout.json", JSON.stringify(layout, null, 2))]);
+			p.log.success(`Saved ${pc.cyan("fields.json")} and ${pc.cyan("layout.json")}`);
+		} catch (error) {
+			handleCliError(error);
+		}
+	}
+});
+
+//#endregion
+//#region src/core/application/formSchema/executeMigration.ts
+async function executeMigration({ container }) {
+	const schema = parseSchemaText(await container.schemaStorage.get());
+	const [currentFields, currentLayout] = await Promise.all([container.formConfigurator.getFields(), container.formConfigurator.getLayout()]);
+	const diff = DiffDetector.detect(schema, currentFields);
+	const enrichedCurrentLayout = enrichLayoutWithFields(currentLayout, currentFields);
+	const hasLayoutChanges = DiffDetector.detectLayoutChanges(schema.layout, enrichedCurrentLayout);
+	if (diff.isEmpty && !hasLayoutChanges) return;
+	const subtableInnerCodes = collectSubtableInnerFieldCodes(schema.fields);
+	const added = diff.entries.filter((e) => e.type === "added");
+	const modified = diff.entries.filter((e) => e.type === "modified");
+	const deleted = diff.entries.filter((e) => e.type === "deleted");
+	if (added.length > 0) {
+		const fields = added.filter((e) => e.after !== void 0).filter((e) => !subtableInnerCodes.has(e.fieldCode)).map((e) => e.after);
+		if (fields.length > 0) await container.formConfigurator.addFields(fields);
+	}
+	if (modified.length > 0) {
+		const fields = modified.filter((e) => e.after !== void 0).filter((e) => !subtableInnerCodes.has(e.fieldCode)).map((e) => e.after);
+		if (fields.length > 0) await container.formConfigurator.updateFields(fields);
+	}
+	if (deleted.length > 0) {
+		const currentSubtableInnerCodes = collectSubtableInnerFieldCodes(currentFields);
+		const fieldCodes = deleted.filter((e) => !currentSubtableInnerCodes.has(e.fieldCode)).map((e) => e.fieldCode);
+		if (fieldCodes.length > 0) await container.formConfigurator.deleteFields(fieldCodes);
+	}
+	if (hasLayoutChanges) await container.formConfigurator.updateLayout(schema.layout);
+}
+
+//#endregion
+//#region src/cli/commands/migrate.ts
+var migrate_default = define({
+	name: "migrate",
+	description: "Apply schema changes to kintone form",
+	args: { ...kintoneArgs },
+	run: async (ctx) => {
+		try {
+			const container = createCliContainer(resolveConfig(ctx.values));
+			const s = p.spinner();
+			s.start("Detecting changes...");
+			const result = await detectDiff({ container });
+			s.stop("Changes detected.");
+			if (result.isEmpty) {
+				p.log.success("No changes detected. Form is up to date.");
+				return;
+			}
+			printDiffResult(result);
+			const shouldContinue = await p.confirm({ message: "Apply these changes?" });
+			if (p.isCancel(shouldContinue) || !shouldContinue) {
+				p.cancel("Migration cancelled.");
+				process.exit(0);
+			}
+			const ms = p.spinner();
+			ms.start("Applying migration...");
+			await executeMigration({ container });
+			ms.stop("Migration applied.");
+			p.log.success("Migration completed successfully.");
+			await promptDeploy(container);
+		} catch (error) {
+			handleCliError(error);
+		}
+	}
+});
+
+//#endregion
+//#region src/core/application/formSchema/forceOverrideForm.ts
+async function forceOverrideForm({ container }) {
+	const schema = parseSchemaText(await container.schemaStorage.get());
+	const currentFields = await container.formConfigurator.getFields();
+	const subtableInnerCodes = collectSubtableInnerFieldCodes(schema.fields);
+	const toAdd = [];
+	const toUpdate = [];
+	const toDelete = [];
+	for (const [fieldCode, schemaDef] of schema.fields) {
+		if (subtableInnerCodes.has(fieldCode)) continue;
+		if (currentFields.has(fieldCode)) toUpdate.push(schemaDef);
+		else toAdd.push(schemaDef);
+	}
+	const currentSubtableInnerCodes = collectSubtableInnerFieldCodes(currentFields);
+	for (const fieldCode of currentFields.keys()) {
+		if (currentSubtableInnerCodes.has(fieldCode)) continue;
+		if (!schema.fields.has(fieldCode)) toDelete.push(fieldCode);
+	}
+	if (toAdd.length > 0) await container.formConfigurator.addFields(toAdd);
+	if (toUpdate.length > 0) await container.formConfigurator.updateFields(toUpdate);
+	if (toDelete.length > 0) await container.formConfigurator.deleteFields(toDelete);
+	await container.formConfigurator.updateLayout(schema.layout);
+}
+
+//#endregion
+//#region src/cli/commands/override.ts
+var override_default = define({
+	name: "override",
+	description: "Force override kintone form with declared schema",
+	args: { ...kintoneArgs },
+	run: async (ctx) => {
+		try {
+			const container = createCliContainer(resolveConfig(ctx.values));
+			p.log.warn(`${pc.bold(pc.red("WARNING:"))} This will replace the entire form with the declared schema.`);
+			p.log.warn("Fields not defined in the schema will be deleted.");
+			const shouldContinue = await p.confirm({ message: "Are you sure you want to force override?" });
+			if (p.isCancel(shouldContinue) || !shouldContinue) {
+				p.cancel("Force override cancelled.");
+				process.exit(0);
+			}
+			const s = p.spinner();
+			s.start("Force overriding form...");
+			await forceOverrideForm({ container });
+			s.stop("Force override applied.");
+			p.log.success("Force override completed successfully.");
+			await promptDeploy(container);
+		} catch (error) {
+			handleCliError(error);
+		}
+	}
+});
+
+//#endregion
+//#region src/cli/index.ts
+function loadVersion() {
+	try {
+		return createRequire(import.meta.url)("../package.json").version;
+	} catch {
+		return "0.0.0-dev";
+	}
+}
+const main = define({
+	name: "kintone-migrator",
+	description: "kintone form schema migration tool",
+	run: () => {}
+});
+await cli(process.argv.slice(2), main, {
+	name: "kintone-migrator",
+	version: loadVersion(),
+	subCommands: {
+		diff: diff_default,
+		migrate: migrate_default,
+		override: override_default,
+		capture: capture_default,
+		dump: dump_default
+	}
+});
+
+//#endregion
+export {  };