@stalfh233/omc-cli 0.0.0-stage → 0.4.0

package/dist/fake/workflow.js

@@ -0,0 +1,364 @@
+import { businessRefusal, malformedEnvelope, NOT_HANDLED } from "./state.js";
+const PENDING_STATES = new Set(["NOTSTARTED", "INPROGRESS"]);
+const ACTIVITY_TYPES = new Set(["START", "END", "CONNECTION", "PARTICIPANT", "SUB_INSTANCE", "CIRCULATE", "SYSTEM_ACTIVITY", "AGENT_ACTIVITY"]);
+const POINT = /^-?\d+(?:\.\d+)?,\s-?\d+(?:\.\d+)?$/;
+/**
+ * Live 8.6.26 fidelity (2026-09-17 probe): workflow/validate and /publish
+ * answer HTTP 200 + errcode 0 and put the truth in `data` as
+ * ValidateMessage[]. The originate (first PARTICIPANT) node's `participant`
+ * must be the platform keyword `"{Originator}"`; a plain value ("admin")
+ * answers `401035 <activityName> ERROR` and the flow never goes live.
+ * `"{Creator}"` on a non-originate participant node is a `401062` WARN that
+ * does not block.
+ */
+function validateWorkflowParticipants(activities) {
+    if (!Array.isArray(activities))
+        return [];
+    const rows = activities;
+    const participants = rows.filter((activity) => String(activity?.activityType ?? "") === "PARTICIPANT");
+    const messages = [];
+    const originate = participants[0];
+    if (originate && String(originate.participant ?? "") !== "{Originator}")
+        messages.push({ errCode: 401035, errContent: originate.activityName ?? originate.activityCode ?? "", errMsg: null, errorLevel: "ERROR" });
+    for (const activity of participants.slice(1)) {
+        if (String(activity.participant ?? "") === "{Creator}")
+            messages.push({ errCode: 401062, errContent: activity.activityName ?? activity.activityCode ?? "", errMsg: null, errorLevel: "WARN" });
+    }
+    return messages;
+}
+function invalidRenderShape(body) {
+    if (!Array.isArray(body.activities))
+        return "activities";
+    const codes = new Set();
+    for (const activity of body.activities) {
+        const record = activity;
+        const code = String(record?.activityCode ?? "").trim();
+        const type = String(record?.activityType ?? "").trim();
+        if (!code || codes.has(code) || !ACTIVITY_TYPES.has(type))
+            return "activities";
+        codes.add(code);
+    }
+    if (!Array.isArray(body.rules))
+        return "rules";
+    for (const rule of body.rules) {
+        const record = rule;
+        const pre = String(record?.preActivityCode ?? "");
+        const post = String(record?.postActivityCode ?? "");
+        const points = record?.points;
+        if (!codes.has(pre) || !codes.has(post) || !Array.isArray(points) || points.length === 0 || points.some((point) => typeof point !== "string" || !POINT.test(point)))
+            return "rules";
+    }
+    return null;
+}
+/**
+ * Spawn the two work items a workflow start produces: the originator fill item
+ * (already FINISHED — the start submit is the fill) and the pending approval
+ * item that `workitem.list` must surface for `data.submit`.
+ */
+export function startWorkflowInstance(state, input) {
+    const sequence = state.workItems.size + 1;
+    const instanceId = `wf-${sequence}`;
+    const fillId = `wi-${sequence}`;
+    const approveId = `wi-${sequence + 1}`;
+    state.workItems.set(fillId, {
+        id: fillId,
+        instanceId,
+        activityCode: "fill",
+        activityName: "填写申请单",
+        participant: "tester",
+        state: "FINISHED",
+        workflowCode: input.workflowCode,
+        schemaCode: input.schemaCode,
+        bizObjectId: input.bizObjectId,
+    });
+    state.workItems.set(approveId, {
+        id: approveId,
+        instanceId,
+        activityCode: "approve",
+        activityName: "审批",
+        participant: "tester",
+        state: "INPROGRESS",
+        workflowCode: input.workflowCode,
+        schemaCode: input.schemaCode,
+        bizObjectId: input.bizObjectId,
+    });
+    return { workflowInstanceId: instanceId, workItemId: approveId };
+}
+/** Complete a pending work item (approval submit). Returns false if unknown. */
+export function completeWorkItem(state, workItemId) {
+    const item = state.workItems.get(workItemId);
+    if (!item)
+        return false;
+    item.state = "FINISHED";
+    return true;
+}
+/**
+ * Portal draft-save shape (finishStart=FALSE): one instance in DRAFT with a
+ * single PENDING start work item. Submitting that item (startWorkflowDraft's
+ * workItemId) is what advances the instance — see startWorkflowInstance for
+ * the finishStart=TRUE twin.
+ */
+export function startWorkflowDraft(state, input) {
+    const sequence = state.workItems.size + 1;
+    const instanceId = `wf-${sequence}`;
+    const startId = `wi-${sequence}`;
+    state.workItems.set(startId, {
+        id: startId,
+        instanceId,
+        activityCode: "fill",
+        activityName: "填写申请单",
+        participant: "tester",
+        state: "INPROGRESS",
+        workflowCode: input.workflowCode,
+        schemaCode: input.schemaCode,
+        bizObjectId: input.bizObjectId,
+        isStart: true,
+    });
+    return { workflowInstanceId: instanceId, workItemId: startId };
+}
+/** After the START work item is submitted, the next (approval) activity spawns a pending todo. */
+export function spawnApprovalWorkItem(state, input) {
+    const approveId = `wi-${state.workItems.size + 1}`;
+    state.workItems.set(approveId, {
+        id: approveId,
+        instanceId: input.instanceId,
+        activityCode: "approve",
+        activityName: "审批",
+        participant: "tester",
+        state: "INPROGRESS",
+        workflowCode: input.workflowCode,
+        schemaCode: input.schemaCode,
+        bizObjectId: input.bizObjectId,
+    });
+    return approveId;
+}
+function toWorkItemVO(item) {
+    return {
+        id: item.id,
+        instanceId: item.instanceId,
+        activityCode: item.activityCode,
+        activityName: item.activityName,
+        state: item.state,
+        workflowCode: item.workflowCode,
+        schemaCode: item.schemaCode,
+        participant: item.participant,
+        participantName: item.participantName ?? item.participant,
+        originator: item.originator,
+        sequenceNo: item.sequenceNo,
+    };
+}
+/** W7-S29-greenfield lane: workflow template authoring + runtime work-item query. Twin of src/lanes/workflow.ts. */
+export const workflowRoute = (ctx, input) => {
+    const q = input.query ?? {};
+    const body = (input.body ?? {});
+    switch (input.path) {
+        case "/api/api/workflow/create": {
+            const code = String(body.workflowCode ?? body.code ?? "");
+            const name = String(body.workflowName ?? body.name ?? code);
+            const schemaCode = String(body.schemaCode ?? "");
+            // Ticket 76 live fidelity: creating a workflow when the SCHEMA already
+            // has one answers an envelope with NO numeric errcode (live:
+            // "envelope for /api/api/workflow/create has no numeric errcode") — the
+            // tool must decode it as a duplicate-create, not a malformed failure.
+            if ([...ctx.state.workflows.values()].some((wf) => wf.schemaCode === schemaCode) && !ctx.state.workflows.has(code))
+                return malformedEnvelope({ workflowCode: code, workflowName: name, schemaCode, exist: true });
+            if (!ctx.state.workflows.has(code)) {
+                // Ticket 112 platform fidelity: the real create auto-generates a
+                // full draft (START → PARTICIPANT 填写申请单 → END with canvas rules;
+                // WorkflowTemplateController update @ApiImplicitParam example) — the
+                // fake seeds the same platform-shaped template so the merge path has
+                // real activity boxes and rule shapes to echo.
+                ctx.state.workflows.set(code, {
+                    code,
+                    name,
+                    schemaCode,
+                    template: {
+                        workflowCode: code,
+                        name,
+                        workflowName: name,
+                        schemaCode,
+                        // Live create seeds templateType DRAFT ("SAVE" is not a
+                        // WorkflowTemplateStatus member — S29 contract).
+                        templateType: "DRAFT",
+                        activities: [
+                            { activityCode: "Activity1", activityType: "START", activityName: "开始", x: 327, y: 36, width: 158, height: 40 },
+                            { activityCode: "Activity2", activityType: "PARTICIPANT", activityName: "填写申请单", participant: "{Originator}", x: 327, y: 116, width: 158, height: 40 },
+                            { activityCode: "Activity3", activityType: "END", activityName: "结束", x: 327, y: 196, width: 158, height: 40 },
+                        ],
+                        rules: [
+                            { preActivityCode: "Activity1", postActivityCode: "Activity2", points: ["406, 76", "406, 116"] },
+                            { preActivityCode: "Activity2", postActivityCode: "Activity3", points: ["406, 156", "406, 196"] },
+                        ],
+                    },
+                    published: null,
+                });
+            }
+            return { code };
+        }
+        case "/api/api/workflow/isworkflow": {
+            // WorkflowTemplateController.isWorkFlow(schemaCode): any header for the
+            // schema answers true.
+            const schemaCode = String(q.schemaCode ?? "");
+            return [...ctx.state.workflows.values()].some((wf) => wf.schemaCode === schemaCode);
+        }
+        case "/api/api/workflow/getWorkflow": {
+            // WorkflowTemplateController.getWorkflow(schemaCode): the published
+            // template for the schema (carries workflowCode), or null when the model
+            // has none. Used to auto-start a workflow-backed data.submit.
+            const schemaCode = String(q.schemaCode ?? "");
+            const wf = [...ctx.state.workflows.values()].find((candidate) => candidate.schemaCode === schemaCode);
+            if (!wf)
+                return null;
+            const template = (wf.published ?? wf.template);
+            return { ...template, workflowCode: wf.code };
+        }
+        case "/api/api/workflow/get_header": {
+            const wf = ctx.state.workflows.get(String(q.workflowCode ?? ""));
+            // Round-2 live fidelity (BUG-05): these endpoints answer 401001
+            // 流程不存在！ for an ABSENT workflow rather than a null payload.
+            if (!wf)
+                return businessRefusal(401001, "流程不存在！");
+            return { code: wf.code, name: wf.name };
+        }
+        case "/api/api/workflow/get_draft": {
+            const wf = ctx.state.workflows.get(String(q.workflowCode ?? ""));
+            if (!wf)
+                return businessRefusal(401001, "流程不存在！");
+            return wf.template;
+        }
+        case "/api/api/workflow/get_published": {
+            const wf = ctx.state.workflows.get(String(q.workflowCode ?? ""));
+            // Live fidelity: like get_header/get_draft, an ABSENT workflow answers
+            // 401001 流程不存在！ rather than a null payload; the tool degrades that
+            // to exists:false. Ticket 77: an UNPUBLISHED workflow still answers the
+            // DRAFT shape here — data presence is not publish evidence. The
+            // published face carries the templateType PUBLISH marker.
+            if (!wf)
+                return businessRefusal(401001, "流程不存在！");
+            return wf.published ?? wf.template ?? null;
+        }
+        case "/api/api/workflow/update": {
+            const code = String(body.workflowCode ?? q.workflowCode ?? "");
+            const wf = ctx.state.workflows.get(code);
+            if (!wf)
+                return null;
+            // Ticket 112 platform fidelity (WorkflowTemplateUtil.java:90-171): an
+            // illegal templateType ("BusinessProcess" is not a
+            // WorkflowTemplateStatus member — valueOf at :136) or an activities
+            // element without a type makes the converter swallow the exception
+            // into a PARTIAL model; the save chain then fails with errcode 50000.
+            if (body.templateType === "BusinessProcess")
+                return businessRefusal(50000, "服务异常");
+            if (Array.isArray(body.activities) &&
+                body.activities.some((activity) => {
+                    const record = activity;
+                    const type = record != null && typeof record === "object" ? (record.type ?? record.activityType) : undefined;
+                    return type === undefined || type === null || String(type).trim() === "";
+                }))
+                return businessRefusal(50000, "服务异常");
+            if (body.activities !== undefined && invalidRenderShape(body))
+                return businessRefusal(50000, "服务异常");
+            // Platform fidelity (live 2026-09-23; bench12/13/15): an existing
+            // activityCode cannot be RENAMED or RETYPED — the stored name/type win.
+            // A caller that wants a different name/type must send it under a fresh
+            // code (the tool reconciles this before the wire); re-sending the same
+            // code with a changed name is a silent no-op on the platform, so the fake
+            // must reproduce it rather than store the body verbatim.
+            const stored = wf.template.activities;
+            const storedByCode = new Map((Array.isArray(stored) ? stored : []).map((activity) => [String(activity.activityCode ?? ""), activity]));
+            const pinned = Array.isArray(body.activities)
+                ? {
+                    ...body,
+                    activities: body.activities.map((activity) => {
+                        const prior = storedByCode.get(String(activity.activityCode ?? ""));
+                        return prior
+                            ? { ...activity, activityName: prior.activityName, i18nMessage: prior.i18nMessage, activityType: prior.activityType }
+                            : activity;
+                    }),
+                }
+                : body;
+            wf.template = { ...pinned };
+            return { code };
+        }
+        case "/api/api/workflow/validate":
+        case "/api/api/workflow/publish": {
+            const code = String(body.workflowCode ?? q.workflowCode ?? "");
+            const wf = ctx.state.workflows.get(code);
+            if (!wf)
+                return null;
+            if (body.activities !== undefined && invalidRenderShape(body))
+                return businessRefusal(50000, "服务异常");
+            // Live 8.6.26 fidelity (2026-09-17): validate/publish REFUSE with HTTP
+            // 200 + errcode 0 and the truth in `data` as ValidateMessage[]
+            // ({errCode, errContent, errorLevel}). The originate (first PARTICIPANT)
+            // node's participant must be the platform keyword "{Originator}" — a
+            // plain user/role value answers 401035 ERROR while errcode stays 0, and
+            // the flow never goes live. `{Creator}` on a non-originate node is a WARN
+            // (401062) that does not block.
+            const activities = Array.isArray(body.activities) ? body.activities : wf.template.activities;
+            const validation = validateWorkflowParticipants(activities);
+            if (input.path === "/api/api/workflow/validate")
+                return validation;
+            if (validation.some((message) => message.errorLevel === "ERROR"))
+                return validation;
+            // Ticket 77: the published face carries the PUBLISH marker (live readback
+            // evidence: publish state is identified by templateType:PUBLISH /
+            // version fields, never by data presence).
+            wf.published = { ...body, templateType: "PUBLISH", workflowVersion: (wf.published ? Number(wf.published.workflowVersion ?? 1) : 0) + 1 };
+            return { code, workflowVersion: wf.published.workflowVersion };
+        }
+        case "/api/api/workflow/delete":
+            ctx.state.workflows.delete(String(body.workflowCode ?? q.workflowCode ?? q.code ?? ""));
+            return null;
+        case "/api/api/runtime/workflow/search_workitems": {
+            // The real endpoint returns the caller's pending todos (biz_workitem only
+            // holds pending rows); finished items move to the finished store. The
+            // server's filterWorkflowInstanceId is a NOT-equal exclusion, so it is
+            // deliberately not honored here — exact instance matching is client-side.
+            let rows = [...ctx.state.workItems.values()].filter((item) => PENDING_STATES.has(item.state));
+            if (q.workflowCode)
+                rows = rows.filter((item) => item.workflowCode === q.workflowCode);
+            if (q.schemaCode)
+                rows = rows.filter((item) => item.schemaCode === q.schemaCode);
+            const page = Number(q.page ?? 0);
+            const size = Number(q.size ?? 20);
+            const start = page * size;
+            return {
+                totalElements: rows.length,
+                totalPages: size > 0 ? Math.ceil(rows.length / size) : 0,
+                content: rows.slice(start, start + size).map(toWorkItemVO),
+            };
+        }
+        case "/api/api/runtime/workflow/getBizObjectByWfInstanceId": {
+            const instanceId = String(q.workflowInstanceId ?? "");
+            const item = [...ctx.state.workItems.values()].find((candidate) => candidate.instanceId === instanceId);
+            if (!item)
+                return null;
+            return { id: item.bizObjectId, schemaCode: item.schemaCode };
+        }
+        case "/api/api/organization/role/list":
+            // Real shape: groups with `children` roles (see real-env observation).
+            return [
+                { id: "grp-1", name: "默认", code: "SYS_1000000", children: [{ id: "role-lead", name: "部门负责人", code: "SYS260630023816197", roleType: "SYS", corpId: "corp-1" }] },
+                { id: "role-finance", name: "财务负责人", code: "SYS260515031207258", roleType: "SYS", corpId: "corp-1" },
+            ];
+        case "/api/api/organization/department/tree":
+            return { departmentList: [{ id: "dept-1", name: "总所", code: "1", corpId: "corp-1", parentId: null }, { id: "dept-2", name: "业务部", code: "1_1", corpId: "corp-1", parentId: "dept-1" }] };
+        case "/api/api/organization/user/search": {
+            // UserController.search: @RequestBody {wd,page,size} → PageVO<UserVO>.
+            const wd = String(body.wd ?? "");
+            if (!wd)
+                return businessRefusal(10005, "关键字不能为空");
+            const users = [
+                { id: "user-1", username: "18900000001", name: "付文彬", departmentId: "dept-1", userId: "18900000001", status: "ENABLE", deleted: false, corpId: "corp-1" },
+                { id: "user-2", username: "18900000002", name: "李四", departmentId: "dept-2", userId: "18900000002", status: "ENABLE", deleted: false, corpId: "corp-1" },
+            ].filter((user) => user.name.includes(wd) || user.username.includes(wd));
+            const page = Number(body.page ?? 0);
+            const size = Number(body.size ?? 100);
+            return { totalElements: users.length, totalPages: size > 0 ? Math.ceil(users.length / size) : 0, content: users.slice(page * size, page * size + size) };
+        }
+        default:
+            return NOT_HANDLED;
+    }
+};
+//# sourceMappingURL=workflow.js.map

package/dist/field-change.js

@@ -0,0 +1,200 @@
+import { FIELD_PROPERTY_TYPES } from "./field-families.js";
+import { assertFormConditions, assertNumericalScale, assertFieldOptionsAllowed, buildChildTableSubSchema, buildFieldOptions, ensureRelationDisplayFieldOptions, normalizeFieldPropertyType, relationDisplayFieldCode, } from "./field-families.js";
+import { nameI18nJson } from "./field-families.js";
+import { decodeJsonObjectColumn } from "./json-column.js";
+import { ToolRefusalError } from "./tool-types.js";
+/**
+ * Fail-closed relation-target gate (round17 dogfood R3). A relation field whose
+ * options lack `schemaCode` is ACCEPTED by the platform at create, but then
+ * `field.publish` fails with an opaque `errcode 300010 数据模型编码不能为空！` and
+ * the column is unusable. Backfill `options.schemaCode` from the top-level
+ * `relativeCode` when present (they name the same target); refuse when neither
+ * carries a target, naming the fix instead of letting the model be poisoned.
+ */
+function assertRelationTargetPresent(propertyType, options, relativeCode, code) {
+    if (propertyType !== FIELD_PROPERTY_TYPES.WORK_SHEET && propertyType !== FIELD_PROPERTY_TYPES.MULT_WORK_SHEET)
+        return;
+    const optionCode = typeof options.schemaCode === "string" ? options.schemaCode.trim() : "";
+    if (optionCode)
+        return;
+    // Accept the target under any of the synonyms callers naturally reach for
+    // (top-level relativeCode; options.relativeCode) — they all name the target
+    // model. The platform's authoritative relation key is options.schemaCode.
+    const candidates = [relativeCode, options.relativeCode, options.relativeSchemaCode]
+        .map((value) => (typeof value === "string" ? value.trim() : ""))
+        .filter((value) => value.length > 0);
+    const target = candidates[0];
+    if (target) {
+        options.schemaCode = target;
+        if (typeof options.queryCode !== "string" || options.queryCode.trim() === "")
+            options.queryCode = target;
+        return;
+    }
+    throw new ToolRefusalError({
+        status: "refused",
+        blocker: "field-relation-target-missing",
+        code,
+        message: "关联字段缺少目标模型：options.schemaCode 与顶层 relativeCode 都为空。平台建字段时接受它，但 field.publish 会以 300010『数据模型编码不能为空』拒绝，之后该列不可用。请传 relativeCode:'<目标模型code>'（工具会自动补全 options.schemaCode/queryCode），或在 options 里直接给 schemaCode",
+    });
+}
+/** Normalize one field change and run every reproduced write gate exactly once. */
+export function prepareFieldChange(input) {
+    const propertyType = normalizeFieldPropertyType({ propertyType: input.propertyType });
+    const isChildTable = propertyType === FIELD_PROPERTY_TYPES.CHILD_TABLE;
+    if (isChildTable) {
+        const subSchema = buildChildTableSubSchema({ code: input.code, subFields: input.subFields });
+        return { propertyType, isChildTable, options: {}, subSchema };
+    }
+    const raw = buildFieldOptions({
+        propertyType: input.propertyType,
+        ...(input.choices ? { choices: input.choices } : {}),
+        ...(input.options ? { options: input.options } : {}),
+    });
+    assertRelationTargetPresent(propertyType, raw, input.relativeCode, input.code);
+    // Gates run here so every entry point (direct, orchestrator, intent) shares them.
+    assertFieldOptionsAllowed(propertyType, raw, input.schemaCode);
+    assertNumericalScale(propertyType, raw);
+    assertFormConditions(raw);
+    const options = ensureRelationDisplayFieldOptions(propertyType, raw);
+    const displayCode = relationDisplayFieldCode(propertyType, options);
+    return { propertyType, isChildTable, options, ...(displayCode ? { displayCode } : {}) };
+}
+/** The single platform wire body for a field create. */
+export function fieldChangeWireBody(input, prepared) {
+    return {
+        name: input.name,
+        name_i18n: nameI18nJson(input.name),
+        code: input.code,
+        schemaCode: input.schemaCode,
+        propertyType: prepared.propertyType,
+        propertyEmpty: input.propertyEmpty ?? false,
+        ...(prepared.isChildTable
+            ? { defaultValue: null, subSchema: prepared.subSchema }
+            : { defaultValue: "", ...(prepared.displayCode ? { relativePropertyCode: prepared.displayCode } : {}), options: JSON.stringify(prepared.options) }),
+        ...(input.relativeCode ? { relativeCode: input.relativeCode } : {}),
+    };
+}
+export function prepareFieldUpdate(input) {
+    const recordType = Number(input.base.type ?? input.base.propertyType);
+    const isChildTable = recordType === FIELD_PROPERTY_TYPES.CHILD_TABLE;
+    if (isChildTable && (input.options !== undefined || input.choices !== undefined || input.subFields !== undefined))
+        throw new ToolRefusalError({
+            status: "refused",
+            blocker: "child-table-update-unsupported",
+            schemaCode: input.schemaCode,
+            propertyCode: input.code,
+            message: `子表字段 ${input.schemaCode}.${input.code} 不接受 options/choices/subFields。子表列就是 schemaCode=${input.code} 上的普通字段：增列用 field.create --args '{"schemaCode":"${input.code}","code":"<子列>",...}'，改列/删列用 field.update/field.delete（同 schemaCode），改完对父模型 field.publish 即发布`,
+        });
+    const currentOptions = decodeJsonObjectColumn(input.base.options, { invalid: "throw", array: "accept", object: "accept" }) ?? {};
+    const nextOptions = isChildTable
+        ? currentOptions
+        : ensureRelationDisplayFieldOptions(recordType, {
+            ...currentOptions,
+            ...buildFieldOptions({
+                propertyType: recordType,
+                ...(input.choices ? { choices: input.choices } : {}),
+                ...(input.options ? { options: input.options } : {}),
+            }),
+        });
+    if (!isChildTable && !input.options && !input.choices)
+        Object.assign(nextOptions, currentOptions);
+    if (!isChildTable) {
+        // An update that touches a relation's options must keep a resolvable target:
+        // backfill schemaCode from relativeCode (top-level or already stored) so
+        // field.publish cannot later 300010 on this field.
+        assertRelationTargetPresent(recordType, nextOptions, input.relativeCode ?? (typeof input.base.relativeCode === "string" ? input.base.relativeCode : undefined), input.code);
+        assertFieldOptionsAllowed(recordType, nextOptions, input.schemaCode);
+        if (input.options !== undefined || input.choices !== undefined)
+            assertNumericalScale(recordType, nextOptions);
+        if (input.options !== undefined)
+            assertFormConditions(input.options);
+    }
+    // Ticket 61: an explicit displayField wins; otherwise preserve the stored
+    // top-level relativePropertyCode (the runtime reads it, not options).
+    const displayCode = relationDisplayFieldCode(recordType, nextOptions)
+        ?? (typeof input.base.relativePropertyCode === "string" && input.base.relativePropertyCode.trim() ? input.base.relativePropertyCode.trim() : undefined);
+    const name = input.name ?? (typeof input.base.name === "string" ? input.base.name : undefined);
+    const nameI18n = input.name_i18n !== undefined
+        ? (typeof input.name_i18n === "string" ? input.name_i18n : JSON.stringify(input.name_i18n))
+        : input.name !== undefined
+            ? nameI18nJson(input.name)
+            : (typeof input.base.name_i18n === "string" ? input.base.name_i18n : undefined);
+    return { propertyType: recordType, isChildTable, options: nextOptions, ...(displayCode !== undefined ? { displayCode } : {}), ...(name !== undefined ? { name } : {}), ...(nameI18n !== undefined ? { nameI18n } : {}) };
+}
+/** The single field-update wire body: the stored row spread with changed keys. */
+export function fieldUpdateWireBody(input, prepared) {
+    return {
+        ...input.base,
+        schemaCode: input.schemaCode,
+        code: input.code,
+        ...(prepared.isChildTable ? {} : { options: JSON.stringify(prepared.options) }),
+        ...(prepared.displayCode !== undefined ? { relativePropertyCode: prepared.displayCode } : {}),
+        ...(prepared.name !== undefined ? { name: prepared.name } : {}),
+        ...(prepared.nameI18n !== undefined ? { name_i18n: prepared.nameI18n } : {}),
+        ...(input.relativeCode ? { relativeCode: input.relativeCode } : {}),
+        ...(input.propertyEmpty !== undefined ? { propertyEmpty: input.propertyEmpty } : {}),
+    };
+}
+function canonical(value) {
+    if (Array.isArray(value))
+        return value.map(canonical);
+    if (value && typeof value === "object") {
+        const record = value;
+        return Object.fromEntries(Object.keys(record).sort().map((key) => [key, canonical(record[key])]));
+    }
+    return value;
+}
+function parseStoredOptions(value) {
+    if (typeof value === "string") {
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return value;
+        }
+    }
+    return value;
+}
+/** Canonical, storage-independent view used to decide "same field, no change". */
+export function fieldSemanticDescriptor(row) {
+    const type = Number(row.type ?? row.propertyType);
+    const subSchema = (row.subSchema ?? null);
+    const subFields = subSchema?.properties
+        ? Object.values(subSchema.properties).map((property) => ({
+            code: String(property.code ?? ""),
+            type: Number.isNaN(Number(property.type ?? property.propertyType)) ? null : Number(property.type ?? property.propertyType),
+            options: canonical(parseStoredOptions(property.options)),
+        }))
+        : [];
+    return {
+        code: String(row.code ?? row.propertyCode ?? ""),
+        name: (row.name ?? null),
+        type: Number.isNaN(type) ? null : type,
+        options: canonical(parseStoredOptions(row.options)),
+        subFields: [...subFields].sort((left, right) => left.code.localeCompare(right.code)),
+    };
+}
+/** True when a stored field already matches the requested change (name/type/options/subFields). */
+export function sameFieldChange(stored, input) {
+    const descriptor = fieldSemanticDescriptor(stored);
+    if (descriptor.code !== input.code)
+        return false;
+    if (descriptor.name !== input.name)
+        return false;
+    const prepared = prepareFieldChange(input);
+    if (descriptor.type !== prepared.propertyType)
+        return false;
+    if (prepared.isChildTable) {
+        const wanted = prepared.subSchema?.properties;
+        const wantedFields = wanted
+            ? Object.values(wanted).map((property) => ({
+                code: String(property.code ?? ""),
+                type: Number(property.type ?? property.propertyType),
+                options: canonical(parseStoredOptions(property.options)),
+            })).sort((left, right) => left.code.localeCompare(right.code))
+            : [];
+        return JSON.stringify(descriptor.subFields) === JSON.stringify(wantedFields);
+    }
+    return JSON.stringify(descriptor.options) === JSON.stringify(canonical(prepared.options));
+}
+//# sourceMappingURL=field-change.js.map