@pylonts/dsl 1.1.20 → 1.1.22

package/README.md

@@ -7,21 +7,24 @@ Schema 定义与产物生成分离的 DSL 系统：先写 DSL 元数据（表 /
 从概要设计到详细设计的自顶向下链路：
 
 ```
-project（地图：应用与 API 拓扑）
-  → dictionary（词典：命名与数据类型标准）
-    → prototype（概要设计：页面与字段）
-      → table / dto（详细设计）
-        → driver 生成产物（SQL / 枚举 / TypeBox）
+concepts（概念：名词 + 名词解释——先于一切存在的名字层）
+  → project（地图：应用与 API 拓扑）
+    → dictionary（词典：词根与字段命名标准，概念派生）
+      → prototype（概要设计：页面与字段）
+        → table / dto（详细设计）
+          → driver 生成产物（SQL / 枚举 / TypeBox）
 ```
 
 ## 文档
 
+- [concepts.md](./docs/concepts.md) — 概念层（名词 + 名词解释，蓝图的名字层；设计草案）
 - [project.md](./docs/project.md) — 项目拓扑（地图）
 - [dictionary.md](./docs/dictionary.md) — 短语词典（命名标准）
 - [prototype.md](./docs/prototype.md) — 页面原型（概要设计）
 - [table.md](./docs/table.md) — 定义表（详细设计）
 - [dto.md](./docs/dto.md) — 定义 DTO
 - [curd.md](./docs/curd.md) — 管理端 CRUD 页面标准（CurdSchema）
+- [task.md](./docs/task.md) — 系统任务（TaskSchema：scheduled 定时 / async 异步，action 闭包成员）
 - [utils.md](./docs/utils.md) — 工具模块与领域规则（UtilsSchema：防御 guard / 判断 / 计算）
 - [aggregate.md](./docs/aggregate.md) — 聚合/仓储 DSL 扩展规划（声明层已落地：DomainAggregate/RepositorySchema + 存储校验，生成器待选型）
 - [domain-event.md](./docs/domain-event.md) — 领域事件 DSL 扩展规划（声明层已落地：DomainEventSchema + event_schema 存储校验，发布/订阅待实现）

package/dist/action.d.ts

@@ -1,39 +1,82 @@
 import { SchemaBase } from './dsl.js';
-import type { DtoField, DtoMessage, DtoArrayField, DtoObjectField } from './dto.js';
-import type { RefSchema } from './ref.js';
 import type { ControllerMethodSchema } from './controller.js';
-/** An action a user can perform on a page (e.g. submit, approve, reject).
- *  Subclasses use `type` as the discriminator. */
+import type { ThirdServiceMethodSchema, ThirdCallbackSchema } from './third-service.js';
+import type { TaskSchema } from './task.js';
+import type { TableSchema } from './db.js';
+import type { PageSchema } from './page.js';
+/** A beat of a journey: type + properties + input data. */
 export interface ActionSchema extends SchemaBase {
-    type: string;
+    type: 'page' | 'controller' | 'third' | 'db' | 'task';
+    /** Input data of this beat (blueprint: names first, refined to refs later). */
+    data?: Record<string, unknown>;
 }
-export declare function defineAction(name: string, description?: string): ActionSchema;
-/** Parameter data source for a call argument. */
-export type DataRef = {
-    type: 'route';
-    key: string;
-} | {
-    type: 'data';
-    key: string;
-} | {
-    type: 'value';
-    value: unknown;
-};
-/** Create a route-parameter reference. */
-export declare function route(key: string): DataRef;
-/** Create a page-data reference. */
-export declare function data(key: string): DataRef;
-export interface CallAction extends ActionSchema {
-    type: 'call';
-    func: ControllerMethodSchema;
-    args?: Record<string, DtoField | DtoMessage | DtoArrayField | DtoObjectField | RefSchema | string>;
+/** Visit a page — `data` present means fill/submit a form, absent means pure view. */
+export interface PageAction extends ActionSchema {
+    type: 'page';
+    /** Target page (PageFlow node). */
+    page: PageSchema;
+    /** Page url/path (e.g. '/bd/apply'). */
+    url: string;
+}
+/** Call a backend controller method. */
+export interface ControllerAction extends ActionSchema {
+    type: 'controller';
+    /** The controller method invoked (shared instance). */
+    method: ControllerMethodSchema;
+}
+/** Invoke a third-party service method or receive its callback. */
+export interface ThirdAction extends ActionSchema {
+    type: 'third';
+    /** The third-party method invoked (outbound). */
+    method?: ThirdServiceMethodSchema;
+    /** The third-party callback received (inbound) — mutually exclusive with method. */
+    callback?: ThirdCallbackSchema;
+    /** Wait for the async callback (inbound) before the journey continues. */
+    async?: boolean;
 }
-export declare function call(func: ControllerMethodSchema, args?: Record<string, DtoField | DtoMessage | DtoArrayField | DtoObjectField | RefSchema | string>): CallAction;
-/** Assign a call's result to a page data field.
- *  React: setState({ [field]: await ... }). Mini-program: this.setData({ [field]: ... }). */
-export interface SetDataAction extends ActionSchema {
-    type: 'setData';
-    call: CallAction;
-    field: DtoField;
+/** Write to a database table. */
+export interface DbAction extends ActionSchema {
+    type: 'db';
+    /** The table written (shared instance). */
+    table: TableSchema;
+    /** Write operation: insert | update | delete. */
+    op: 'insert' | 'update' | 'delete';
 }
-export declare function setData(call: CallAction, field: DtoField): SetDataAction;
+/** Trigger a system task (scheduled or async). */
+export interface TaskAction extends ActionSchema {
+    type: 'task';
+    /** The task triggered (shared instance). */
+    task: TaskSchema;
+}
+/** Builder for a journey action. */
+export declare const action: {
+    page(options: {
+        page: PageSchema;
+        url: string;
+        data?: Record<string, unknown>;
+        description?: string;
+    }): PageAction;
+    controller(options: {
+        method: ControllerMethodSchema;
+        data?: Record<string, unknown>;
+        description?: string;
+    }): ControllerAction;
+    third(options: {
+        method?: ThirdServiceMethodSchema;
+        callback?: ThirdCallbackSchema;
+        data?: Record<string, unknown>;
+        async?: boolean;
+        description?: string;
+    }): ThirdAction;
+    db(options: {
+        table: TableSchema;
+        op: 'insert' | 'update' | 'delete';
+        data?: Record<string, unknown>;
+        description?: string;
+    }): DbAction;
+    task(options: {
+        task: TaskSchema;
+        data?: Record<string, unknown>;
+        description?: string;
+    }): TaskAction;
+};

package/dist/action.js

@@ -1,17 +1,19 @@
-export function defineAction(name, description) {
-    return { name, description, type: 'gesture' };
-}
-/** Create a route-parameter reference. */
-export function route(key) {
-    return { type: 'route', key };
-}
-/** Create a page-data reference. */
-export function data(key) {
-    return { type: 'data', key };
-}
-export function call(func, args) {
-    return { name: func.name, type: 'call', func, args };
-}
-export function setData(call, field) {
-    return { name: 'setData', type: 'setData', call, field };
-}
+/** Builder for a journey action. */
+export const action = {
+    page(options) {
+        return { name: options.page.name, type: 'page', page: options.page, url: options.url, data: options.data, description: options.description };
+    },
+    controller(options) {
+        return { name: options.method.name, type: 'controller', method: options.method, data: options.data, description: options.description };
+    },
+    third(options) {
+        const name = options.method?.name ?? options.callback?.name ?? 'third';
+        return { name, type: 'third', method: options.method, callback: options.callback, data: options.data, async: options.async, description: options.description };
+    },
+    db(options) {
+        return { name: options.table.name, type: 'db', table: options.table, op: options.op, data: options.data, description: options.description };
+    },
+    task(options) {
+        return { name: options.task.name, type: 'task', task: options.task, data: options.data, description: options.description };
+    },
+};

package/dist/aggregate.d.ts

@@ -1,16 +1,7 @@
 import type { SchemaBase } from './dsl.js';
-import type { TableSchema, ForeignKey } from './db.js';
-/** How a member table attaches to the aggregate root. */
-export interface AggregateMember {
-    /** The member table (shared instance from schema/*.table.ts). */
-    table: TableSchema;
-    /** The foreign key on the member table pointing to the root table.
-     *  Must exist in table.foreignKeys and its references must be the root's PK
-     *  columns. Defaults to the (unique) FK referencing the root table. */
-    via?: ForeignKey;
-    /** 1:1 member (unique constraint on via.columns) vs 1:N (default). */
-    one?: boolean;
-}
+import type { TableSchema } from './db.js';
+/** Member table(s) keyed by role name. Array = 1:N; non-array = 1:1 extension. */
+export type AggregateMember = TableSchema | TableSchema[];
 /** A cross-member invariant, checked by generated repository code. */
 export interface AggregateInvariant {
     name: string;
@@ -29,7 +20,6 @@ export interface DomainAggregate extends SchemaBase {
     references?: Record<string, string>;
 }
 export declare function defineAggregate(options: {
-    name: string;
     root: TableSchema;
     members?: Record<string, AggregateMember>;
     invariants?: AggregateInvariant[];

package/dist/aggregate.js

@@ -1,7 +1,7 @@
 export function defineAggregate(options) {
     const schema = {
         type: 'aggregate',
-        name: options.name,
+        name: options.root.name,
         description: options.description,
         root: options.root,
         members: options.members ?? {},
@@ -10,36 +10,33 @@ export function defineAggregate(options) {
     };
     // Root must have a primary key (aggregate identity).
     if (options.root.primaryKey === undefined) {
-        throw new Error(`aggregate '${options.name}': root table '${options.root.name}' must have a primary key`);
+        throw new Error(`aggregate '${schema.name}': root table '${options.root.name}' must have a primary key`);
     }
-    // Each member must attach to the root via an existing FK referencing the root.
     const rootPkRefs = Array.isArray(options.root.primaryKey)
         ? options.root.primaryKey
         : [options.root.primaryKey];
+    // Each member must attach to the root. Array members are normal 1:N tables
+    // and must have exactly one FK referencing the root. Non-array (1:1 extension)
+    // members are designed but not implemented yet.
     for (const [role, member] of Object.entries(schema.members)) {
-        const fks = Object.values(member.table.foreignKeys ?? {}).filter((fk) => {
-            const refs = Array.isArray(fk.references) ? fk.references : [fk.references];
-            return refs.every((r) => rootPkRefs.includes(r)) && refs.length === rootPkRefs.length;
-        });
-        if (fks.length === 0) {
-            throw new Error(`aggregate '${options.name}': member '${role}' table '${member.table.name}' has no foreign key referencing root '${options.root.name}' — declare one in the table's foreignKeys`);
-        }
-        if (member.via !== undefined) {
-            const viaKeys = Object.values(member.table.foreignKeys ?? {});
-            if (!viaKeys.includes(member.via)) {
-                throw new Error(`aggregate '${options.name}': member '${role}' via must be one of table '${member.table.name}' foreignKeys — got a non-FK object`);
+        if (Array.isArray(member)) {
+            if (member.length !== 1) {
+                throw new Error(`aggregate '${schema.name}': member '${role}' array must contain exactly one table schema`);
             }
-            const refs = Array.isArray(member.via.references) ? member.via.references : [member.via.references];
-            if (!(refs.length === rootPkRefs.length && refs.every((r) => rootPkRefs.includes(r)))) {
-                throw new Error(`aggregate '${options.name}': member '${role}' via must reference root '${options.root.name}' primary key columns`);
+            const table = member[0];
+            const fks = Object.values(table.foreignKeys ?? {}).filter((fk) => {
+                const refs = Array.isArray(fk.references) ? fk.references : [fk.references];
+                return refs.length === rootPkRefs.length && refs.every((r) => rootPkRefs.includes(r));
+            });
+            if (fks.length === 0) {
+                throw new Error(`aggregate '${schema.name}': member '${role}' table '${table.name}' has no foreign key referencing root '${options.root.name}' — declare one in the table's foreignKeys`);
             }
-        }
-        else {
-            // Default: the (single) FK referencing the root. More than one → must declare via.
             if (fks.length > 1) {
-                throw new Error(`aggregate '${options.name}': member '${role}' table '${member.table.name}' has ${fks.length} foreign keys referencing root '${options.root.name}' — declare via explicitly`);
+                throw new Error(`aggregate '${schema.name}': member '${role}' table '${table.name}' has ${fks.length} foreign keys referencing root '${options.root.name}' — reduce to one FK for minimal aggregate declarations`);
             }
-            member.via = fks[0];
+        }
+        else {
+            throw new Error(`aggregate '${schema.name}': member '${role}' is a non-array table — 1:1 extension tables are designed but not implemented yet; use an array for 1:N members`);
         }
     }
     return schema;

package/dist/component.d.ts

@@ -1,13 +1,13 @@
 import type { SchemaBase } from './dsl.js';
 import type { RefSchema } from './ref.js';
-import type { ActionSchema } from './action.js';
+import type { PageActionSchema } from './page-action.js';
 import type { EventDataSchema } from './event.js';
 /** A component event trigger declaration. */
 export interface TriggerSchema extends SchemaBase {
     /** Data the event carries (e.g. e.detail). */
     eventData?: EventDataSchema;
-    /** Actions that fire when the event occurs. */
-    actions?: ActionSchema[];
+    /** Page actions that fire when the event occurs. */
+    actions?: PageActionSchema[];
 }
 /** A UI component declaration — a virtual schema that describes props and
  *  event triggers, not a real renderable component.

package/dist/curd.d.ts

@@ -1,7 +1,7 @@
 import { SchemaBase, Field } from './dsl.js';
 import { TableSchema } from './db.js';
 import { FrontAppSchema } from './project.js';
-import { ActionSchema } from './action.js';
+import { PageActionSchema } from './page-action.js';
 import type { FilterSchema } from './filter.js';
 /** Mode of an action page: modal dialog or standalone route. */
 export type ActionPageMode = 'modal' | 'route';
@@ -43,7 +43,7 @@ export interface CurdSchema extends SchemaBase {
     /** Sidebar menu section (group) this CRUD page belongs to. */
     section: string;
     /** Extra user actions on this page (beyond the standard CRUD). */
-    actions?: ActionSchema[];
+    actions?: PageActionSchema[];
     /** Add/update/detail action pages. */
     actionPages?: {
         add?: ActionPage;

package/dist/dto.d.ts

@@ -106,8 +106,15 @@ export declare function isDtoField(v: unknown): v is DtoField;
 /** Resolve a ref chain to its terminal DtoField (the one without .ref).
  *  Cycles are a DSL definition error — fail loudly at render time. */
 export declare function resolveDtoRefChain(f: DtoField): DtoField;
-/** TS type of a DtoField in generated code — unwraps the wrapped field
- *  (enum → its JS name, date/datetime → string, containers → jsType). */
+/** TS type of a DtoField in generated code.
+ *  A field shared by reference (its schema is the owning DTO — utils args
+ *  like `args: { items: OrderSubmitRequest.fields.items }`) renders as an
+ *  indexed access on the DTO's generated type (the DTO owns the structure).
+ *  Array elements render by name (`ItemDto[]` — named DTO) or by recursion
+ *  (`Array<string>` — scalar). Plain wire objects (objectField) render
+ *  their property shape (`{ key: type }`); DtoField-class containers are
+ *  rejected at build time (DTOs must not nest inline structures).
+ *  Enum → its JS name, date/datetime → string. */
 export declare function dtoFieldJsType(df: DtoField): string;
 /** Enum JS names referenced by a DtoField, recursing into inline array/object
  *  wrappers; DtoMessage item references stop the walk. First-occurrence order. */
@@ -118,6 +125,15 @@ export declare function dtoArrayField(def: {
 export declare function dtoObjectField(def: {
     properties: Record<string, DtoField>;
 } & Omit<BaseField, 'name'>): DtoObjectField;
+/** DTOs must not nest DtoField-class containers inline: dtoObjectField /
+ *  dtoArrayField instances (and dtoField(dtoObjectField(...))-style wraps)
+ *  have no reusable name — extract a named DTO and reference it as an array
+ *  element (dtoArrayField({ items: namedDto })), and array items must be a
+ *  named DTO or a scalar field. Plain Field containers (objectField /
+ *  arrayField — wire-format nesting) stay legal and render inline.
+ *  DtoField-class wrappers (dtoField(dtoArrayField(...))) carry the def
+ *  inside the instance's .field, so both layers are unwrapped. */
+export declare function assertNoInlineContainers(dtoName: string, fields: Record<string, DtoField>): void;
 export declare function buildInput(name: string, fields: Record<string, DtoField>, description?: string): DtoMessage;
 export declare function buildOutput(name: string, fields: Record<string, DtoField>, description?: string): DtoMessage;
 export declare function buildQuery(name: string, fields: Record<string, DtoField>, description?: string): DtoMessage;

package/dist/dto.js

@@ -133,15 +133,50 @@ export function resolveDtoRefChain(f) {
     }
     return cur;
 }
-/** TS type of a DtoField in generated code — unwraps the wrapped field
- *  (enum → its JS name, date/datetime → string, containers → jsType). */
+/** TS type of a DtoField in generated code.
+ *  A field shared by reference (its schema is the owning DTO — utils args
+ *  like `args: { items: OrderSubmitRequest.fields.items }`) renders as an
+ *  indexed access on the DTO's generated type (the DTO owns the structure).
+ *  Array elements render by name (`ItemDto[]` — named DTO) or by recursion
+ *  (`Array<string>` — scalar). Plain wire objects (objectField) render
+ *  their property shape (`{ key: type }`); DtoField-class containers are
+ *  rejected at build time (DTOs must not nest inline structures).
+ *  Enum → its JS name, date/datetime → string. */
 export function dtoFieldJsType(df) {
-    const f = df.field;
-    if (f.type === 'enum')
-        return f.enum.jsName;
-    if (f.type === 'date' || f.type === 'datetime')
+    const owner = df.schema;
+    if (owner?.type === 'dto' && owner.name !== undefined && owner.name !== '' && df.name !== '') {
+        return `${owner.name}['${df.name}']`;
+    }
+    return dtoFieldJsTypeInner(df.field);
+}
+/** Type of a raw field object — unwraps DtoField-class wrappers
+ *  (dtoField(dtoArrayField(...)) stores the def inside the instance's
+ *  .field) and recurses: named-DTO elements (Name[]), scalar elements
+ *  (Array<T>), plain wire objects ({ key: type }), enums, and scalars. */
+function dtoFieldJsTypeInner(field) {
+    const f = field.field ?? field;
+    const inner = f;
+    if (inner.type === 'enum')
+        return inner.enum.jsName;
+    if (inner.type === 'date' || inner.type === 'datetime')
         return 'string';
-    return f.jsType;
+    if (inner.type === 'array') {
+        const items = inner.items;
+        return isDtoMessage(items) ? `${items.name}[]` : `Array<${dtoFieldJsType(items)}>`;
+    }
+    if (inner.type === 'object') {
+        // Plain objectField properties are bare Fields; DtoObjectFieldDef
+        // properties are DtoFields. Recurse through both.
+        const props = Object.entries(inner.properties ?? {})
+            .map(([k, v]) => {
+            const optional = isDtoField(v) ? v.isOptional() : v.optional ?? false;
+            const type = isDtoField(v) ? dtoFieldJsType(v) : dtoFieldJsTypeInner(v);
+            return `${k}${optional ? '?' : ''}: ${type}`;
+        })
+            .join('; ');
+        return `{ ${props} }`;
+    }
+    return inner.jsType ?? '';
 }
 /** Enum JS names referenced by a DtoField, recursing into inline array/object
  *  wrappers; DtoMessage item references stop the walk. First-occurrence order. */
@@ -162,14 +197,45 @@ export function dtoCollectEnumRefs(df, out = []) {
     return out;
 }
 export function dtoArrayField(def) {
-    // Items stay as-is: an inline DtoField is rendered inline, a DtoMessage is
-    // referenced by name (the driver renders Type.Array(<DtoName>)).
+    // Items stay as-is: a DtoMessage is referenced by name (the driver renders
+    // Type.Array(<DtoName>)); a scalar DtoField element renders its primitive
+    // type. Inline container elements are rejected by buildMessage/defineUtils
+    // (DTOs must not nest inline structures — every object needs a name).
     return new DtoArrayField({ name: '', type: 'array', jsType: 'array', ...def });
 }
 export function dtoObjectField(def) {
     return new DtoObjectField({ name: '', type: 'object', jsType: 'object', ...def });
 }
+/** DTOs must not nest DtoField-class containers inline: dtoObjectField /
+ *  dtoArrayField instances (and dtoField(dtoObjectField(...))-style wraps)
+ *  have no reusable name — extract a named DTO and reference it as an array
+ *  element (dtoArrayField({ items: namedDto })), and array items must be a
+ *  named DTO or a scalar field. Plain Field containers (objectField /
+ *  arrayField — wire-format nesting) stay legal and render inline.
+ *  DtoField-class wrappers (dtoField(dtoArrayField(...))) carry the def
+ *  inside the instance's .field, so both layers are unwrapped. */
+export function assertNoInlineContainers(dtoName, fields) {
+    for (const [key, df] of Object.entries(fields)) {
+        const f = df.field.field ?? df.field;
+        const field = f;
+        // Only DtoField-class containers are banned (they need a name). Plain
+        // Field objects (objectField — wire-format nesting) are legal and render
+        // inline: dtoField(objectField({...})) stays allowed.
+        const isDtoClassContainer = isDtoField(df.field) || typeof df.properties === 'function';
+        if (isDtoClassContainer && field.type === 'object') {
+            throw new Error(`[dto] "${dtoName}" field "${key}": inline object is not allowed — dtoObjectField containers must be named: extract a named DTO and reference it (dtoArrayField({ items: itemDto })) or use a plain objectField for wire-format nesting`);
+        }
+        if (field.type === 'array' && isDtoField(field.items)) {
+            const items = field.items.field.field ?? field.items.field;
+            const item = items;
+            if (item.type === 'object' || item.type === 'array') {
+                throw new Error(`[dto] "${dtoName}" field "${key}": inline container elements are not allowed — array items must be a named DTO or a scalar field`);
+            }
+        }
+    }
+}
 function buildMessage(name, direction, fields, description) {
+    assertNoInlineContainers(name, fields);
     const message = new DtoMessage(name, direction, fields, description);
     // Write back the DTO field name from the map key (safe: DtoField instances
     // are created per DTO, never shared).

package/dist/flow-script.js

@@ -9,7 +9,7 @@
 // The IR stays the single executable model (mermaid, must-analysis, throws
 // coverage, service contracts all consume it); this layer is a lowering, not
 // a parallel model.
-import { defineFlow, defineSlots, edge, guard, ifNode, isCall, isEnd, isFlowNode, isFlowSlot, isGuard, isIfNode, methodOf, node, tryNode, } from './flow.js';
+import { defineFlow, defineSlots, edge, guard, ifNode, isCall, isConditionGroup, isEnd, isFlowNode, isFlowSlot, isGuard, isIfNode, methodOf, node, tryNode, } from './flow.js';
 /** Call a method as a statement or (in IF position) as a utils predicate. */
 export function invoke(method, args, result) {
     return { kind: 'invoke', method, args, result };
@@ -132,6 +132,11 @@ function addUsed(ctx, slot) {
     ctx.usedNames.add(slot.name);
 }
 function addConditionUsed(ctx, c) {
+    if (isConditionGroup(c)) {
+        for (const s of c.conds)
+            addConditionUsed(ctx, s);
+        return;
+    }
     if (!isCall(c)) {
         addUsed(ctx, isFlowSlot(c.field) ? c.field : c.field.slot);
         return;
@@ -144,6 +149,8 @@ function addConditionUsed(ctx, c) {
 function isInvokeStep(c) {
     return c.kind === 'invoke';
 }
+/** Lower an IF condition: a top-level invoke is a predicate call, and
+ *  composites convert invoke steps nested inside them recursively. */
 function toCondition(c) {
     if (isInvokeStep(c)) {
         if (c.result !== undefined) {
@@ -151,6 +158,9 @@ function toCondition(c) {
         }
         return { method: c.method, args: c.args === undefined ? [] : Array.isArray(c.args) ? c.args : [c.args] };
     }
+    if (isConditionGroup(c)) {
+        return { kind: c.kind, conds: c.conds.map((sub) => toCondition(sub)) };
+    }
     return c;
 }
 /** Display form mirrors the mermaid driver: owner.name / schema.name. */
@@ -172,11 +182,36 @@ function methodThrows(m) {
     return 'throws' in m && m.throws !== undefined ? m.throws : [];
 }
 /** Readable condition text used as node/branch labels (and as the throw
- *  label when THROW carries no message). */
+ *  label when THROW carries no message). Composites render parenthesized
+ *  sub-conditions: !(a), (a && b), (a || b). */
 function renderCondition(c) {
+    if (isConditionGroup(c)) {
+        const inner = c.conds.map(renderCondition).join(c.kind === 'and' ? ' && ' : c.kind === 'or' ? ' || ' : '');
+        return c.kind === 'not' ? `!(${inner})` : `(${inner})`;
+    }
     if (!isCall(c)) {
         if (isFlowSlot(c.field)) {
-            return c.op === 'isNull' ? `${c.field.name} is null` : `${c.field.name} is not null`;
+            const nullOp = c.op === 'isNull' || c.op === 'isNotNull';
+            if (nullOp)
+                return c.op === 'isNull' ? `${c.field.name} is null` : `${c.field.name} is not null`;
+            // scalar slot comparison: total > 100
+            const ref = c.field.name;
+            switch (c.op) {
+                case 'lt':
+                    return `${ref} < ${renderValue(c.value)}`;
+                case 'le':
+                    return `${ref} <= ${renderValue(c.value)}`;
+                case 'gt':
+                    return `${ref} > ${renderValue(c.value)}`;
+                case 'ge':
+                    return `${ref} >= ${renderValue(c.value)}`;
+                case 'eq':
+                    return `${ref} = ${renderValue(c.value)}`;
+                case 'ne':
+                    return `${ref} ≠ ${renderValue(c.value)}`;
+                default:
+                    throw new Error(`unsupported comparison op '${c.op}'`);
+            }
         }
         const field = c.field.field;
         const ref = `${c.field.slot.name}.${field.name}`;
@@ -363,15 +398,21 @@ function compileTry(step, ctx, cont, inherit) {
     const ordinal = ctx.tryTotal - ++ctx.tryCount + 1;
     const suffix = ordinal === 1 ? '' : `${ordinal}`;
     const body = compileFlowBody(`${ctx.name}.tryBody${suffix}`, undefined, step.body, ctx, inherit);
+    // Catch handlers and finally may read what the body produced before the
+    // failure point (Java semantics: try { row = dao.get() } catch { use(row) }).
+    // The body's productions seed their entry availability alongside the
+    // enclosing flow's inherited slots.
+    const bodyProduced = flowProducedSlots(body);
+    const catchInherit = [...inherit, ...bodyProduced];
     const catches = step.catches.map(([ex, steps]) => ({
         exception: ex,
-        handler: compileFlowBody(`${ctx.name}.catch${ex.name}${suffix}`, undefined, steps, ctx, inherit),
+        handler: compileFlowBody(`${ctx.name}.catch${ex.name}${suffix}`, undefined, steps, ctx, catchInherit),
     }));
     const t = tryNode(step.name ?? 'try', {
         body,
         catches,
         finally: step.finally
-            ? compileFlowBody(`${ctx.name}.finally${suffix}`, undefined, step.finally, ctx, inherit)
+            ? compileFlowBody(`${ctx.name}.finally${suffix}`, undefined, step.finally, ctx, catchInherit)
             : undefined,
     });
     ctx.seen.add(t);
@@ -401,6 +442,25 @@ function compileSub(step, ctx, cont, inherit) {
     ctx.edges.push(edge(n, cont));
     return n;
 }
+/** Slots a flow's own nodes produce (call results and writes) — the try
+ *  body's productions become visible to its catch handlers and finally. */
+function flowProducedSlots(f) {
+    const out = new Set();
+    for (const n of f.nodes) {
+        if (isEnd(n))
+            continue;
+        if (isGuard(n) || isFlowNode(n)) {
+            for (const m of n.methods ?? []) {
+                if (isCall(m) && m.result !== undefined)
+                    out.add(m.result);
+            }
+            if (isFlowNode(n))
+                for (const w of n.writes ?? [])
+                    out.add(w);
+        }
+    }
+    return [...out];
+}
 /** Compile one flow (top-level or sub-flow): its own slots registry (args
  *  plus the named slots actually used inside), its own exception ends, and
  *  its own return end (linked through DANGLE). */
@@ -432,8 +492,11 @@ function buildFlow(name, description, ctx, start) {
     const nodes = [...ctx.seen];
     const registry = defineSlots(buildSlots(ctx));
     // Entry inheritance only for slots the flow actually consumes; unused
-    // productions of the enclosing flow are not this flow's concern.
-    const entrySlots = rewriteSlots(nodes, ctx.edges, registry, ctx.entrySlots.filter((s) => ctx.usedSlots.has(s)));
+    // productions of the enclosing flow are not this flow's concern. Name-based
+    // matching: inherited instances may come from another flow's registry (the
+    // try body's re-bound productions), so identity comparison would drop them.
+    const usedNames = new Set([...ctx.usedSlots].map((s) => s.name));
+    const entrySlots = rewriteSlots(nodes, ctx.edges, registry, ctx.entrySlots.filter((s) => usedNames.has(s.name)));
     return defineFlow(name, {
         start,
         description,
@@ -475,6 +538,9 @@ function rewriteSlots(nodes, edges, slots, entrySlots) {
         return { method: m.method, args: m.args?.map(map), result: m.result ? map(m.result) : undefined };
     };
     const cond = (c) => {
+        if (isConditionGroup(c)) {
+            return { kind: c.kind, conds: c.conds.map(cond) };
+        }
         if (!isCall(c)) {
             if (isFlowSlot(c.field)) {
                 return { kind: 'comparison', op: c.op, field: map(c.field), value: c.value };