@nocobase/flow-engine 3.0.0-alpha.7 → 3.0.0-alpha.8

package/lib/components/FlowContextSelector.js

@@ -247,6 +247,7 @@ const FlowContextSelectorComponent = /* @__PURE__ */ __name(({
   }, [active, cascaderProps.disabled, currentPath]);
   const handleChange = (0, import_react.useCallback)(
     (selectedValues, selectedOptions) => {
+      var _a;
       const lastOption = selectedOptions == null ? void 0 : selectedOptions[selectedOptions.length - 1];
       if (!selectedValues || selectedValues.length === 0) {
         onChange == null ? void 0 : onChange("", lastOption == null ? void 0 : lastOption.meta);
@@ -256,6 +257,7 @@ const FlowContextSelectorComponent = /* @__PURE__ */ __name(({
       const path = selectedValues.map(String);
       const pathString = path.join(".");
       const isLeaf = lastOption == null ? void 0 : lastOption.isLeaf;
+      const isSelectable = ((_a = lastOption == null ? void 0 : lastOption.meta) == null ? void 0 : _a.selectable) !== false;
       const now = Date.now();
       let formattedValue;
       if (customFormatPathToValue) {
@@ -267,12 +269,16 @@ const FlowContextSelectorComponent = /* @__PURE__ */ __name(({
         formattedValue = (0, import_utils.formatPathToValue)(lastOption == null ? void 0 : lastOption.meta);
       }
       if (isLeaf) {
+        if (!isSelectable) {
+          setTempSelectedPath(path);
+          return;
+        }
         onChange == null ? void 0 : onChange(formattedValue, lastOption == null ? void 0 : lastOption.meta);
         setTempSelectedPath([]);
         return;
       }
       const lastSelected = lastSelectedRef.current;
-      const isDoubleClick = !onlyLeafSelectable && (lastSelected == null ? void 0 : lastSelected.path) === pathString && now - lastSelected.time < 300;
+      const isDoubleClick = isSelectable && !onlyLeafSelectable && (lastSelected == null ? void 0 : lastSelected.path) === pathString && now - lastSelected.time < 300;
       if (isDoubleClick) {
         onChange == null ? void 0 : onChange(formattedValue, lastOption == null ? void 0 : lastOption.meta);
         lastSelectedRef.current = null;

package/lib/flowContext.d.ts

@@ -27,6 +27,9 @@ import type { RecordRef } from './utils/serverContextParams';
 import { FlowView, FlowViewer } from './views/FlowView';
 import { type RunJSVersion } from './runjs-context/registry';
 type Getter<T = any> = (ctx: FlowContext) => T | Promise<T>;
+export type ResolveJsonTemplateOptions = {
+    contractModelUid?: string | number | null;
+};
 export type FlowContextDocRef = string | {
     url: string;
     title?: string;
@@ -77,6 +80,7 @@ export interface MetaTreeNode {
     hidden?: boolean | (() => boolean);
     disabled?: boolean | (() => boolean);
     disabledReason?: string | (() => string | undefined);
+    selectable?: boolean;
     children?: MetaTreeNode[] | (() => Promise<MetaTreeNode[]>);
 }
 export interface PropertyMeta {
@@ -343,7 +347,7 @@ declare class BaseFlowEngineContext extends FlowContext {
      * @deprecated use `resolveJsonTemplate` instead
      */
     renderJson: (template: JSONValue) => Promise<any>;
-    resolveJsonTemplate: (template: JSONValue) => Promise<any>;
+    resolveJsonTemplate: (template: JSONValue, options?: ResolveJsonTemplateOptions) => Promise<any>;
     getVar: (path: string) => Promise<any>;
     request: (options: RequestOptions) => Promise<any>;
     runjs: (code: string, variables?: Record<string, any>, options?: JSRunnerOptions) => Promise<any>;

package/lib/flowContext.js

@@ -2383,7 +2383,7 @@ const _FlowEngineContext = class _FlowEngineContext extends BaseFlowEngineContex
     this.defineMethod("renderJson", function(template) {
       return this.resolveJsonTemplate(template);
     });
-    this.defineMethod("resolveJsonTemplate", async function(template) {
+    const resolveJsonTemplate = /* @__PURE__ */ __name(async function(template, options) {
       var _a, _b, _c;
       const used = (0, import_utils.extractUsedVariablePaths)(template);
       const usedVarNames = Object.keys(used || {});
@@ -2516,7 +2516,12 @@ const _FlowEngineContext = class _FlowEngineContext extends BaseFlowEngineContex
         }
         if (this.api) {
           try {
+            const contractRd = (0, import_params_resolvers.buildFlowModelResolveDescriptor)(
+              this,
+              options == null ? void 0 : options.contractModelUid
+            );
             serverResolved = await (0, import_params_resolvers.enqueueVariablesResolve)(this, {
+              ...contractRd ? { contractRd } : {},
               rd: (0, import_params_resolvers.buildFlowModelResolveDescriptor)(this, (_a = this.model) == null ? void 0 : _a.uid),
               template,
               contextParams: autoContextParams || {}
@@ -2528,7 +2533,8 @@ const _FlowEngineContext = class _FlowEngineContext extends BaseFlowEngineContex
         }
       }
       return (0, import_utils.resolveExpressions)(serverResolved, this);
-    });
+    }, "resolveJsonTemplate");
+    this.defineMethod("resolveJsonTemplate", resolveJsonTemplate);
     this.defineMethod(
       "getVar",
       async function(varPath) {

package/lib/utils/dateVariable.d.ts

@@ -6,11 +6,33 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
+declare const PRESET_KEY_LIST: readonly ["today", "now", "yesterday", "tomorrow", "thisWeek", "lastWeek", "nextWeek", "thisMonth", "lastMonth", "nextMonth", "thisQuarter", "lastQuarter", "nextQuarter", "thisYear", "lastYear", "nextYear"];
+export type CtxDatePreset = (typeof PRESET_KEY_LIST)[number];
+export type CtxDateRelativeDirection = 'next' | 'past';
+export type CtxDateRelativeUnit = 'day' | 'week' | 'month' | 'year';
+export type CtxDateExpressionConfig = {
+    kind: 'exact';
+    value: string | [string, string];
+    format?: string;
+} | {
+    kind: 'relative';
+    direction: CtxDateRelativeDirection;
+    amount: number;
+    unit: CtxDateRelativeUnit;
+    format?: string;
+} | {
+    kind: 'preset';
+    preset: CtxDatePreset;
+    format?: string;
+};
 export declare function isCtxDatePathPrefix(pathSegments: string[]): boolean;
 export declare function encodeBase64Url(input: string): string;
 export declare function decodeBase64Url(input: string): string | undefined;
 export declare function isCtxDateExpression(value: unknown): value is string;
 export declare function isCompleteCtxDatePath(pathSegments: string[]): boolean;
 export declare function parseCtxDateExpression(value: unknown): any;
+export declare function parseCtxDateExpressionConfig(value: unknown): CtxDateExpressionConfig | undefined;
+export declare function serializeCtxDateExpressionConfig(config: CtxDateExpressionConfig): string | undefined;
 export declare function serializeCtxDateValue(value: unknown): string | undefined;
 export declare function resolveCtxDatePath(pathSegments: string[]): any;
+export {};

package/lib/utils/dateVariable.js

@@ -43,13 +43,15 @@ __export(dateVariable_exports, {
   isCtxDateExpression: () => isCtxDateExpression,
   isCtxDatePathPrefix: () => isCtxDatePathPrefix,
   parseCtxDateExpression: () => parseCtxDateExpression,
+  parseCtxDateExpressionConfig: () => parseCtxDateExpressionConfig,
   resolveCtxDatePath: () => resolveCtxDatePath,
+  serializeCtxDateExpressionConfig: () => serializeCtxDateExpressionConfig,
   serializeCtxDateValue: () => serializeCtxDateValue
 });
 module.exports = __toCommonJS(dateVariable_exports);
 var import_dayjs = __toESM(require("dayjs"));
 const CTX_DATE_REGEX = /^\{\{\s*ctx\.date(?:\.(.+?))?\s*\}\}$/;
-const PRESET_KEYS = /* @__PURE__ */ new Set([
+const PRESET_KEY_LIST = [
   "today",
   "now",
   "yesterday",
@@ -66,9 +68,11 @@ const PRESET_KEYS = /* @__PURE__ */ new Set([
   "thisYear",
   "lastYear",
   "nextYear"
-]);
+];
+const PRESET_KEYS = new Set(PRESET_KEY_LIST);
 const RELATIVE_DIRECTIONS = /* @__PURE__ */ new Set(["next", "past"]);
 const RELATIVE_UNITS = /* @__PURE__ */ new Set(["day", "week", "month", "year"]);
+const MAX_DATE_FORMAT_LENGTH = 128;
 function parseCtxDateSegments(value) {
   if (typeof value !== "string") return null;
   const trimmed = value.trim();
@@ -79,8 +83,7 @@ function parseCtxDateSegments(value) {
   return rawPath.split(".").map((seg) => seg.trim()).filter(Boolean);
 }
 __name(parseCtxDateSegments, "parseCtxDateSegments");
-function isCtxDatePathPrefix(pathSegments) {
-  const segments = withDatePrefix((pathSegments || []).map((seg) => String(seg)));
+function isBaseCtxDatePathPrefix(segments) {
   if (segments[0] !== "date") return false;
   if (segments.length === 1) return true;
   if (segments[1] === "preset") {
@@ -117,6 +120,34 @@ function isCtxDatePathPrefix(pathSegments) {
   }
   return false;
 }
+__name(isBaseCtxDatePathPrefix, "isBaseCtxDatePathPrefix");
+function decodeFormatToken(token) {
+  const raw = String(token || "");
+  if (!raw.startsWith("v")) return void 0;
+  const decoded = decodeBase64Url(raw.slice(1));
+  if (!decoded || decoded.length > MAX_DATE_FORMAT_LENGTH) return void 0;
+  return decoded;
+}
+__name(decodeFormatToken, "decodeFormatToken");
+function splitFormattedDateSegments(segments) {
+  if (segments[0] !== "date") return null;
+  if (segments[1] !== "format") return { baseSegments: segments };
+  if (segments.length < 4) return null;
+  const format = decodeFormatToken(segments[2]);
+  if (!format) return null;
+  return { baseSegments: ["date", ...segments.slice(3)], format };
+}
+__name(splitFormattedDateSegments, "splitFormattedDateSegments");
+function isCtxDatePathPrefix(pathSegments) {
+  const segments = withDatePrefix((pathSegments || []).map((seg) => String(seg)));
+  if (segments[0] !== "date") return false;
+  if (segments.length === 1) return true;
+  if (segments[1] !== "format") return isBaseCtxDatePathPrefix(segments);
+  if (segments.length === 2) return true;
+  if (segments.length === 3) return typeof decodeFormatToken(segments[2]) === "string";
+  const formatted = splitFormattedDateSegments(segments);
+  return formatted ? isBaseCtxDatePathPrefix(formatted.baseSegments) : false;
+}
 __name(isCtxDatePathPrefix, "isCtxDatePathPrefix");
 function withDatePrefix(pathSegments) {
   if (pathSegments[0] === "date") {
@@ -225,26 +256,31 @@ __name(isCtxDateExpression, "isCtxDateExpression");
 function isCompleteCtxDatePath(pathSegments) {
   if (!isCtxDatePathPrefix(pathSegments)) return false;
   const segments = withDatePrefix((pathSegments || []).map((seg) => String(seg)));
-  if (segments[0] !== "date") return false;
-  if (segments[1] === "preset") {
-    return segments.length === 3 && PRESET_KEYS.has(segments[2]);
+  const formatted = splitFormattedDateSegments(segments);
+  if (!formatted) return false;
+  const baseSegments = formatted.baseSegments;
+  if (baseSegments[1] === "preset") {
+    return baseSegments.length === 3 && PRESET_KEYS.has(baseSegments[2]);
   }
-  if (segments[1] === "relative") {
-    if (segments.length !== 5) return false;
-    return RELATIVE_DIRECTIONS.has(segments[2]) && RELATIVE_UNITS.has(segments[3]) && typeof parseNumberToken(segments[4]) === "number";
+  if (baseSegments[1] === "relative") {
+    if (baseSegments.length !== 5) return false;
+    return RELATIVE_DIRECTIONS.has(baseSegments[2]) && RELATIVE_UNITS.has(baseSegments[3]) && typeof parseNumberToken(baseSegments[4]) === "number";
   }
-  if (segments[1] === "exact" && segments[2] === "single" && segments[3] === "date") {
-    return segments.length === 5 && /^v.+/.test(segments[4]);
+  if (baseSegments[1] === "exact" && baseSegments[2] === "single" && baseSegments[3] === "date") {
+    return baseSegments.length === 5 && /^v.+/.test(baseSegments[4]);
   }
-  if (segments[1] === "exact" && segments[2] === "range" && segments[3] === "date") {
-    return segments.length === 6 && /^v.+/.test(segments[4]) && /^v.+/.test(segments[5]);
+  if (baseSegments[1] === "exact" && baseSegments[2] === "range" && baseSegments[3] === "date") {
+    return baseSegments.length === 6 && /^v.+/.test(baseSegments[4]) && /^v.+/.test(baseSegments[5]);
   }
   return false;
 }
 __name(isCompleteCtxDatePath, "isCompleteCtxDatePath");
 function parseCtxDateExpression(value) {
   if (!isCtxDateExpression(value)) return void 0;
-  const segments = withDatePrefix(parseCtxDateSegments(value) || []);
+  const rawSegments = withDatePrefix(parseCtxDateSegments(value) || []);
+  const formatted = splitFormattedDateSegments(rawSegments);
+  if (!formatted) return void 0;
+  const segments = formatted.baseSegments;
   if (segments[1] === "preset" && segments.length === 3 && PRESET_KEYS.has(segments[2])) {
     return { type: segments[2] };
   }
@@ -272,6 +308,60 @@ function parseCtxDateExpression(value) {
   return void 0;
 }
 __name(parseCtxDateExpression, "parseCtxDateExpression");
+function parseCtxDateExpressionConfig(value) {
+  if (!isCtxDateExpression(value)) return void 0;
+  const segments = withDatePrefix(parseCtxDateSegments(value) || []);
+  const formatted = splitFormattedDateSegments(segments);
+  if (!formatted) return void 0;
+  const parsed = parseCtxDateExpression(value);
+  const formatConfig = formatted.format ? { format: formatted.format } : {};
+  if (typeof parsed === "string") {
+    return { kind: "exact", value: parsed, ...formatConfig };
+  }
+  if (Array.isArray(parsed) && parsed.length === 2 && typeof parsed[0] === "string" && typeof parsed[1] === "string") {
+    return { kind: "exact", value: [parsed[0], parsed[1]], ...formatConfig };
+  }
+  if (!parsed || typeof parsed !== "object") return void 0;
+  const typed = parsed;
+  if (typed.type === "past" || typed.type === "next") {
+    if (typeof typed.unit !== "string" || !RELATIVE_UNITS.has(typed.unit) || typeof typed.number !== "number") {
+      return void 0;
+    }
+    return {
+      kind: "relative",
+      direction: typed.type,
+      amount: typed.number,
+      unit: typed.unit,
+      ...formatConfig
+    };
+  }
+  if (typeof typed.type === "string" && PRESET_KEYS.has(typed.type)) {
+    return { kind: "preset", preset: typed.type, ...formatConfig };
+  }
+  return void 0;
+}
+__name(parseCtxDateExpressionConfig, "parseCtxDateExpressionConfig");
+function serializeCtxDateExpressionConfig(config) {
+  let legacyValue;
+  if (config.kind === "preset") {
+    if (!PRESET_KEYS.has(config.preset)) return void 0;
+    legacyValue = { type: config.preset };
+  } else if (config.kind === "relative") {
+    if (!RELATIVE_DIRECTIONS.has(config.direction) || !RELATIVE_UNITS.has(config.unit)) return void 0;
+    const amount = Math.floor(Number(config.amount));
+    if (!Number.isFinite(amount) || amount <= 0) return void 0;
+    legacyValue = { type: config.direction, unit: config.unit, number: amount };
+  } else {
+    legacyValue = config.value;
+  }
+  const expression = serializeCtxDateValue(legacyValue);
+  if (!expression || !config.format) return expression;
+  const format = String(config.format);
+  if (!format.trim() || format.length > MAX_DATE_FORMAT_LENGTH) return void 0;
+  const segments = withDatePrefix(parseCtxDateSegments(expression) || []);
+  return toCtxDateExpression(["date", "format", `v${encodeBase64Url(format)}`, ...segments.slice(1)]);
+}
+__name(serializeCtxDateExpressionConfig, "serializeCtxDateExpressionConfig");
 function serializeCtxDateValue(value) {
   if (isCtxDateExpression(value)) {
     return String(value).trim();
@@ -317,8 +407,23 @@ function serializeCtxDateValue(value) {
   return void 0;
 }
 __name(serializeCtxDateValue, "serializeCtxDateValue");
+function formatResolvedDateValue(value, format) {
+  const formatValue = /* @__PURE__ */ __name((item) => {
+    if (typeof item !== "string") return item;
+    const parsed = (0, import_dayjs.default)(item);
+    return parsed.isValid() ? parsed.format(format) : item;
+  }, "formatValue");
+  return Array.isArray(value) ? value.map(formatValue) : formatValue(value);
+}
+__name(formatResolvedDateValue, "formatResolvedDateValue");
 function resolveCtxDatePath(pathSegments) {
-  const segments = withDatePrefix((pathSegments || []).map((seg) => String(seg)));
+  const rawSegments = withDatePrefix((pathSegments || []).map((seg) => String(seg)));
+  const formatted = splitFormattedDateSegments(rawSegments);
+  if (!formatted) return void 0;
+  if (formatted.format) {
+    return formatResolvedDateValue(resolveCtxDatePath(formatted.baseSegments), formatted.format);
+  }
+  const segments = formatted.baseSegments;
   if (segments[0] !== "date") return void 0;
   if (segments[1] === "preset" && segments.length === 3) {
     const key = segments[2];
@@ -375,6 +480,8 @@ __name(resolveCtxDatePath, "resolveCtxDatePath");
   isCtxDateExpression,
   isCtxDatePathPrefix,
   parseCtxDateExpression,
+  parseCtxDateExpressionConfig,
   resolveCtxDatePath,
+  serializeCtxDateExpressionConfig,
   serializeCtxDateValue
 });

package/lib/utils/index.d.ts

@@ -21,7 +21,7 @@ export { extractPropertyPath, formatPathToVariable, isVariableExpression } from
 export { clearAutoFlowError, getAutoFlowError, setAutoFlowError, type AutoFlowError } from './autoFlowError';
 export { parsePathnameToViewParams, type ViewParam } from './parsePathnameToViewParams';
 export { createOpenViewRouteState, decodeOpenViewRouteState, encodeOpenViewRouteState, isOpenViewRouteStateToken, RUNJS_OPEN_VIEW_ROUTE_STATE, type OpenViewRouteMode, type OpenViewRouteSize, type OpenViewRouteState, } from './openViewRouteState';
-export { decodeBase64Url, encodeBase64Url, isCompleteCtxDatePath, isCtxDatePathPrefix, isCtxDateExpression, parseCtxDateExpression, resolveCtxDatePath, serializeCtxDateValue, } from './dateVariable';
+export { decodeBase64Url, encodeBase64Url, isCompleteCtxDatePath, isCtxDatePathPrefix, isCtxDateExpression, parseCtxDateExpression, parseCtxDateExpressionConfig, resolveCtxDatePath, serializeCtxDateExpressionConfig, serializeCtxDateValue, type CtxDateExpressionConfig, type CtxDatePreset, type CtxDateRelativeDirection, type CtxDateRelativeUnit, } from './dateVariable';
 export { isRunJSValue, normalizeRunJSValue, extractUsedVariablePathsFromRunJS, type RunJSValue } from './runjsValue';
 export { resolveRunJSObjectValues } from './resolveRunJSObjectValues';
 export { prepareRunJsCode, preprocessRunJsTemplates } from './runjsTemplateCompat';

package/lib/utils/index.js

@@ -73,6 +73,7 @@ __export(utils_exports, {
   isVariableExpression: () => import_context.isVariableExpression,
   normalizeRunJSValue: () => import_runjsValue.normalizeRunJSValue,
   parseCtxDateExpression: () => import_dateVariable.parseCtxDateExpression,
+  parseCtxDateExpressionConfig: () => import_dateVariable.parseCtxDateExpressionConfig,
   parsePathnameToViewParams: () => import_parsePathnameToViewParams.parsePathnameToViewParams,
   prepareRunJsCode: () => import_runjsTemplateCompat.prepareRunJsCode,
   preprocessRunJsTemplates: () => import_runjsTemplateCompat.preprocessRunJsTemplates,
@@ -87,6 +88,7 @@ __export(utils_exports, {
   resolveStepDisabledInSettings: () => import_schema_utils.resolveStepDisabledInSettings,
   resolveStepUiSchema: () => import_schema_utils.resolveStepUiSchema,
   resolveUiMode: () => import_schema_utils.resolveUiMode,
+  serializeCtxDateExpressionConfig: () => import_dateVariable.serializeCtxDateExpressionConfig,
   serializeCtxDateValue: () => import_dateVariable.serializeCtxDateValue,
   setAutoFlowError: () => import_autoFlowError.setAutoFlowError,
   setupRuntimeContextSteps: () => import_setupRuntimeContextSteps.setupRuntimeContextSteps,
@@ -168,6 +170,7 @@ var import_randomId = require("./randomId");
   isVariableExpression,
   normalizeRunJSValue,
   parseCtxDateExpression,
+  parseCtxDateExpressionConfig,
   parsePathnameToViewParams,
   prepareRunJsCode,
   preprocessRunJsTemplates,
@@ -182,6 +185,7 @@ var import_randomId = require("./randomId");
   resolveStepDisabledInSettings,
   resolveStepUiSchema,
   resolveUiMode,
+  serializeCtxDateExpressionConfig,
   serializeCtxDateValue,
   setAutoFlowError,
   setupRuntimeContextSteps,

package/lib/utils/params-resolvers.d.ts

@@ -27,6 +27,7 @@ export type JSONValue = string | {
     [key: string]: JSONValue;
 } | JSONValue[];
 type BatchPayload = {
+    contractRd?: string;
     rd?: string;
     template: JSONValue;
     contextParams?: ServerContextParams | undefined;

package/lib/utils/params-resolvers.js

@@ -146,6 +146,7 @@ function enqueueVariablesResolve(ctx, payload) {
     try {
       const batch = items.map((it) => ({
         id: it.id,
+        contractRd: it.payload.contractRd,
         rd: it.payload.rd,
         template: it.payload.template,
         contextParams: it.payload.contextParams || {}

package/lib/views/createViewMeta.d.ts

@@ -28,6 +28,7 @@ interface PopupNodeResource {
 interface PopupNode {
     uid?: string;
     resource: PopupNodeResource;
+    sourceRecord?: unknown;
     parent?: PopupNode;
 }
 export declare function buildPopupRuntime(ctx: FlowContext, view: FlowView): Promise<PopupNode | undefined>;

package/lib/views/createViewMeta.js

@@ -428,10 +428,11 @@ function createPopupMeta(ctx, anchorView) {
 }
 __name(createPopupMeta, "createPopupMeta");
 async function buildPopupRuntime(ctx, view) {
-  var _a;
+  var _a, _b, _c;
   const stack = getViewStack(view);
   const currentIndex = getAnchoredViewStackIndex(view, stack);
-  const openerUids = (_a = view == null ? void 0 : view.inputArgs) == null ? void 0 : _a.openerUids;
+  const sourceRecord = (_b = (_a = view == null ? void 0 : view.inputArgs) == null ? void 0 : _a.parentItem) == null ? void 0 : _b.value;
+  const openerUids = (_c = view == null ? void 0 : view.inputArgs) == null ? void 0 : _c.openerUids;
   const hasOpener = Array.isArray(openerUids) && openerUids.length > 0;
   const hasStackPopup = currentIndex >= 1;
   const isPopup = hasStackPopup || hasOpener;
@@ -448,16 +449,17 @@ async function buildPopupRuntime(ctx, view) {
         associationName: args.associationName,
         filterByTk: args.filterByTk,
         sourceId: args.sourceId
-      }
+      },
+      ...typeof sourceRecord !== "undefined" ? { sourceRecord } : {}
     };
   }
   const buildNode = /* @__PURE__ */ __name(async (idx) => {
-    var _a2, _b, _c, _d, _e, _f;
+    var _a2, _b2, _c2, _d, _e, _f;
     if (idx < 0 || !((_a2 = stack[idx]) == null ? void 0 : _a2.viewUid)) return void 0;
     const viewUid = stack[idx].viewUid;
-    let model = (_b = ctx.engine) == null ? void 0 : _b.getModel(viewUid, true);
+    let model = (_b2 = ctx.engine) == null ? void 0 : _b2.getModel(viewUid, true);
     if (!model) {
-      model = await ((_c = ctx.engine) == null ? void 0 : _c.loadModel({ uid: viewUid }));
+      model = await ((_c2 = ctx.engine) == null ? void 0 : _c2.loadModel({ uid: viewUid }));
     }
     const p = ((_d = model == null ? void 0 : model.getStepParams) == null ? void 0 : _d.call(model, "popupSettings", "openView")) || {};
     const collectionName = p == null ? void 0 : p.collectionName;
@@ -477,16 +479,43 @@ async function buildPopupRuntime(ctx, view) {
     return node;
   }, "buildNode");
   const currentNode = await buildNode(currentIndex);
+  if (currentNode && typeof sourceRecord !== "undefined") {
+    currentNode.sourceRecord = sourceRecord;
+  }
   return currentNode;
 }
 __name(buildPopupRuntime, "buildPopupRuntime");
 function registerPopupVariable(ctx, view) {
   const POPUP_SERVER_PATH_RE = /^(?:record|sourceRecord)(?:\.|$)|^parent(?:\.parent)*(?:\.(?:record|sourceRecord))(?:\.|$)/;
+  const shouldResolveSourceRecordOnServer = /* @__PURE__ */ __name((path) => {
+    var _a, _b;
+    if (path !== "sourceRecord" && !path.startsWith("sourceRecord.")) return false;
+    const parentItem = (_a = view == null ? void 0 : view.inputArgs) == null ? void 0 : _a.parentItem;
+    if (typeof (parentItem == null ? void 0 : parentItem.value) === "undefined") return true;
+    const sourcePath = path === "sourceRecord" ? "" : path.slice("sourceRecord.".length);
+    if (!sourcePath) return false;
+    const parentItemResolver = (_b = view == null ? void 0 : view.inputArgs) == null ? void 0 : _b.parentItemResolver;
+    if (typeof parentItemResolver === "function") {
+      return parentItemResolver(`value.${sourcePath}`);
+    }
+    const segments = sourcePath.split(".").filter(Boolean);
+    let current = parentItem.value;
+    for (const segment of segments) {
+      if (current === null || typeof current !== "object" || !(segment in current)) {
+        return true;
+      }
+      current = current[segment];
+    }
+    return false;
+  }, "shouldResolveSourceRecordOnServer");
   ctx.defineProperty("popup", {
     get: /* @__PURE__ */ __name(async () => buildPopupRuntime(ctx, view), "get"),
     meta: createPopupMeta(ctx, view),
     resolveOnServer: /* @__PURE__ */ __name((p) => {
       try {
+        if (p === "sourceRecord" || p.startsWith("sourceRecord.")) {
+          return shouldResolveSourceRecordOnServer(p);
+        }
         return !!p && POPUP_SERVER_PATH_RE.test(p);
       } catch (_) {
         return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/flow-engine",
-  "version": "3.0.0-alpha.7",
+  "version": "3.0.0-alpha.8",
   "private": false,
   "description": "A standalone flow engine for NocoBase, managing workflows, models, and actions.",
   "main": "lib/index.js",
@@ -8,8 +8,8 @@
   "dependencies": {
     "@formily/antd-v5": "1.x",
     "@formily/reactive": "2.x",
-    "@nocobase/sdk": "3.0.0-alpha.7",
-    "@nocobase/shared": "3.0.0-alpha.7",
+    "@nocobase/sdk": "3.0.0-alpha.8",
+    "@nocobase/shared": "3.0.0-alpha.8",
     "ahooks": "^3.7.2",
     "axios": "^1.7.0",
     "dayjs": "^1.11.9",
@@ -37,5 +37,5 @@
   ],
   "author": "NocoBase Team",
   "license": "Apache-2.0",
-  "gitHead": "19cd28c710f3b3c614ebe2fd7d5a415d527ee559"
+  "gitHead": "ce017f3deb8b2414c6b13818042c4187270d1d8a"
 }

package/src/__tests__/createViewMeta.popup.test.ts

@@ -11,7 +11,7 @@ import { describe, it, expect, vi } from 'vitest';
 import { FlowContext } from '../flowContext';
 import { FlowEngine } from '../flowEngine';
 import type { FlowView } from '../views/FlowView';
-import { buildPopupRuntime, createPopupMeta } from '../views/createViewMeta';
+import { buildPopupRuntime, createPopupMeta, registerPopupVariable } from '../views/createViewMeta';
 
 describe('createPopupMeta - popup variables', () => {
   function makeCtx() {
@@ -167,6 +167,7 @@ describe('createPopupMeta - popup variables', () => {
   it('buildPopupRuntime anchors current popup even when the navigation stack already has a child popup', async () => {
     const { engine, ctx } = makeCtx();
     const parentView = makeNestedPopupView('parent-popup-uid', 13);
+    parentView.inputArgs.parentItem = { value: { id: 13, phone: '9999' } };
     mockNestedPopupModels(engine);
 
     const popup = await buildPopupRuntime(ctx, parentView);
@@ -179,6 +180,7 @@ describe('createPopupMeta - popup variables', () => {
       filterByTk: 13,
       sourceId: 13,
     });
+    expect(popup?.sourceRecord).toEqual({ id: 13, phone: '9999' });
   });
 
   it('buildVariablesParams(record) keeps the parent view record when a child popup is open', async () => {
@@ -314,4 +316,85 @@ describe('createPopupMeta - popup variables', () => {
     const props = typeof meta.properties === 'function' ? await (meta.properties as any)() : meta.properties || {};
     expect(props.record).toBeUndefined();
   });
+
+  it('uses the current parent item value for popup sourceRecord fields', async () => {
+    const { ctx } = makeCtx();
+    const parentItemResolver = vi.fn(() => false);
+    const anchorView: FlowView = {
+      type: 'dialog',
+      inputArgs: {
+        openerUids: ['opener-uid-1'],
+        viewUid: 'popup-uid',
+        dataSourceKey: 'main',
+        collectionName: 'roles',
+        associationName: 'users.roles',
+        sourceId: 1,
+        parentItem: { value: { id: 1, phone: '9999' } },
+        parentItemResolver,
+      },
+      Header: null,
+      Footer: null,
+      close: () => void 0,
+      update: () => void 0,
+    } as any;
+
+    registerPopupVariable(ctx, anchorView);
+
+    await expect(ctx.popup).resolves.toMatchObject({
+      sourceRecord: { id: 1, phone: '9999' },
+    });
+    expect(ctx.getPropertyOptions('popup')?.resolveOnServer?.('sourceRecord.phone')).toBe(false);
+    expect(parentItemResolver).toHaveBeenCalledWith('value.phone');
+  });
+
+  it('resolves a popup sourceRecord field from the current parent item without a server request', async () => {
+    const engine = new FlowEngine();
+    const ctx = engine.context;
+    const anchorView: FlowView = {
+      type: 'dialog',
+      inputArgs: {
+        openerUids: ['opener-uid-1'],
+        viewUid: 'popup-uid',
+        dataSourceKey: 'main',
+        collectionName: 'roles',
+        associationName: 'users.roles',
+        sourceId: 1,
+        parentItem: { value: { id: 1, phone: '9999' } },
+        parentItemResolver: () => false,
+      },
+      Header: null,
+      Footer: null,
+      close: () => void 0,
+      update: () => void 0,
+    } as any;
+
+    registerPopupVariable(ctx, anchorView);
+
+    await expect(ctx.resolveJsonTemplate('{{ ctx.popup.sourceRecord.phone }}')).resolves.toBe('9999');
+  });
+
+  it('keeps server resolution for popup sourceRecord association subpaths', async () => {
+    const { ctx } = makeCtx();
+    const anchorView: FlowView = {
+      type: 'dialog',
+      inputArgs: {
+        openerUids: ['opener-uid-1'],
+        viewUid: 'popup-uid',
+        dataSourceKey: 'main',
+        collectionName: 'roles',
+        associationName: 'users.roles',
+        sourceId: 1,
+        parentItem: { value: { id: 1, departmentId: 2 } },
+        parentItemResolver: (path: string) => path === 'value.department.title',
+      },
+      Header: null,
+      Footer: null,
+      close: () => void 0,
+      update: () => void 0,
+    } as any;
+
+    registerPopupVariable(ctx, anchorView);
+
+    expect(ctx.getPropertyOptions('popup')?.resolveOnServer?.('sourceRecord.department.title')).toBe(true);
+  });
 });

package/src/__tests__/flowContext.test.ts

@@ -16,6 +16,7 @@ import { RunJSContextRegistry } from '../runjs-context/registry';
 import { setupRunJSContexts } from '../runjs-context/setup';
 import { createViewScopedEngine } from '../ViewScopedFlowEngine';
 import { DATA_SOURCE_DIRTY_EVENT } from '../views/viewEvents';
+import { serializeCtxDateExpressionConfig } from '../utils/dateVariable';
 
 describe('FlowContext properties and methods', () => {
   it('should return static property value', () => {
@@ -2068,10 +2069,16 @@ describe('getPropertyMetaTree with deep delegate meta', () => {
 describe('FlowContext resolveOnServer selective server resolution', () => {
   it('resolves ctx.date expressions on client context', async () => {
     const engine = new FlowEngine();
+    const formattedToday = serializeCtxDateExpressionConfig({
+      kind: 'preset',
+      preset: 'today',
+      format: 'YYYY/MM/DD',
+    });
     const out = await (engine.context as any).resolveJsonTemplate({
       today: '{{ ctx.date.preset.today }}',
       next12: '{{ ctx.date.relative.next.day.n12 }}',
       now: '{{ ctx.date.preset.now }}',
+      formattedToday,
     });
 
     expect(typeof out.today).toBe('string');
@@ -2080,6 +2087,7 @@ describe('FlowContext resolveOnServer selective server resolution', () => {
     expect(out.next12).toMatch(/^\d{4}-\d{2}-\d{2}$/);
     expect(typeof out.now).toBe('string');
     expect(out.now.length).toBeGreaterThan(0);
+    expect(out.formattedToday).toMatch(/^\d{4}\/\d{2}\/\d{2}$/);
   });
 
   it('does not call server by default (no resolveOnServer set)', async () => {

package/src/__tests__/objectVariable.test.ts

@@ -8,6 +8,7 @@
  */
 
 import { describe, expect, it, vi } from 'vitest';
+import { generateFlowModelRdFromToken } from '@nocobase/utils/client';
 import { FlowContext } from '../flowContext';
 import { FlowEngine } from '../flowEngine';
 import {
@@ -122,7 +123,10 @@ describe('objectVariable utilities', () => {
 
     // Provide API stub to intercept variables:resolve
     const calls: any[] = [];
+    const payload = Buffer.from(JSON.stringify({ userId: 1, signInTime: 'contract-owner-test' })).toString('base64url');
+    const token = `test.${payload}.sig`;
     (ctx as any).api = {
+      auth: { token },
       request: vi.fn(async ({ url, data, method }) => {
         calls.push({ url, data, method });
         const batch = (data?.values?.batch as any[]) || [];
@@ -146,13 +150,14 @@ describe('objectVariable utilities', () => {
     });
 
     const template = { x: '{{ ctx.obj.author.name }}' } as any;
-    await (ctx as any).resolveJsonTemplate(template);
+    await (ctx as any).resolveJsonTemplate(template, { contractModelUid: 'form-grid' });
 
     // Assert variables:resolve was called with proper flattened contextParams
     expect((ctx as any).api.request).toHaveBeenCalled();
     const call = calls.find((c) => c.url === 'variables:resolve');
     expect(call).toBeTruthy();
     const batch0 = call.data?.values?.batch?.[0];
+    expect(batch0?.contractRd).toBe(generateFlowModelRdFromToken('form-grid', token));
     expect(batch0?.contextParams).toBeTruthy();
     // Flattened key should be 'obj.author'
     const cp = batch0.contextParams as Record<string, any>;

package/src/components/FlowContextSelector.tsx

@@ -311,6 +311,7 @@ const FlowContextSelectorComponent: React.FC<FlowContextSelectorProps> = ({
       const path = selectedValues.map(String);
       const pathString = path.join('.');
       const isLeaf = lastOption?.isLeaf;
+      const isSelectable = lastOption?.meta?.selectable !== false;
       const now = Date.now();
 
       // 使用自定义格式化函数或默认函数
@@ -325,6 +326,10 @@ const FlowContextSelectorComponent: React.FC<FlowContextSelectorProps> = ({
       }
 
       if (isLeaf) {
+        if (!isSelectable) {
+          setTempSelectedPath(path);
+          return;
+        }
         onChange?.(formattedValue, lastOption?.meta);
         // 选中叶子节点后，可清空内部临时路径（外部 value 将驱动级联）
         setTempSelectedPath([]);
@@ -333,7 +338,8 @@ const FlowContextSelectorComponent: React.FC<FlowContextSelectorProps> = ({
 
       // 非叶子节点：检查双击
       const lastSelected = lastSelectedRef.current;
-      const isDoubleClick = !onlyLeafSelectable && lastSelected?.path === pathString && now - lastSelected.time < 300;
+      const isDoubleClick =
+        isSelectable && !onlyLeafSelectable && lastSelected?.path === pathString && now - lastSelected.time < 300;
 
       if (isDoubleClick) {
         // 双击：选中非叶子节点

package/src/components/variables/__tests__/FlowContextSelector.test.tsx

@@ -864,4 +864,39 @@ describe('FlowContextSelector', () => {
     // It should only expand the node, not select it
     expect(onChange).not.toHaveBeenCalled();
   });
+
+  it('should expand but never select a node marked selectable=false', async () => {
+    const onChange = vi.fn();
+    const flowContext = createTestFlowContext();
+    const metaTree = [
+      {
+        name: 'date',
+        title: 'Date',
+        type: 'date',
+        paths: ['date'],
+        selectable: false,
+        children: [{ name: 'today', title: 'Today', type: 'date', paths: ['date', 'today'] }],
+      },
+    ];
+
+    render(
+      <TestFlowContextWrapper context={flowContext}>
+        <FlowContextSelector metaTree={metaTree} onChange={onChange} />
+      </TestFlowContextWrapper>,
+    );
+
+    fireEvent.click(screen.getByRole('button'));
+    await waitFor(() => expect(screen.getByText('Date')).toBeInTheDocument());
+
+    fireEvent.click(screen.getByText('Date'));
+    fireEvent.click(screen.getByText('Date'));
+    expect(onChange).not.toHaveBeenCalled();
+
+    await waitFor(() => expect(screen.getByText('Today')).toBeInTheDocument());
+    fireEvent.click(screen.getByText('Today'));
+    expect(onChange).toHaveBeenCalledWith(
+      '{{ ctx.date.today }}',
+      expect.objectContaining({ paths: ['date', 'today'] }),
+    );
+  });
 });

package/src/flowContext.ts

@@ -165,6 +165,10 @@ function inferSelectsFromUsage(paths: string[] = []): { generatedAppends?: strin
 
 type Getter<T = any> = (ctx: FlowContext) => T | Promise<T>;
 
+export type ResolveJsonTemplateOptions = {
+  contractModelUid?: string | number | null;
+};
+
 export type FlowContextDocRef = string | { url: string; title?: string };
 
 export type FlowDeprecationDoc =
@@ -221,6 +225,8 @@ export interface MetaTreeNode {
   // 变量禁用状态与原因（用于变量选择器 UI 展示）
   disabled?: boolean | (() => boolean);
   disabledReason?: string | (() => string | undefined);
+  // 允许节点仅用于展开子级，而不能作为变量值被选中
+  selectable?: boolean;
   children?: MetaTreeNode[] | (() => Promise<MetaTreeNode[]>);
 }
 
@@ -3044,7 +3050,7 @@ class BaseFlowEngineContext extends FlowContext {
    * @deprecated use `resolveJsonTemplate` instead
    */
   declare renderJson: (template: JSONValue) => Promise<any>;
-  declare resolveJsonTemplate: (template: JSONValue) => Promise<any>;
+  declare resolveJsonTemplate: (template: JSONValue, options?: ResolveJsonTemplateOptions) => Promise<any>;
   declare getVar: (path: string) => Promise<any>;
   declare request: (options: RequestOptions) => Promise<any>;
   declare runjs: (code: string, variables?: Record<string, any>, options?: JSRunnerOptions) => Promise<any>;
@@ -3227,7 +3233,11 @@ export class FlowEngineContext extends BaseFlowEngineContext {
     this.defineMethod('renderJson', function (template: any) {
       return this.resolveJsonTemplate(template);
     });
-    this.defineMethod('resolveJsonTemplate', async function (this: BaseFlowEngineContext, template: any) {
+    const resolveJsonTemplate = async function (
+      this: BaseFlowEngineContext,
+      template: any,
+      options?: ResolveJsonTemplateOptions,
+    ) {
       // 提取模板使用到的变量及其子路径
       const used = extractUsedVariablePaths(template);
       const usedVarNames = Object.keys(used || {});
@@ -3396,7 +3406,12 @@ export class FlowEngineContext extends BaseFlowEngineContext {
 
         if (this.api) {
           try {
+            const contractRd = buildFlowModelResolveDescriptor(
+              this as FlowRuntimeContext<FlowModel>,
+              options?.contractModelUid,
+            );
             serverResolved = await enqueueVariablesResolve(this as FlowRuntimeContext<FlowModel>, {
+              ...(contractRd ? { contractRd } : {}),
               rd: buildFlowModelResolveDescriptor(this as FlowRuntimeContext<FlowModel>, this.model?.uid),
               template,
               contextParams: autoContextParams || {},
@@ -3409,7 +3424,8 @@ export class FlowEngineContext extends BaseFlowEngineContext {
       }
 
       return resolveExpressions(serverResolved, this);
-    });
+    };
+    this.defineMethod('resolveJsonTemplate', resolveJsonTemplate);
 
     // Helper: resolve a single ctx expression value via resolveJsonTemplate behavior.
     // Example: await ctx.getVar('ctx.record.id')

package/src/utils/__tests__/dateVariable.test.ts

@@ -12,9 +12,12 @@ import {
   decodeBase64Url,
   encodeBase64Url,
   isCompleteCtxDatePath,
+  isCtxDatePathPrefix,
   isCtxDateExpression,
   parseCtxDateExpression,
+  parseCtxDateExpressionConfig,
   resolveCtxDatePath,
+  serializeCtxDateExpressionConfig,
   serializeCtxDateValue,
 } from '../dateVariable';
 
@@ -54,13 +57,60 @@ describe('dateVariable utils', () => {
       number: 2,
     });
 
-    const singleExpr = serializeCtxDateValue('2026-02-12')!;
+    const singleExpr = serializeCtxDateValue('2026-02-12');
+    if (!singleExpr) throw new Error('Expected exact date expression');
     expect(parseCtxDateExpression(singleExpr)).toBe('2026-02-12');
 
-    const rangeExpr = serializeCtxDateValue(['2026-02-12', '2026-02-20'])!;
+    const rangeExpr = serializeCtxDateValue(['2026-02-12', '2026-02-20']);
+    if (!rangeExpr) throw new Error('Expected exact date range expression');
     expect(parseCtxDateExpression(rangeExpr)).toEqual(['2026-02-12', '2026-02-20']);
   });
 
+  it('serializes, parses and resolves formatted expressions', () => {
+    const expression = serializeCtxDateExpressionConfig({
+      kind: 'preset',
+      preset: 'today',
+      format: 'YYYY/MM/DD',
+    });
+    if (!expression) throw new Error('Expected formatted date expression');
+
+    expect(expression).toMatch(/^\{\{ ctx\.date\.format\.v[A-Za-z0-9_-]+\.preset\.today \}\}$/);
+    expect(parseCtxDateExpressionConfig(expression)).toEqual({
+      kind: 'preset',
+      preset: 'today',
+      format: 'YYYY/MM/DD',
+    });
+    // Keep the legacy parser contract for filter-form consumers.
+    expect(parseCtxDateExpression(expression)).toEqual({ type: 'today' });
+
+    const path = expression.replace('{{ ctx.', '').replace(' }}', '').split('.');
+    expect(resolveCtxDatePath(path)).toMatch(/^\d{4}\/\d{2}\/\d{2}$/);
+    expect(isCompleteCtxDatePath(path)).toBe(true);
+  });
+
+  it('preserves significant whitespace in a custom Format', () => {
+    const expression = serializeCtxDateExpressionConfig({
+      kind: 'preset',
+      preset: 'today',
+      format: 'YYYY-MM-DD ',
+    });
+    if (!expression) throw new Error('Expected formatted date expression');
+
+    expect(parseCtxDateExpressionConfig(expression)?.format).toBe('YYYY-MM-DD ');
+  });
+
+  it('formats exact ranges element by element', () => {
+    const expression = serializeCtxDateExpressionConfig({
+      kind: 'exact',
+      value: ['2026-02-12', '2026-02-20'],
+      format: 'YYYYMMDD',
+    });
+    if (!expression) throw new Error('Expected formatted date range expression');
+    const path = expression.replace('{{ ctx.', '').replace(' }}', '').split('.');
+
+    expect(resolveCtxDatePath(path)).toEqual(['20260212', '20260220']);
+  });
+
   it('resolves preset/relative/exact path', () => {
     expect(typeof resolveCtxDatePath(['date', 'preset', 'now'])).toBe('string');
 
@@ -72,11 +122,13 @@ describe('dateVariable utils', () => {
     expect(typeof rel).toBe('string');
     expect(rel).toMatch(/^\d{4}-\d{2}-\d{2}$/);
 
-    const singleExpr = serializeCtxDateValue('2026-02-12')!;
+    const singleExpr = serializeCtxDateValue('2026-02-12');
+    if (!singleExpr) throw new Error('Expected exact date expression');
     const token = singleExpr.replace('{{ ctx.date.exact.single.date.', '').replace(' }}', '');
     expect(resolveCtxDatePath(['date', 'exact', 'single', 'date', token])).toBe('2026-02-12');
 
-    const rangeExpr = serializeCtxDateValue(['2026-02-12', '2026-02-20'])!;
+    const rangeExpr = serializeCtxDateValue(['2026-02-12', '2026-02-20']);
+    if (!rangeExpr) throw new Error('Expected exact date range expression');
     const parts = rangeExpr.replace('{{ ctx.date.exact.range.date.', '').replace(' }}', '').split('.');
     expect(resolveCtxDatePath(['date', 'exact', 'range', 'date', parts[0], parts[1]])).toEqual([
       '2026-02-12',
@@ -90,6 +142,7 @@ describe('dateVariable utils', () => {
     expect(isCompleteCtxDatePath(['date', 'exact', 'single', 'date', 'vabc'])).toBe(true);
     expect(isCompleteCtxDatePath(['date', 'exact', 'range', 'date', 'vabc', 'vdef'])).toBe(true);
     expect(isCompleteCtxDatePath(['date', 'relative', 'next', 'day'])).toBe(false);
+    expect(isCtxDatePathPrefix(['date', 'format'])).toBe(true);
     expect(isCompleteCtxDatePath(['user', 'name'])).toBe(false);
   });
 

package/src/utils/dateVariable.ts

@@ -11,7 +11,7 @@ import dayjs from 'dayjs';
 
 const CTX_DATE_REGEX = /^\{\{\s*ctx\.date(?:\.(.+?))?\s*\}\}$/;
 
-const PRESET_KEYS = new Set([
+const PRESET_KEY_LIST = [
   'today',
   'now',
   'yesterday',
@@ -28,10 +28,28 @@ const PRESET_KEYS = new Set([
   'thisYear',
   'lastYear',
   'nextYear',
-]);
+] as const;
+
+export type CtxDatePreset = (typeof PRESET_KEY_LIST)[number];
+export type CtxDateRelativeDirection = 'next' | 'past';
+export type CtxDateRelativeUnit = 'day' | 'week' | 'month' | 'year';
+
+export type CtxDateExpressionConfig =
+  | { kind: 'exact'; value: string | [string, string]; format?: string }
+  | {
+      kind: 'relative';
+      direction: CtxDateRelativeDirection;
+      amount: number;
+      unit: CtxDateRelativeUnit;
+      format?: string;
+    }
+  | { kind: 'preset'; preset: CtxDatePreset; format?: string };
+
+const PRESET_KEYS = new Set<string>(PRESET_KEY_LIST);
 
 const RELATIVE_DIRECTIONS = new Set(['next', 'past']);
 const RELATIVE_UNITS = new Set(['day', 'week', 'month', 'year']);
+const MAX_DATE_FORMAT_LENGTH = 128;
 
 function parseCtxDateSegments(value: string): string[] | null {
   if (typeof value !== 'string') return null;
@@ -46,8 +64,7 @@ function parseCtxDateSegments(value: string): string[] | null {
     .filter(Boolean);
 }
 
-export function isCtxDatePathPrefix(pathSegments: string[]): boolean {
-  const segments = withDatePrefix((pathSegments || []).map((seg) => String(seg)));
+function isBaseCtxDatePathPrefix(segments: string[]): boolean {
   if (segments[0] !== 'date') return false;
   if (segments.length === 1) return true;
 
@@ -96,6 +113,36 @@ export function isCtxDatePathPrefix(pathSegments: string[]): boolean {
   return false;
 }
 
+function decodeFormatToken(token: string): string | undefined {
+  const raw = String(token || '');
+  if (!raw.startsWith('v')) return undefined;
+  const decoded = decodeBase64Url(raw.slice(1));
+  if (!decoded || decoded.length > MAX_DATE_FORMAT_LENGTH) return undefined;
+  return decoded;
+}
+
+function splitFormattedDateSegments(segments: string[]): { baseSegments: string[]; format?: string } | null {
+  if (segments[0] !== 'date') return null;
+  if (segments[1] !== 'format') return { baseSegments: segments };
+  if (segments.length < 4) return null;
+
+  const format = decodeFormatToken(segments[2]);
+  if (!format) return null;
+  return { baseSegments: ['date', ...segments.slice(3)], format };
+}
+
+export function isCtxDatePathPrefix(pathSegments: string[]): boolean {
+  const segments = withDatePrefix((pathSegments || []).map((seg) => String(seg)));
+  if (segments[0] !== 'date') return false;
+  if (segments.length === 1) return true;
+  if (segments[1] !== 'format') return isBaseCtxDatePathPrefix(segments);
+  if (segments.length === 2) return true;
+  if (segments.length === 3) return typeof decodeFormatToken(segments[2]) === 'string';
+
+  const formatted = splitFormattedDateSegments(segments);
+  return formatted ? isBaseCtxDatePathPrefix(formatted.baseSegments) : false;
+}
+
 function withDatePrefix(pathSegments: string[]): string[] {
   if (pathSegments[0] === 'date') {
     return pathSegments;
@@ -210,27 +257,29 @@ export function isCtxDateExpression(value: unknown): value is string {
 export function isCompleteCtxDatePath(pathSegments: string[]): boolean {
   if (!isCtxDatePathPrefix(pathSegments)) return false;
   const segments = withDatePrefix((pathSegments || []).map((seg) => String(seg)));
-  if (segments[0] !== 'date') return false;
+  const formatted = splitFormattedDateSegments(segments);
+  if (!formatted) return false;
+  const baseSegments = formatted.baseSegments;
 
-  if (segments[1] === 'preset') {
-    return segments.length === 3 && PRESET_KEYS.has(segments[2]);
+  if (baseSegments[1] === 'preset') {
+    return baseSegments.length === 3 && PRESET_KEYS.has(baseSegments[2]);
   }
 
-  if (segments[1] === 'relative') {
-    if (segments.length !== 5) return false;
+  if (baseSegments[1] === 'relative') {
+    if (baseSegments.length !== 5) return false;
     return (
-      RELATIVE_DIRECTIONS.has(segments[2]) &&
-      RELATIVE_UNITS.has(segments[3]) &&
-      typeof parseNumberToken(segments[4]) === 'number'
+      RELATIVE_DIRECTIONS.has(baseSegments[2]) &&
+      RELATIVE_UNITS.has(baseSegments[3]) &&
+      typeof parseNumberToken(baseSegments[4]) === 'number'
     );
   }
 
-  if (segments[1] === 'exact' && segments[2] === 'single' && segments[3] === 'date') {
-    return segments.length === 5 && /^v.+/.test(segments[4]);
+  if (baseSegments[1] === 'exact' && baseSegments[2] === 'single' && baseSegments[3] === 'date') {
+    return baseSegments.length === 5 && /^v.+/.test(baseSegments[4]);
   }
 
-  if (segments[1] === 'exact' && segments[2] === 'range' && segments[3] === 'date') {
-    return segments.length === 6 && /^v.+/.test(segments[4]) && /^v.+/.test(segments[5]);
+  if (baseSegments[1] === 'exact' && baseSegments[2] === 'range' && baseSegments[3] === 'date') {
+    return baseSegments.length === 6 && /^v.+/.test(baseSegments[4]) && /^v.+/.test(baseSegments[5]);
   }
 
   return false;
@@ -238,7 +287,10 @@ export function isCompleteCtxDatePath(pathSegments: string[]): boolean {
 
 export function parseCtxDateExpression(value: unknown): any {
   if (!isCtxDateExpression(value)) return undefined;
-  const segments = withDatePrefix(parseCtxDateSegments(value as string) || []);
+  const rawSegments = withDatePrefix(parseCtxDateSegments(value as string) || []);
+  const formatted = splitFormattedDateSegments(rawSegments);
+  if (!formatted) return undefined;
+  const segments = formatted.baseSegments;
 
   if (segments[1] === 'preset' && segments.length === 3 && PRESET_KEYS.has(segments[2])) {
     return { type: segments[2] };
@@ -276,6 +328,66 @@ export function parseCtxDateExpression(value: unknown): any {
   return undefined;
 }
 
+export function parseCtxDateExpressionConfig(value: unknown): CtxDateExpressionConfig | undefined {
+  if (!isCtxDateExpression(value)) return undefined;
+  const segments = withDatePrefix(parseCtxDateSegments(value) || []);
+  const formatted = splitFormattedDateSegments(segments);
+  if (!formatted) return undefined;
+
+  const parsed = parseCtxDateExpression(value);
+  const formatConfig = formatted.format ? { format: formatted.format } : {};
+  if (typeof parsed === 'string') {
+    return { kind: 'exact', value: parsed, ...formatConfig };
+  }
+  if (Array.isArray(parsed) && parsed.length === 2 && typeof parsed[0] === 'string' && typeof parsed[1] === 'string') {
+    return { kind: 'exact', value: [parsed[0], parsed[1]], ...formatConfig };
+  }
+
+  if (!parsed || typeof parsed !== 'object') return undefined;
+  const typed = parsed as { type?: unknown; unit?: unknown; number?: unknown };
+  if (typed.type === 'past' || typed.type === 'next') {
+    if (typeof typed.unit !== 'string' || !RELATIVE_UNITS.has(typed.unit) || typeof typed.number !== 'number') {
+      return undefined;
+    }
+    return {
+      kind: 'relative',
+      direction: typed.type,
+      amount: typed.number,
+      unit: typed.unit as CtxDateRelativeUnit,
+      ...formatConfig,
+    };
+  }
+
+  if (typeof typed.type === 'string' && PRESET_KEYS.has(typed.type)) {
+    return { kind: 'preset', preset: typed.type as CtxDatePreset, ...formatConfig };
+  }
+  return undefined;
+}
+
+export function serializeCtxDateExpressionConfig(config: CtxDateExpressionConfig): string | undefined {
+  let legacyValue: unknown;
+
+  if (config.kind === 'preset') {
+    if (!PRESET_KEYS.has(config.preset)) return undefined;
+    legacyValue = { type: config.preset };
+  } else if (config.kind === 'relative') {
+    if (!RELATIVE_DIRECTIONS.has(config.direction) || !RELATIVE_UNITS.has(config.unit)) return undefined;
+    const amount = Math.floor(Number(config.amount));
+    if (!Number.isFinite(amount) || amount <= 0) return undefined;
+    legacyValue = { type: config.direction, unit: config.unit, number: amount };
+  } else {
+    legacyValue = config.value;
+  }
+
+  const expression = serializeCtxDateValue(legacyValue);
+  if (!expression || !config.format) return expression;
+
+  const format = String(config.format);
+  if (!format.trim() || format.length > MAX_DATE_FORMAT_LENGTH) return undefined;
+  const segments = withDatePrefix(parseCtxDateSegments(expression) || []);
+  return toCtxDateExpression(['date', 'format', `v${encodeBase64Url(format)}`, ...segments.slice(1)]);
+}
+
 export function serializeCtxDateValue(value: unknown): string | undefined {
   if (isCtxDateExpression(value)) {
     return String(value).trim();
@@ -327,8 +439,23 @@ export function serializeCtxDateValue(value: unknown): string | undefined {
   return undefined;
 }
 
+function formatResolvedDateValue(value: unknown, format: string): unknown {
+  const formatValue = (item: unknown) => {
+    if (typeof item !== 'string') return item;
+    const parsed = dayjs(item);
+    return parsed.isValid() ? parsed.format(format) : item;
+  };
+  return Array.isArray(value) ? value.map(formatValue) : formatValue(value);
+}
+
 export function resolveCtxDatePath(pathSegments: string[]): any {
-  const segments = withDatePrefix((pathSegments || []).map((seg) => String(seg)));
+  const rawSegments = withDatePrefix((pathSegments || []).map((seg) => String(seg)));
+  const formatted = splitFormattedDateSegments(rawSegments);
+  if (!formatted) return undefined;
+  if (formatted.format) {
+    return formatResolvedDateValue(resolveCtxDatePath(formatted.baseSegments), formatted.format);
+  }
+  const segments = formatted.baseSegments;
   if (segments[0] !== 'date') return undefined;
 
   if (segments[1] === 'preset' && segments.length === 3) {

package/src/utils/index.ts

@@ -92,8 +92,14 @@ export {
   isCtxDatePathPrefix,
   isCtxDateExpression,
   parseCtxDateExpression,
+  parseCtxDateExpressionConfig,
   resolveCtxDatePath,
+  serializeCtxDateExpressionConfig,
   serializeCtxDateValue,
+  type CtxDateExpressionConfig,
+  type CtxDatePreset,
+  type CtxDateRelativeDirection,
+  type CtxDateRelativeUnit,
 } from './dateVariable';
 
 // RunJS value helpers

package/src/utils/params-resolvers.ts

@@ -79,6 +79,7 @@ export type JSONValue = string | { [key: string]: JSONValue } | JSONValue[];
 // =========================
 
 type BatchPayload = {
+  contractRd?: string;
   rd?: string;
   template: JSONValue;
   contextParams?: ServerContextParams | undefined;
@@ -172,6 +173,7 @@ export function enqueueVariablesResolve(ctx: FlowRuntimeContext, payload: BatchP
     try {
       const batch = items.map((it) => ({
         id: it.id,
+        contractRd: it.payload.contractRd,
         rd: it.payload.rd,
         template: it.payload.template,
         contextParams: it.payload.contextParams || {},

package/src/views/createViewMeta.ts

@@ -475,12 +475,14 @@ interface PopupNodeResource {
 interface PopupNode {
   uid?: string;
   resource: PopupNodeResource;
+  sourceRecord?: unknown;
   parent?: PopupNode;
 }
 
 export async function buildPopupRuntime(ctx: FlowContext, view: FlowView): Promise<PopupNode | undefined> {
   const stack = getViewStack(view);
   const currentIndex = getAnchoredViewStackIndex(view, stack);
+  const sourceRecord = view?.inputArgs?.parentItem?.value;
 
   const openerUids = view?.inputArgs?.openerUids;
   const hasOpener = Array.isArray(openerUids) && openerUids.length > 0;
@@ -503,6 +505,7 @@ export async function buildPopupRuntime(ctx: FlowContext, view: FlowView): Promi
         filterByTk: args.filterByTk,
         sourceId: args.sourceId,
       },
+      ...(typeof sourceRecord !== 'undefined' ? { sourceRecord } : {}),
     };
   }
 
@@ -531,6 +534,9 @@ export async function buildPopupRuntime(ctx: FlowContext, view: FlowView): Promi
     return node;
   };
   const currentNode = await buildNode(currentIndex);
+  if (currentNode && typeof sourceRecord !== 'undefined') {
+    currentNode.sourceRecord = sourceRecord;
+  }
   return currentNode;
 }
 
@@ -542,6 +548,30 @@ export function registerPopupVariable(ctx: FlowContext, view: FlowView) {
   // - 任意层级 parent.parent... 下的 record / sourceRecord 及其子字段
   const POPUP_SERVER_PATH_RE =
     /^(?:record|sourceRecord)(?:\.|$)|^parent(?:\.parent)*(?:\.(?:record|sourceRecord))(?:\.|$)/;
+  const shouldResolveSourceRecordOnServer = (path: string): boolean => {
+    if (path !== 'sourceRecord' && !path.startsWith('sourceRecord.')) return false;
+
+    const parentItem = view?.inputArgs?.parentItem;
+    if (typeof parentItem?.value === 'undefined') return true;
+
+    const sourcePath = path === 'sourceRecord' ? '' : path.slice('sourceRecord.'.length);
+    if (!sourcePath) return false;
+
+    const parentItemResolver = view?.inputArgs?.parentItemResolver;
+    if (typeof parentItemResolver === 'function') {
+      return parentItemResolver(`value.${sourcePath}`);
+    }
+
+    const segments = sourcePath.split('.').filter(Boolean);
+    let current = parentItem.value;
+    for (const segment of segments) {
+      if (current === null || typeof current !== 'object' || !(segment in current)) {
+        return true;
+      }
+      current = current[segment];
+    }
+    return false;
+  };
   // 始终注册 popup 变量：
   // - 若当前视图无可推断记录，仅在元信息中不呈现 record 字段；
   // - 但仍可依据 navigation 推断并展示上级弹窗信息。
@@ -550,6 +580,9 @@ export function registerPopupVariable(ctx: FlowContext, view: FlowView) {
     meta: createPopupMeta(ctx, view),
     resolveOnServer: (p: string) => {
       try {
+        if (p === 'sourceRecord' || p.startsWith('sourceRecord.')) {
+          return shouldResolveSourceRecordOnServer(p);
+        }
         return !!p && POPUP_SERVER_PATH_RE.test(p);
       } catch (_) {
         return false;