@stalfh233/omc-cli 0.0.0-stage → 0.4.10

package/dist/intent/capabilities/form.js

@@ -0,0 +1,136 @@
+import { ENDPOINTS } from "../../endpoints.js";
+import { wireCall, WireError } from "../../wire.js";
+import { refuse } from "../capability.js";
+import { describe, isScalarString, pushError } from "../validation.js";
+/** Keys a form block accepts. */
+const FORM_KEYS = new Set(["publish", "fieldCodes"]);
+function parseJsonObject(value) {
+    if (typeof value !== "string")
+        return {};
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * The default-form publish chain (CONTEXT.md 表单发布链): draft-first layout,
+ * publish, and published-binding readback. It requires the field capability
+ * because a form draft binds declared fields and must follow their publication.
+ */
+export const formCapability = {
+    id: "form",
+    title: "默认表单",
+    requires: ["field"],
+    operations: ["draft", "publish"],
+    validate(node, draft, ctx) {
+        const formNode = node.entries.find((entry) => entry.key === "form")?.value;
+        if (formNode === undefined || (formNode.kind === "scalar" && formNode.value === null))
+            return;
+        if (formNode.kind !== "map") {
+            pushError(ctx, "intent-form-not-a-map", `form 必须是映射（只接受 publish）——得到 ${describe(formNode)}`, `${ctx.base}.form`, "value");
+            return;
+        }
+        for (const entry of formNode.entries) {
+            if (!FORM_KEYS.has(entry.key))
+                pushError(ctx, "intent-key-unknown", `form 不支持键 "${entry.key}"（只接受 publish / fieldCodes）`, `${ctx.base}.form.${entry.key}`);
+        }
+        const publishNode = formNode.entries.find((entry) => entry.key === "publish")?.value;
+        if (publishNode === undefined) {
+            pushError(ctx, "intent-form-publish-missing", "form.publish 缺失（必须显式 true/false——缺 form 键则停在字段发布，不触表单生命周期）", `${ctx.base}.form`, "value");
+            return;
+        }
+        if (publishNode.kind !== "scalar" || typeof publishNode.value !== "boolean") {
+            pushError(ctx, "intent-form-publish-not-boolean", `form.publish 必须是布尔值（得到 ${describe(publishNode)}）`, `${ctx.base}.form.publish`, "value");
+            return;
+        }
+        const fieldCodesNode = formNode.entries.find((entry) => entry.key === "fieldCodes")?.value;
+        let fieldCodes;
+        if (fieldCodesNode !== undefined) {
+            const valid = fieldCodesNode.kind === "seq" && fieldCodesNode.items.every((item) => isScalarString(item));
+            if (!valid)
+                pushError(ctx, "intent-form-fieldcodes-invalid", "form.fieldCodes 必须是非空字符串列表", `${ctx.base}.form.fieldCodes`, "value");
+            else
+                fieldCodes = fieldCodesNode.items.map((item) => item.value.trim());
+        }
+        draft.form = { publish: publishNode.value, ...(fieldCodes ? { fieldCodes } : {}) };
+    },
+    async read(session, _intent, draft) {
+        if (!draft.present)
+            return;
+        try {
+            const sheet = (await wireCall(session, { path: ENDPOINTS.sheetGet, query: { schemaCode: draft.code, sheetCode: draft.code } })).data;
+            if (!sheet || typeof sheet !== "object")
+                return;
+            const row = sheet;
+            draft.form = {
+                present: true,
+                published: row.published === true || typeof row.publishedViewJson === "string",
+                existDraft: row.existDraft === true || typeof row.draftViewJson === "string",
+                boundFieldCodes: Array.isArray(row.binding?.fieldCodes) && row.binding.fieldCodes.length > 0
+                    ? row.binding.fieldCodes.map(String)
+                    : Object.keys(parseJsonObject(row.publishedAttributesJson ?? row.draftAttributesJson)),
+            };
+        }
+        catch (error) {
+            // Form absence 302024 ("表单不存在！") is the authoritative absence probe
+            // on the live face; the fake answers errcode 0 with null data instead.
+            if (error instanceof WireError && error.errcode === 302024)
+                return;
+            throw error;
+        }
+    },
+    plan(intent, baseline, emit) {
+        const form = intent.form;
+        if (!form)
+            return;
+        const declaredCodes = new Set(intent.fields.map((field) => field.code));
+        const formFieldCodes = form.fieldCodes ?? intent.fields.map((field) => field.code);
+        const invalidFormCodes = formFieldCodes.filter((code) => !declaredCodes.has(code));
+        if (invalidFormCodes.length > 0)
+            refuse("intent-form-fieldcodes-unknown", `表单 ${intent.code} 声明了模型字段之外的绑定：${invalidFormCodes.join("、")}`);
+        if (form.publish !== true)
+            return;
+        const requiresExactFormBinding = form.fieldCodes !== undefined;
+        const sameCodes = (left, right) => left.length === right.length && left.every((code) => right.includes(code));
+        const current = baseline.form;
+        if (current.present === true && current.published && (!requiresExactFormBinding || sameCodes(current.boundFieldCodes, formFieldCodes))) {
+            emit.skip(`form:${intent.code}`, "form-published");
+            return;
+        }
+        if (current.present !== true || !current.existDraft || (requiresExactFormBinding && !sameCodes(current.boundFieldCodes, formFieldCodes)))
+            emit.change("form.draft", { schemaCode: intent.code, sheetCode: intent.code, fieldCodes: formFieldCodes }, `form:${intent.code}`, current.present === true ? "form-no-draft" : "form-absent");
+        emit.change("form.publish", { schemaCode: intent.code, sheetCode: intent.code }, `form:${intent.code}`, "form-unpublished");
+    },
+    decode(baseline, draft) {
+        // The form attributes JSON carries designer LAYOUT controls (section
+        // titles/groups keyed as Title<ts>/Group<ts>) alongside field controls;
+        // only real model fields count as bindings (ticket 120 decoder honesty).
+        const fieldCodes = new Set(baseline.fields.map((field) => field.code));
+        const boundFieldCodes = baseline.form.boundFieldCodes.filter((code) => fieldCodes.has(code));
+        draft.form = { ...baseline.form, boundFieldCodes };
+        draft.frontend.formBoundFieldCodes = boundFieldCodes;
+    },
+    compare(intent, live, emit) {
+        if (intent.form?.publish !== true)
+            return;
+        if (!live.present) {
+            emit.difference("form-missing", `form:${intent.code}`, `表单 ${intent.code} 随模型缺失`);
+            return;
+        }
+        if (!live.form.present) {
+            emit.difference("form-missing", `form:${intent.code}`, `默认表单 ${intent.code} 不存在（302024/空 data 解码为 absent）`);
+            return;
+        }
+        if (!live.form.published) {
+            emit.difference("form-not-published", `form:${intent.code}`, `默认表单 ${intent.code} 未发布`);
+            return;
+        }
+        const wantedFormFields = intent.form.fieldCodes ?? intent.fields.map((field) => field.code);
+        if (wantedFormFields.some((code) => !live.frontend.formBoundFieldCodes.includes(code)))
+            emit.difference("form-not-bound", `form:${intent.code}`, `默认表单 ${intent.code} 的控件绑定未覆盖声明字段`);
+    },
+};
+//# sourceMappingURL=form.js.map

package/dist/intent/capabilities/index.js

@@ -0,0 +1,64 @@
+import { businessruleCapability } from "./businessrule.js";
+import { bizserviceCapability } from "./bizservice.js";
+import { dataruleCapability } from "./datarule.js";
+import { fieldCapability } from "./field.js";
+import { formCapability } from "./form.js";
+import { listviewCapability } from "./listview.js";
+import { modelCapability } from "./model.js";
+import { onlinejsCapability } from "./onlinejs.js";
+import { reportCapability } from "./report.js";
+import { workflowCapability } from "./workflow.js";
+/**
+ * Every Configuration capability the intent face carries, in declaration
+ * order. Declaration order is only the tie-break for the topological sort —
+ * execution order comes from each capability's `requires`.
+ */
+export const INTENT_CAPABILITIES = Object.freeze([
+    modelCapability,
+    fieldCapability,
+    formCapability,
+    listviewCapability,
+    bizserviceCapability,
+    dataruleCapability,
+    businessruleCapability,
+    workflowCapability,
+    onlinejsCapability,
+    reportCapability,
+]);
+/**
+ * The capabilities that participate in one model's lifecycle. A model declared
+ * `absent:true` is a deletion target, so ONLY the model capability runs — its
+ * fields/form/listview/rules/... go with it and must not be read or planned.
+ */
+export function capabilitiesForModel(model) {
+    const ordered = orderedCapabilities();
+    return model.absent === true ? ordered.filter((capability) => capability.id === "model") : ordered;
+}
+/**
+ * Capabilities in execution order. `requires` names capabilities that must run
+ * first; among capabilities whose dependencies are already satisfied,
+ * declaration order wins, so the result is deterministic. A cycle or an
+ * unknown requirement fails closed rather than silently reordering.
+ */
+export function orderedCapabilities() {
+    const byId = new Map(INTENT_CAPABILITIES.map((capability) => [capability.id, capability]));
+    for (const capability of INTENT_CAPABILITIES) {
+        for (const requirement of capability.requires) {
+            if (!byId.has(requirement))
+                throw new Error(`capability "${capability.id}" requires unknown capability "${requirement}"`);
+        }
+    }
+    const remaining = [...INTENT_CAPABILITIES];
+    const done = new Set();
+    const ordered = [];
+    while (remaining.length > 0) {
+        const index = remaining.findIndex((capability) => capability.requires.every((requirement) => done.has(requirement)));
+        if (index < 0)
+            throw new Error(`capability requires cycle among: ${remaining.map((capability) => capability.id).join(", ")}`);
+        const [capability] = remaining.splice(index, 1);
+        ordered.push(capability);
+        done.add(capability.id);
+    }
+    return ordered;
+}
+//# sourceMappingURL=index.js.map

package/dist/intent/capabilities/listview.js

@@ -0,0 +1,157 @@
+import { ENDPOINTS } from "../../endpoints.js";
+import { wireCall, WireError } from "../../wire.js";
+import { refuse } from "../capability.js";
+import { SYSTEM_FIELD_CODES } from "../../field-families.js";
+import { isScalarString, pushError } from "../validation.js";
+/** Keys a list-view block accepts. */
+const LISTVIEW_KEYS = new Set(["code", "name", "fieldCodes", "absent"]);
+/**
+ * The list-view design-time header and column lifecycle. It requires the field
+ * capability because its columns reference declared fields.
+ */
+export const listviewCapability = {
+    id: "listview",
+    title: "列表视图",
+    requires: ["field"],
+    operations: ["create", "configure", "delete"],
+    validate(node, draft, ctx) {
+        const listviewNode = node.entries.find((entry) => entry.key === "listview")?.value;
+        if (listviewNode === undefined || (listviewNode.kind === "scalar" && listviewNode.value === null))
+            return;
+        if (listviewNode.kind !== "map") {
+            pushError(ctx, "intent-listview-not-a-map", "listview 必须是映射（只接受 code / name / fieldCodes / absent）", `${ctx.base}.listview`, "value");
+            return;
+        }
+        // Keys the compiler itself derives (never caller-declared): naming them is a
+        // harmless misunderstanding of the column model, so explain that fieldCodes
+        // is authoritative and the platform defaults are cleared automatically.
+        const COMPILER_MANAGED_KEYS = new Set(["hideDefaultSystemFields", "replaceColumns"]);
+        // Keys the intent face deliberately does NOT support declaring: business
+        // sorts / filters / actions / presentation are cleared to the platform
+        // default by the compiler, so a caller who declared them must fall back to
+        // `listview.configure` AFTER apply. The old message claimed the compiler
+        // "自动处理" these, which read as "declaring them works" and cost a retry
+        // (bench67). Name the escape hatch explicitly.
+        const CONFIGURE_ONLY_KEYS = new Set(["conditions", "sorts", "actions", "presentation"]);
+        for (const entry of listviewNode.entries) {
+            if (!LISTVIEW_KEYS.has(entry.key)) {
+                const message = COMPILER_MANAGED_KEYS.has(entry.key)
+                    ? `listview 不支持键 "${entry.key}"——**编译器自动处理**：fieldCodes 就是视图的权威列集合（自动 replaceColumns + hideDefaultSystemFields，清掉平台预置的 name/creater/createdTime/sequenceNo 系统列，并清空默认的 createdTime 筛选/排序）。只需写 fieldCodes；要展示某系统列就把它写进 fieldCodes`
+                    : CONFIGURE_ONLY_KEYS.has(entry.key)
+                        ? `listview 不支持键 "${entry.key}"：intent 的 listview 只声明列（code / name / fieldCodes / absent），**不声明业务筛选/排序/按钮/展示**——编译器会把它们清成平台默认。要配置业务条件/排序请 intent apply 之后用 \`omc call listview.configure\`（它的 conditions/sorts/actions 会增量合并到视图）`
+                        : entry.key === "columns"
+                            ? `listview 不支持键 "columns"；请改用 "fieldCodes" 声明列（只接受 code / name / fieldCodes / absent）`
+                            : `listview 不支持键 "${entry.key}"（只接受 code / name / fieldCodes / absent）`;
+                pushError(ctx, "intent-key-unknown", message, `${ctx.base}.listview.${entry.key}`);
+            }
+        }
+        const lvCode = listviewNode.entries.find((entry) => entry.key === "code")?.value;
+        const lvName = listviewNode.entries.find((entry) => entry.key === "name")?.value;
+        const lvFields = listviewNode.entries.find((entry) => entry.key === "fieldCodes")?.value;
+        const lvAbsent = listviewNode.entries.find((entry) => entry.key === "absent")?.value;
+        // `code` and `name` default to the platform's own default view (code == the
+        // model/schema code) so a caller only has to declare `fieldCodes`. Omitting
+        // them used to be a hard error (bench41: two `intent-listview-*-invalid`
+        // errors and a retry); the default is unambiguous and matches the
+        // documented `listview.configure` behaviour (omit code → the default view).
+        if (lvCode !== undefined && !(lvCode.kind === "scalar" && lvCode.value === null) && !isScalarString(lvCode))
+            pushError(ctx, "intent-listview-code-invalid", "listview.code 必须是非空字符串或省略（省略即模型默认视图 code=schemaCode）", `${ctx.base}.listview.code`, "value");
+        if (lvName !== undefined && !(lvName.kind === "scalar" && lvName.value === null) && !isScalarString(lvName))
+            pushError(ctx, "intent-listview-name-invalid", "listview.name 必须是非空字符串或省略（省略即「<模型名>默认视图」）", `${ctx.base}.listview.name`, "value");
+        const resolvedCode = isScalarString(lvCode) ? lvCode.value.trim() : draft.code;
+        const resolvedName = isScalarString(lvName) ? lvName.value : `${draft.name || draft.code}默认视图`;
+        if (lvAbsent !== undefined && (lvAbsent.kind !== "scalar" || typeof lvAbsent.value !== "boolean"))
+            pushError(ctx, "intent-listview-absent-invalid", "listview.absent 必须是布尔", `${ctx.base}.listview.absent`, "value");
+        if (lvAbsent?.kind === "scalar" && lvAbsent.value === true) {
+            for (const key of ["name", "fieldCodes"])
+                if (listviewNode.entries.some((entry) => entry.key === key))
+                    pushError(ctx, "intent-listview-absent-with-shape", `列表视图声明 absent:true 表示删除该视图，不能再声明 ${key}`, `${ctx.base}.listview.${key}`);
+            draft.listview = { code: resolvedCode, absent: true };
+            return;
+        }
+        const validFields = lvFields?.kind === "seq" && lvFields.items.length > 0 && lvFields.items.every((item) => isScalarString(item));
+        if (!validFields)
+            pushError(ctx, "intent-listview-fieldcodes-invalid", "listview.fieldCodes 必须是非空字符串列表", `${ctx.base}.listview.fieldCodes`, "value");
+        if (validFields)
+            draft.listview = { code: resolvedCode, name: resolvedName, fieldCodes: lvFields.items.map((item) => item.value.trim()) };
+    },
+    async read(session, intent, draft) {
+        if (!draft.present || !intent.listview)
+            return;
+        try {
+            const result = await wireCall(session, { path: ENDPOINTS.listQueryGet, query: { schemaCode: intent.code, code: intent.listview.code, clientType: "PC" } });
+            const view = result.data;
+            if (!view || !view.id)
+                return;
+            const columns = Array.isArray(view.queryColumns)
+                ? view.queryColumns.map((column) => String(column.propertyCode ?? "")).filter(Boolean)
+                : [];
+            draft.listview = { present: true, columns };
+        }
+        catch (error) {
+            if (error instanceof WireError && error.errcode === 302025)
+                return;
+            throw error;
+        }
+    },
+    plan(intent, baseline, emit) {
+        const listview = intent.listview;
+        if (!listview)
+            return;
+        const resource = `listview:${listview.code}`;
+        if (listview.absent === true) {
+            if (baseline.listview.present)
+                emit.change("listview.delete", { schemaCode: intent.code, code: listview.code }, resource, "listview-declared-absent");
+            else
+                emit.skip(resource, "listview-already-absent");
+            return;
+        }
+        const fieldCodes = listview.fieldCodes ?? [];
+        const declaredCodes = new Set(intent.fields.map((field) => field.code));
+        // A declared column may be a business field OR an explicit SYSTEM field
+        // (createdTime/creater/sequenceNo/…) — the user opts into a system column by
+        // naming it; otherwise system columns are dropped (see the configure below).
+        const invalidListviewCodes = fieldCodes.filter((code) => !declaredCodes.has(code) && !SYSTEM_FIELD_CODES.has(code));
+        if (invalidListviewCodes.length > 0)
+            refuse("intent-listview-fieldcodes-unknown", `列表视图 ${listview.code} 声明了模型字段之外的列：${invalidListviewCodes.join("、")}`);
+        if (!baseline.listview.present)
+            emit.change("listview.create", { schemaCode: intent.code, name: listview.name, code: listview.code }, resource, "listview-absent");
+        // The platform's listview.create seeds system columns (name/creater/
+        // createdTime/sequenceNo), a default `createdTime` sort, AND a default
+        // `createdTime` filter; a plain incremental configure keeps them. The
+        // intent's `fieldCodes` IS the desired view, so configure authoritatively:
+        // replaceColumns + hideDefaultSystemFields drop the seeded system columns
+        // (unless the caller named one), and `conditions:[]`/`sorts:[]` clear the
+        // seeded system filter and sort — the user wants business fields, not the
+        // platform's defaults (2026-09-28).
+        if (!baseline.listview.present || fieldCodes.some((code) => !baseline.listview.columns.includes(code)) || baseline.listview.columns.length !== fieldCodes.length)
+            emit.change("listview.configure", { schemaCode: intent.code, code: listview.code, fieldCodes, replaceColumns: true, hideDefaultSystemFields: true, conditions: [], sorts: [] }, resource, "listview-columns-authoritative");
+    },
+    decode(baseline, draft) {
+        draft.frontend.listviewPresent = baseline.listview.present;
+        draft.frontend.listviewColumns = baseline.listview.columns;
+    },
+    compare(intent, live, emit) {
+        const listview = intent.listview;
+        if (!listview || !live.present)
+            return;
+        if (listview.absent === true) {
+            if (live.frontend.listviewPresent)
+                emit.difference("listview-present-unexpected", `listview:${listview.code}`, `列表视图 ${listview.code} 声明 absent:true 但仍存在`);
+            return;
+        }
+        if (!live.frontend.listviewPresent)
+            emit.difference("listview-missing", `listview:${listview.code}`, `列表视图 ${listview.code} 不存在`);
+        else if ((listview.fieldCodes ?? []).some((code) => !live.frontend.listviewColumns.includes(code)))
+            emit.difference("listview-columns-missing", `listview:${listview.code}`, `列表视图 ${listview.code} 缺少声明列`);
+        else {
+            // The intent's fieldCodes IS the view; an unexpected SYSTEM column (not
+            // declared) means the platform's seeded defaults were never cleared.
+            const declared = new Set(listview.fieldCodes ?? []);
+            const unexpectedSystem = live.frontend.listviewColumns.filter((code) => SYSTEM_FIELD_CODES.has(code) && !declared.has(code));
+            if (unexpectedSystem.length > 0)
+                emit.difference("listview-system-columns-unexpected", `listview:${listview.code}`, `列表视图 ${listview.code} 含未声明的系统默认列（应改为业务字段或显式声明）：${unexpectedSystem.join("、")}`);
+        }
+    },
+};
+//# sourceMappingURL=listview.js.map

package/dist/intent/capabilities/model.js

@@ -0,0 +1,100 @@
+import { validateBusinessCode } from "../../code-rules.js";
+import { isScalarString, pushError } from "../validation.js";
+/** Model keys the capability owns on a model node. */
+const MODEL_KEYS = new Set(["code", "name", "absent", "fields", "form", "listview", "rules", "datarules", "workflow", "onlinejs"]);
+/** Keys that describe a live model and are meaningless on a declared-absent one. */
+const PRESENT_ONLY_KEYS = ["name", "fields", "form", "listview", "rules", "datarules", "workflow", "onlinejs"];
+/**
+ * The model resource: identity (code/name) and the model-level lifecycle
+ * (model.create on absence, model.update on name drift, model.delete when the
+ * intent declares the model `absent:true`). It is the root of the capability
+ * graph — everything else requires the model to exist.
+ */
+export const modelCapability = {
+    id: "model",
+    title: "业务模型",
+    requires: [],
+    operations: ["create", "update", "delete"],
+    validate(node, draft, ctx) {
+        for (const entry of node.entries) {
+            if (!MODEL_KEYS.has(entry.key))
+                pushError(ctx, "intent-key-unknown", `模型不支持键 "${entry.key}"（只接受 code / name / absent / fields / form / listview / rules / datarules / workflow / onlinejs）`, `${ctx.base}.${entry.key}`);
+        }
+        const codeNode = node.entries.find((entry) => entry.key === "code")?.value;
+        const nameNode = node.entries.find((entry) => entry.key === "name")?.value;
+        const absentNode = node.entries.find((entry) => entry.key === "absent")?.value;
+        if (!isScalarString(codeNode))
+            pushError(ctx, "intent-model-code-invalid", "模型 code 必须是非空字符串", `${ctx.base}.code`, "value");
+        const code = isScalarString(codeNode) ? codeNode.value.trim() : "";
+        let codeValid = code.length > 0;
+        if (code.length > 0) {
+            const violations = validateBusinessCode(code, { kind: "model" });
+            codeValid = violations.length === 0;
+            if (violations.length > 0)
+                pushError(ctx, "intent-model-code-invalid", `模型 code 未过出门前校验（长度/风格/保留字）：${violations.map((violation) => violation.message).join("；")}`, `${ctx.base}.code`, "value", { validation: violations });
+            if (ctx.seenModelCodes.has(code))
+                pushError(ctx, "intent-model-code-duplicate", `模型 code 重复：${code}`, `${ctx.base}.code`, "value");
+            ctx.seenModelCodes.add(code);
+        }
+        if (absentNode !== undefined && (absentNode.kind !== "scalar" || typeof absentNode.value !== "boolean"))
+            pushError(ctx, "intent-model-absent-invalid", "模型 absent 必须是布尔", `${ctx.base}.absent`, "value");
+        const absent = absentNode?.kind === "scalar" && absentNode.value === true;
+        if (absent) {
+            // A declared-absent model is a deletion target: nothing about its shape is
+            // meaningful, so refuse shape declarations rather than silently ignoring
+            // them (a half-ignored field list would mislead the plan reader).
+            for (const key of PRESENT_ONLY_KEYS) {
+                if (node.entries.some((entry) => entry.key === key))
+                    pushError(ctx, "intent-model-absent-with-shape", `模型声明 absent:true 表示删除该模型，不能再声明 ${key}（模型及其字段/表单/规则随删除一并消失）`, `${ctx.base}.${key}`);
+            }
+        }
+        else if (!isScalarString(nameNode)) {
+            pushError(ctx, "intent-model-name-invalid", "模型 name 必须是非空字符串", `${ctx.base}.name`, "value");
+        }
+        draft.code = code;
+        draft.name = isScalarString(nameNode) ? nameNode.value : "";
+        if (absent)
+            draft.absent = true;
+        // An invalid identity fails the whole file anyway (errors throw); marking it
+        // here keeps "model omitted" consistent with "model has no valid identity".
+        draft.identityValid = codeValid && (absent || isScalarString(nameNode));
+    },
+    async read() {
+        // The model slot's identity (present/name) is resolved by the baseline
+        // assembler's tree scan, which also yields the ownership note.
+    },
+    plan(intent, baseline, emit) {
+        if (intent.absent === true) {
+            if (baseline.present)
+                emit.change("model.delete", { schemaCode: intent.code }, `model:${intent.code}`, "model-declared-absent");
+            else
+                emit.skip(`model:${intent.code}`, "model-already-absent");
+            return;
+        }
+        if (!baseline.present) {
+            emit.change("model.create", { name: intent.name, code: intent.code }, `model:${intent.code}`, "model-absent");
+            return;
+        }
+        emit.skip(`model:${intent.code}`, "model-present");
+        if (baseline.name !== null && baseline.name !== intent.name)
+            emit.change("model.update", { schemaCode: intent.code, name: intent.name }, `model:${intent.code}`, "model-name-drift");
+    },
+    decode() {
+        // Identity (code/name/present) is carried straight from the baseline by the
+        // readback assembler; the model capability contributes no decode slice.
+    },
+    compare(intent, live, emit) {
+        if (intent.absent === true) {
+            if (live.present)
+                emit.difference("model-present-unexpected", `model:${intent.code}`, `模型 ${intent.code} 声明 absent:true 但仍存在`);
+            return;
+        }
+        if (!live.present) {
+            emit.difference("model-missing", `model:${intent.code}`, `模型 ${intent.code} 不存在`);
+            return;
+        }
+        if (live.name !== null && live.name !== intent.name)
+            emit.difference("model-name-mismatch", `model:${intent.code}`, `模型名 live=${live.name} intent=${intent.name}`);
+    },
+};
+//# sourceMappingURL=model.js.map

package/dist/intent/capabilities/onlinejs.js

@@ -0,0 +1,108 @@
+import { ENDPOINTS } from "../../endpoints.js";
+import { wireCall, WireError } from "../../wire.js";
+import { isScalarString, pushError } from "../validation.js";
+const ONLINEJS_KEYS = new Set(["sheetCode", "source", "replace", "publish"]);
+function extractCustomScript(raw) {
+    if (typeof raw !== "string" || raw.trim() === "")
+        return "";
+    try {
+        const elements = JSON.parse(raw);
+        if (!Array.isArray(elements))
+            return "";
+        const script = elements.find((element) => element && typeof element === "object" && element.id === "customScript");
+        return typeof script?.innerHTML === "string" ? script.innerHTML : "";
+    }
+    catch {
+        return "";
+    }
+}
+export const onlinejsCapability = {
+    id: "onlinejs",
+    title: "表单在线 JS",
+    requires: ["form"],
+    operations: ["compose"],
+    validate(node, draft, ctx) {
+        const jsNode = node.entries.find((entry) => entry.key === "onlinejs")?.value;
+        if (jsNode === undefined || (jsNode.kind === "scalar" && jsNode.value === null))
+            return;
+        if (jsNode.kind !== "map") {
+            pushError(ctx, "intent-onlinejs-not-a-map", "onlinejs 必须是映射", `${ctx.base}.onlinejs`, "value");
+            return;
+        }
+        for (const entry of jsNode.entries)
+            if (!ONLINEJS_KEYS.has(entry.key))
+                pushError(ctx, "intent-key-unknown", `onlinejs 不支持键 "${entry.key}"（只接受 sheetCode / source / replace / publish）`, `${ctx.base}.onlinejs.${entry.key}`);
+        const sheetNode = jsNode.entries.find((entry) => entry.key === "sheetCode")?.value;
+        const sourceNode = jsNode.entries.find((entry) => entry.key === "source")?.value;
+        const replaceNode = jsNode.entries.find((entry) => entry.key === "replace")?.value;
+        const publishNode = jsNode.entries.find((entry) => entry.key === "publish")?.value;
+        if (sheetNode !== undefined && (!isScalarString(sheetNode) || sheetNode.value.trim().length === 0))
+            pushError(ctx, "intent-onlinejs-sheet-invalid", "onlinejs.sheetCode 必须是非空字符串", `${ctx.base}.onlinejs.sheetCode`, "value");
+        if (!isScalarString(sourceNode) || sourceNode.value.trim().length === 0)
+            pushError(ctx, "intent-onlinejs-source-invalid", "onlinejs.source 必须是非空字符串", `${ctx.base}.onlinejs.source`, "value");
+        if (replaceNode !== undefined && (replaceNode.kind !== "scalar" || typeof replaceNode.value !== "boolean"))
+            pushError(ctx, "intent-onlinejs-replace-invalid", "onlinejs.replace 必须是布尔", `${ctx.base}.onlinejs.replace`, "value");
+        if (publishNode === undefined || publishNode.kind !== "scalar" || typeof publishNode.value !== "boolean")
+            pushError(ctx, "intent-onlinejs-publish-invalid", "onlinejs.publish 必须是布尔", `${ctx.base}.onlinejs.publish`, "value");
+        if (isScalarString(sourceNode) && publishNode?.kind === "scalar" && typeof publishNode.value === "boolean") {
+            draft.onlinejs = {
+                ...(isScalarString(sheetNode) ? { sheetCode: sheetNode.value.trim() } : {}),
+                source: sourceNode.value.trim(),
+                ...(replaceNode?.kind === "scalar" && typeof replaceNode.value === "boolean" ? { replace: replaceNode.value } : {}),
+                publish: publishNode.value,
+            };
+        }
+    },
+    async read(session, intent, draft) {
+        const onlinejs = intent.onlinejs;
+        if (!onlinejs)
+            return;
+        const sheetCode = onlinejs.sheetCode ?? intent.code;
+        let result = null;
+        try {
+            result = (await wireCall(session, { path: ENDPOINTS.sheetGet, query: { schemaCode: draft.code, sheetCode } })).data;
+        }
+        catch (error) {
+            if (!(error instanceof WireError && error.kind === "business" && (error.errcode === 302024 || error.errcode === 401001)))
+                throw error;
+        }
+        const publishedSource = extractCustomScript(result?.publishedHtmlJson);
+        const draftSource = extractCustomScript(result?.draftHtmlJson);
+        draft.onlinejs = { present: result !== null, published: result?.published === true, source: onlinejs.publish ? publishedSource : draftSource };
+    },
+    plan(intent, baseline, emit) {
+        const onlinejs = intent.onlinejs;
+        if (!onlinejs)
+            return;
+        const sheetCode = onlinejs.sheetCode ?? intent.code;
+        const current = baseline.onlinejs;
+        const sourceSatisfied = current?.present === true && (onlinejs.replace === true ? current.source === onlinejs.source : current.source.includes(onlinejs.source));
+        const resource = `onlinejs:${intent.code}.${sheetCode}`;
+        if (!sourceSatisfied || (onlinejs.publish && current?.published !== true)) {
+            emit.change("onlinejs.compose", { schemaCode: intent.code, sheetCode, source: onlinejs.source, ...(onlinejs.replace !== undefined ? { replace: onlinejs.replace } : {}), publish: onlinejs.publish }, resource, current?.present === true ? "onlinejs-source-drift" : "onlinejs-absent");
+        }
+        else {
+            emit.skip(resource, "onlinejs-present");
+        }
+    },
+    decode(baseline, draft) {
+        if (baseline.onlinejs)
+            draft.onlinejs = { present: baseline.onlinejs.present, published: baseline.onlinejs.published, source: baseline.onlinejs.source };
+    },
+    compare(intent, live, emit) {
+        const onlinejs = intent.onlinejs;
+        if (!onlinejs)
+            return;
+        const current = live.onlinejs;
+        const resource = `onlinejs:${intent.code}.${onlinejs.sheetCode ?? intent.code}`;
+        if (!current?.present) {
+            emit.difference("onlinejs-missing", resource, `表单 ${intent.code} 的在线 JS 不存在`);
+            return;
+        }
+        if (onlinejs.publish && !current.published)
+            emit.difference("onlinejs-not-published", resource, `表单 ${intent.code} 的在线 JS 未发布`);
+        if (onlinejs.replace === true ? current.source !== onlinejs.source : !current.source.includes(onlinejs.source))
+            emit.difference("onlinejs-source-mismatch", resource, `表单 ${intent.code} 的 customScript 不包含声明代码`);
+    },
+};
+//# sourceMappingURL=onlinejs.js.map