pgkiln 0.81.0 → 0.83.0

package/src/runtime/logic.ts

@@ -14,17 +14,42 @@ import { logActivity } from '../session.ts';
 // own savepoint.
 
 const list = (s: string | null | undefined) => (s ?? '').split(',').map((x) => x.trim().toUpperCase()).filter(Boolean);
+const isZero = (v: string) => v.trim() !== '' && Number(v) === 0;
 
-/** Does a computation's or branch's condition hold? Broken SQL counts as false (and shows a message). */
+/** The condition types that run SQL (as the application's role); all others are decided without a query. */
+export const SQL_CONDITIONS = new Set(['sql', 'exists', 'not_exists', 'function_body']);
+
+/** (147) A region's or button's condition: `condition` is the expression, SQL when no type is set. */
+export const conditionOf = (x: { condition?: string | null; condition_type?: string | null; condition_value?: string | null }): Condition => ({
+  condition_type: (x.condition_type || (x.condition?.trim() ? 'sql' : null)) as Condition['condition_type'],
+  condition_expr: x.condition ?? null,
+  condition_value: x.condition_value ?? null,
+});
+
+/** (147) A dynamic action's server-side condition (its condition_type is the client-side one). */
+export const serverConditionOf = (d: { server_condition_type?: string | null; server_condition_expr?: string | null; server_condition_value?: string | null }): Condition => ({
+  condition_type: (d.server_condition_type || null) as Condition['condition_type'],
+  condition_expr: d.server_condition_expr ?? null,
+  condition_value: d.server_condition_value ?? null,
+});
+
+/**
+ * Does a server-side condition hold (migrations 029, 147)? The same catalogue for every component. Broken SQL
+ * counts as false (and shows a message); an unknown type is false.
+ */
 export async function conditionHolds(ctx: PageContext, cond: Condition, where: string): Promise<boolean> {
-  const value = (name: string | null) => {
-    const v = name ? bindValues(ctx)[name.toUpperCase()] : null;
+  const value = (name: string | null | undefined) => {
+    const v = name ? bindValues(ctx)[name.trim().toUpperCase()] : null;
     return v === undefined || v === null ? '' : v;
   };
+  const item = value(cond.condition_expr);
   switch (cond.condition_type) {
     case null:
     case undefined:
+    case 'always':
       return true;
+    case 'never':
+      return false;
     case 'sql':
       return sqlTrue(ctx, cond.condition_expr, where);
     case 'exists':
@@ -39,16 +64,62 @@ export async function conditionHolds(ctx: PageContext, cond: Condition, where: s
         return false; // fail closed either way
       }
     }
+    case 'function_body':
+      try {
+        const v = await savepoint(ctx.client!, () => functionBody(ctx, cond.condition_expr ?? ''));
+        return v === 'true' || v === 't';
+      } catch (e) {
+        ctx.errors.page.push(await publicError(ctx, e, where));
+        return false;
+      }
     case 'item_null':
-      return value(cond.condition_expr) === '';
+      return item === '';
     case 'item_not_null':
-      return value(cond.condition_expr) !== '';
+      return item !== '';
+    case 'item_zero':
+      return isZero(item);
+    case 'item_not_zero':
+      return !isZero(item);
+    case 'item_null_or_zero':
+      return item === '' || isZero(item);
+    case 'item_not_null_or_zero':
+      return item !== '' && !isZero(item);
     case 'item_equals':
-      return value(cond.condition_expr) === (cond.condition_value ?? '');
+      return item === (cond.condition_value ?? '');
     case 'item_not_equals':
-      return value(cond.condition_expr) !== (cond.condition_value ?? '');
+      return item !== (cond.condition_value ?? '');
+    case 'item_equals_item':
+      return item === value(cond.condition_value);
+    case 'item_not_equals_item':
+      return item !== value(cond.condition_value);
+    case 'item_in_list':
+    case 'item_not_in_list': {
+      const found = (cond.condition_value ?? '').split(':').includes(item);
+      return cond.condition_type === 'item_in_list' ? found : !found;
+    }
     case 'request_in':
       return list(cond.condition_value).includes(ctx.request);
+    case 'request_not_in':
+      return !list(cond.condition_value).includes(ctx.request);
+    case 'page_in':
+    case 'page_not_in': {
+      const found = list(cond.condition_value).includes(String(ctx.page.page_no));
+      return cond.condition_type === 'page_in' ? found : !found;
+    }
+    case 'page_is_dialog':
+      return ctx.page.mode === 'modal';
+    case 'page_is_not_dialog':
+      return ctx.page.mode !== 'modal';
+    case 'user_signed_in':
+      return ctx.user !== 'nobody';
+    case 'user_public':
+      return ctx.user === 'nobody';
+    case 'language_in':
+    case 'language_not_in': {
+      const lang = ctx.locale.lang.toUpperCase();
+      const found = list(cond.condition_value).some((l) => l === lang || lang.startsWith(`${l}-`));
+      return cond.condition_type === 'language_in' ? found : !found;
+    }
     default:
       return false; // unknown type: fail closed
   }
@@ -61,7 +132,7 @@ export async function conditionHolds(ctx: PageContext, cond: Condition, where: s
  * savepoint, as the application's role (binds are substituted first, as
  * escaped literals). It never outlives the transaction's savepoint.
  */
-async function functionBody(ctx: PageContext, body: string): Promise<string | null> {
+export async function functionBody(ctx: PageContext, body: string): Promise<string | null> {
   const c = ctx.client!;
   const code = applyBinds(body, bindValues(ctx)).trim();
   const block = /^(declare|begin)\b/i.test(code) ? code : `begin\n${code}\nend`;

package/src/runtime/maps.ts

@@ -13,7 +13,7 @@ import { encodeTile, tileArea, type TileFeature } from '../mvt.ts';
 
 // Map region (APEX: Map region). The SELECT returns, per row, a position
 // (columns lat and lng, latitude and longitude, or location as "lat,lng")
-// and optionally title, body and geojson (a GeoJSON geometry or feature for
+// and optionally id (what a map_object_click dynamic action sees), title, body and geojson (a GeoJSON geometry or feature for
 // lines and areas; a GeoJSON point is a place), and weight (for a heat map).
 // With PostGIS installed, a geometry or geography column (WGS 84) is turned
 // into GeoJSON on the server (ST_AsGeoJSON), so no geojson column is needed.
@@ -59,11 +59,38 @@ interface Point {
   body: string;
   href: string | null;
   weight: number;
+  /** (161) the row's id column: what a map_object_click dynamic action's condition sees */
+  id?: string;
 }
+/** (159, CD-6) a shape layer's look: fixed in the layer's settings, or per row from columns of the same names */
+export interface ShapeStyle {
+  fill_color?: string;
+  stroke_color?: string;
+  stroke_width?: number;
+  opacity?: number;
+}
+const COLOR = /^#[0-9a-fA-F]{6}$/;
+/** The checked parts of a style (anything else is left out). */
+export function shapeStyle(x: unknown): ShapeStyle {
+  const s = (x && typeof x === 'object' ? x : {}) as Record<string, unknown>;
+  const out: ShapeStyle = {};
+  if (typeof s.fill_color === 'string' && COLOR.test(s.fill_color)) out.fill_color = s.fill_color;
+  if (typeof s.stroke_color === 'string' && COLOR.test(s.stroke_color)) out.stroke_color = s.stroke_color;
+  const w = Number(s.stroke_width);
+  if (s.stroke_width !== undefined && s.stroke_width !== null && Number.isFinite(w) && w >= 0 && w <= 20) out.stroke_width = w;
+  const o = Number(s.opacity);
+  if (s.opacity !== undefined && s.opacity !== null && Number.isFinite(o) && o >= 0 && o <= 1) out.opacity = o;
+  return out;
+}
+const SHAPE_KINDS = new Set(['lines', 'polygons', 'extruded']);
+const kindOf = (v: unknown): LayerDef['kind'] => (v === 'heat' || SHAPE_KINDS.has(v as string) ? (v as LayerDef['kind']) : 'markers');
+
 export interface LayerDef {
   name: string;
   source: string;
-  kind: 'markers' | 'heat';
+  /** (159) lines, polygons: GeoJSON / PostGIS shapes with a style; extruded: polygons shaded by a height column */
+  kind: 'markers' | 'heat' | 'lines' | 'polygons' | 'extruded';
+  style: ShapeStyle;
   cluster: boolean;
   link: Link | undefined;
   hidden: boolean;
@@ -78,7 +105,8 @@ export function layerDefs(r: Region): LayerDef[] {
   const first: LayerDef = {
     name: typeof r.config.name === 'string' && r.config.name.trim() ? r.config.name.trim() : (r.title ?? 'Map'),
     source: r.source ?? '',
-    kind: r.config.layer === 'heat' ? 'heat' : 'markers',
+    kind: kindOf(r.config.layer),
+    style: shapeStyle(r.config.style),
     cluster: r.config.cluster === true,
     link: r.config.link,
     hidden: false,
@@ -91,7 +119,8 @@ export function layerDefs(r: Region): LayerDef[] {
     .map((l: any, i: number): LayerDef => ({
       name: typeof l.name === 'string' && l.name.trim() ? l.name.trim() : `Layer ${i + 2}`,
       source: l.source,
-      kind: l.layer === 'heat' ? 'heat' : 'markers',
+      kind: kindOf(l.layer),
+      style: shapeStyle(l.style),
       cluster: l.cluster === true,
       link: l.link && typeof l.link === 'object' && Number.isInteger(l.link.page) ? l.link : undefined,
       hidden: l.hidden === true,
@@ -137,6 +166,7 @@ async function loadLayer(ctx: PageContext, def: LayerDef, g: PostGis | null, opt
     if ((Number.isNaN(lat) || Number.isNaN(lng)) && loc) [lat, lng] = [Number(loc[1]), Number(loc[2])];
     const title = toState(col(row, 'title')) ?? '';
     const body = toState(col(row, 'body')) ?? '';
+    const id = toState(col(row, 'id')) ?? undefined;
     let href: string | null = null;
     if (linkOk && link) {
       const items: Record<string, string> = {};
@@ -151,11 +181,30 @@ async function loadLayer(ctx: PageContext, def: LayerDef, g: PostGis | null, opt
       if (geometry?.type === 'Point' && Array.isArray(geometry.coordinates) && (Number.isNaN(lat) || Number.isNaN(lng)))
         // a point is a place (a marker, a heat spot, part of a cluster)
         [lng, lat] = geometry.coordinates.map(Number);
-      else if (geometry && typeof geometry === 'object') shapes.push({ type: 'Feature', geometry, properties: { title, body, href } });
+      else if (geometry && typeof geometry === 'object') {
+        // (159) a shape layer's style: the layer's, then the row's own columns
+        const style = SHAPE_KINDS.has(def.kind)
+          ? { ...def.style, ...shapeStyle({ fill_color: col(row, 'fill_color'), stroke_color: col(row, 'stroke_color'), stroke_width: col(row, 'stroke_width'), opacity: col(row, 'opacity') }) }
+          : undefined;
+        const h = num(col(row, 'height'));
+        shapes.push({ type: 'Feature', geometry, properties: { title, body, href, ...(id !== undefined ? { id } : {}), ...(style ? { style } : {}), ...(def.kind === 'extruded' && Number.isFinite(h) ? { height: h } : {}) } });
+      }
     }
+    // a shape layer draws only shapes
+    if (SHAPE_KINDS.has(def.kind)) continue;
     const w = num(col(row, 'weight'));
     const weight = Number.isFinite(w) && w > 0 ? w : Number.isNaN(w) ? 1 : 0;
-    if (Math.abs(lat) <= 90 && Math.abs(lng) <= 180) points.push({ lat, lng, title, body, href, weight });
+    if (Math.abs(lat) <= 90 && Math.abs(lng) <= 180) points.push({ lat, lng, title, body, href, weight, ...(id !== undefined ? { id } : {}) });
+  }
+  // (159) extruded: each polygon shaded by its height (from light to strong; no 3D view)
+  if (def.kind === 'extruded') {
+    const hs = shapes.map((f: any) => f.properties.height).filter((h): h is number => typeof h === 'number');
+    const [lo, hi] = hs.length ? [Math.min(...hs), Math.max(...hs)] : [0, 0];
+    for (const f of shapes as any[]) {
+      const h = f.properties.height;
+      const share = typeof h === 'number' && hi > lo ? (h - lo) / (hi - lo) : 0.5;
+      f.properties.style = { ...f.properties.style, opacity: Math.round((0.2 + 0.7 * share) * 100) / 100 };
+    }
   }
   return { points, shapes, truncated };
 }
@@ -250,7 +299,7 @@ export function parseTile(z: string, x: string, y: string) {
 export async function layerTile(ctx: PageContext, def: LayerDef, t: { z: number; x: number; y: number }) {
   const { points, shapes, truncated } = await loadLayer(ctx, def, await postgis(), { area: tileArea(t.z, t.x, t.y, 1 / 16), limit: MAX_TILE_ROWS });
   const features: TileFeature[] = [
-    ...points.map((p) => ({ geometry: { type: 'Point', coordinates: [p.lng, p.lat] }, properties: { title: p.title, body: p.body, href: p.href, weight: p.weight } })),
+    ...points.map((p) => ({ geometry: { type: 'Point', coordinates: [p.lng, p.lat] }, properties: { title: p.title, body: p.body, href: p.href, weight: p.weight, ...(p.id !== undefined ? { id: p.id } : {}) } })),
     ...(shapes as { geometry: TileFeature['geometry']; properties: TileFeature['properties'] }[]).map((s) => ({ geometry: s.geometry, properties: s.properties })),
   ];
   return { tile: encodeTile('places', t.z, t.x, t.y, features), truncated };

package/src/runtime/process-types.ts

@@ -0,0 +1,139 @@
+// (sprint 157, CD-4) Declarative process types APEX applications rely on (migration 150). Each one calls what pgkiln
+// already has: session state, user preferences, the geocoder, document templates, human tasks.
+import type { Process } from '../metadata.ts';
+import { geocode, geocoderUrl } from '../geocode.ts';
+import { substitute, toState, type PageContext } from './context.ts';
+import { renderDocument } from './documents.ts';
+
+const ITEM = /^[A-Z][A-Z0-9_]{0,99}$/;
+const NAME = /^[A-Z][A-Z0-9_]{0,59}$/;
+const isItem = (x: unknown) => typeof x === 'string' && ITEM.test(x);
+const items = (x: unknown) => Array.isArray(x) && x.every(isItem);
+const text = (x: unknown) => x === undefined || typeof x === 'string';
+
+export const DECLARATIVE_PROCESS_TYPES = new Set(['close_dialog', 'clear_session_state', 'reset_pagination', 'user_preferences', 'server_geocoding',
+  'print_report', 'human_task_create', 'human_task_manage', 'form_init']);
+const TASK_ACTIONS = ['approve', 'reject', 'complete', 'claim', 'release', 'delegate', 'cancel'];
+
+/** Problems with a declarative process's config (the builder shows them; running refuses them). */
+export function declarativeProblems(type: string, conf: unknown): string[] {
+  const c = (conf ?? {}) as Record<string, any>;
+  const out: string[] = [];
+  switch (type) {
+    case 'close_dialog':
+      if (c.items !== undefined && !items(c.items)) out.push('"items" is a list of item names, e.g. ["P5_ID"].');
+      break;
+    case 'clear_session_state':
+      if (c.items !== undefined && !items(c.items)) out.push('"items" is a list of item names.');
+      if (c.pages !== undefined && !(Array.isArray(c.pages) && c.pages.every((n: unknown) => Number.isInteger(n) && (n as number) > 0))) out.push('"pages" is a list of page numbers.');
+      if (c.all !== undefined && typeof c.all !== 'boolean') out.push('"all" is true or false.');
+      if (!c.items && !c.pages && !c.all) out.push('Name "items", "pages" or "all": true.');
+      break;
+    case 'user_preferences':
+      if (!['set', 'reset'].includes(c.action ?? 'set')) out.push('"action" is set or reset.');
+      if (typeof c.preference !== 'string' || !NAME.test(c.preference.toUpperCase())) out.push('"preference" is a name, e.g. DEFAULT_DEPT.');
+      if ((c.action ?? 'set') === 'set' && !isItem(c.item)) out.push('"item" names the item whose value is stored.');
+      break;
+    case 'server_geocoding':
+      if (!isItem(c.address_item)) out.push('"address_item" is the item with the address.');
+      if (!isItem(c.coordinates_item)) out.push('"coordinates_item" is the item that gets "lat,lng".');
+      if (c.country !== undefined && !(typeof c.country === 'string' && /^[a-z]{2}(,[a-z]{2})*$/i.test(c.country))) out.push('"country" is a country code, e.g. nl.');
+      break;
+    case 'print_report':
+      if (typeof c.document !== 'string' || !NAME.test(c.document.toUpperCase())) out.push('"document" names a document template or report query.');
+      break;
+    case 'human_task_create':
+      if (typeof c.definition !== 'string' || !NAME.test(c.definition.toUpperCase())) out.push('"definition" names a task definition, e.g. LEAVE_APPROVAL.');
+      if (!text(c.detail_pk)) out.push('"detail_pk" is text, e.g. "&P7_ID.".');
+      if (c.parameters !== undefined && (typeof c.parameters !== 'object' || c.parameters === null || Array.isArray(c.parameters) || Object.values(c.parameters).some((v) => typeof v !== 'string')))
+        out.push('"parameters" maps parameter names to values, e.g. {"DAYS": "&P7_DAYS."}.');
+      if (c.id_item !== undefined && !isItem(c.id_item)) out.push('"id_item" is an item name.');
+      break;
+    case 'human_task_manage':
+      if (!TASK_ACTIONS.includes(c.action)) out.push(`"action" is one of ${TASK_ACTIONS.join(', ')}.`);
+      if (typeof c.task !== 'string' || !c.task) out.push('"task" is the task id, e.g. "&P8_TASK_ID.".');
+      if (c.action === 'complete' && (typeof c.outcome !== 'string' || !NAME.test(c.outcome.toUpperCase()))) out.push('"outcome" names the outcome, e.g. APPROVED.');
+      if (c.action === 'delegate' && (typeof c.to !== 'string' || !c.to)) out.push('"to" is the user it goes to, e.g. "&P8_TO.".');
+      if (!text(c.comment)) out.push('"comment" is text.');
+      break;
+  }
+  return out;
+}
+
+/** Run a declarative process; its success message (or a default) is the answer. */
+export async function runDeclarative(ctx: PageContext, p: Process, assignable: Set<string>): Promise<string | null> {
+  const conf = (p.config ?? {}) as Record<string, any>;
+  const problems = declarativeProblems(p.type, conf);
+  if (problems.length) throw new Error(`Process "${p.name}": ${problems.join(' ')}`);
+  const c = ctx.client!;
+  const value = (s: unknown) => (typeof s === 'string' ? substitute(s, ctx, (x) => x) : null);
+  const state = ctx.session.state;
+  const assign = (name: string, v: string | null) => {
+    if (!assignable.has(name)) throw new Error(`Process "${p.name}": ${name} is not an item of this page or an application item.`);
+    state[name] = v;
+  };
+  switch (p.type) {
+    case 'form_init':
+      return null;
+    case 'close_dialog':
+      ctx.closeDialog = Object.fromEntries(((conf.items ?? []) as string[]).map((n) => [n, state[n] ?? '']));
+      return p.success_message;
+    case 'reset_pagination':
+      ctx.resetPagination = true;
+      return p.success_message;
+    case 'clear_session_state': {
+      const names = new Set<string>(conf.items ?? []);
+      const prefixes = ((conf.pages ?? []) as number[]).map((n) => `P${n}_`);
+      for (const k of Object.keys(state)) {
+        if (k.startsWith('__')) continue;
+        if (names.has(k) || prefixes.some((x) => k.startsWith(x)) || (conf.all === true && (/^P\d+_/.test(k) || ctx.app.app_items.includes(k)))) state[k] = null;
+      }
+      return p.success_message;
+    }
+    case 'user_preferences': {
+      // the public user has no preferences (as meta.get_preference): nothing to store
+      if (ctx.user === 'nobody') return null;
+      const name = String(conf.preference).toUpperCase();
+      if ((conf.action ?? 'set') === 'reset') await c.query('select meta.remove_preference($1)', [name]);
+      else await c.query('select meta.set_preference($1, $2)', [name, state[conf.item] ?? null]);
+      return p.success_message;
+    }
+    case 'server_geocoding': {
+      const address = (state[conf.address_item] ?? '').trim();
+      if (!address) return null;
+      if (!geocoderUrl()) throw new Error(ctx.locale.t('process.no_geocoder'));
+      const [first] = await geocode(address, { language: ctx.locale.lang, country: conf.country ?? null });
+      if (!first) throw new Error(ctx.locale.t('process.address_not_found', { address }));
+      assign(conf.coordinates_item, `${first.lat.toFixed(6)},${first.lon.toFixed(6)}`);
+      return p.success_message;
+    }
+    case 'print_report': {
+      const doc = await renderDocument(ctx, String(conf.document), true);
+      // the first file of a request wins (as for download processes)
+      ctx.download ??= 'download' in doc ? doc.download : { content: doc.file, name: doc.name, type: doc.type, inline: false };
+      return null;
+    }
+    case 'human_task_create': {
+      const params = Object.fromEntries(Object.entries((conf.parameters ?? {}) as Record<string, string>).map(([k, v]) => [k.toUpperCase(), value(v)]));
+      const id = (await c.query('select meta.create_task($1, $2, $3::jsonb)::text as id', [String(conf.definition).toUpperCase(), value(conf.detail_pk) || null, JSON.stringify(params)])).rows[0].id as string;
+      if (conf.id_item) assign(conf.id_item, toState(id));
+      return p.success_message ?? ctx.locale.t('process.task_created', { id });
+    }
+    case 'human_task_manage': {
+      const id = (value(conf.task) ?? '').trim();
+      if (!/^\d{1,18}$/.test(id)) throw new Error(ctx.locale.t('process.no_task'));
+      const comment = value(conf.comment) || null;
+      switch (conf.action) {
+        case 'approve': await c.query('select meta.complete_task($1::bigint, $2, $3)', [id, 'APPROVED', comment]); break;
+        case 'reject': await c.query('select meta.complete_task($1::bigint, $2, $3)', [id, 'REJECTED', comment]); break;
+        case 'complete': await c.query('select meta.complete_task($1::bigint, $2, $3)', [id, String(conf.outcome).toUpperCase(), comment]); break;
+        case 'claim': await c.query('select meta.claim_task($1::bigint)', [id]); break;
+        case 'release': await c.query('select meta.release_task($1::bigint)', [id]); break;
+        case 'delegate': await c.query('select meta.delegate_task($1::bigint, $2)', [id, value(conf.to)]); break;
+        case 'cancel': await c.query('select meta.cancel_task($1::bigint, $2)', [id, comment]); break;
+      }
+      return p.success_message;
+    }
+  }
+  return null;
+}

package/src/runtime/processes.ts

@@ -1,3 +1,4 @@
+import { declarativeProblems, DECLARATIVE_PROCESS_TYPES } from './process-types.ts';
 import { zipSync, type Zippable } from 'fflate';
 import { applyBinds } from '../binds.ts';
 import { esc } from '../html.ts';
@@ -248,6 +249,7 @@ export function processProblems(type: string, conf: unknown): string[] {
   if (type === 'workflow') return workflowProblems(conf);
   if (type === 'send_push') return sendPushProblems(conf);
   if (type === 'send_email') return sendEmailProblems(conf);
+  if (DECLARATIVE_PROCESS_TYPES.has(type)) return declarativeProblems(type, conf);
   return [];
 }
 

package/src/runtime/regions.ts

@@ -1,3 +1,4 @@
+import { renderWorkflowDiagram } from './workflow-diagram.ts';
 import type { QueryResult } from 'pg';
 import { ganttEditable } from './gantt-move.ts';
 import { applyBinds } from '../binds.ts';
@@ -379,6 +380,9 @@ async function renderBody(ctx: PageContext, r: Region, hidden: Set<string>): Pro
     case 'workflows':
       body = await renderWorkflows(ctx, r);
       break;
+    case 'workflow_diagram':
+      body = await renderWorkflowDiagram(ctx, r);
+      break;
     case 'map':
       body = await renderMap(ctx, r);
       break;

package/src/runtime/render.ts

@@ -1,3 +1,4 @@
+import { compareValues, safeStyles } from './da-styles.ts';
 import { randomUUID } from 'node:crypto';
 import { urlChecksum } from '../security.ts';
 import { pwaBody, pwaHead } from './pwa.ts';
@@ -29,6 +30,9 @@ import { sessionLimits } from '../session.ts';
 
 const list = (s: string | null) => (s ?? '').split(',').map((x) => x.trim().toUpperCase()).filter(Boolean);
 
+/** (161) events of grid, calendar, map and tree regions (their value: see public/app.js, pgkiln:component) */
+export const COMPONENT_EVENTS = new Set(['grid_row_init', 'grid_save', 'calendar_date_select', 'calendar_view_change', 'map_object_click', 'map_change', 'tree_selection_change']);
+
 /** Client-side definition of the page's dynamic actions (never includes SQL). */
 function dynamicActionsJson(ctx: PageContext) {
   return ctx.page.dynamic_actions
@@ -50,6 +54,11 @@ function dynamicActionsJson(ctx: PageContext) {
       fn: d.action === 'execute_javascript' && /^[A-Za-z_$][\w$.-]{0,99}$/.test(d.code?.trim() ?? '') ? d.code!.trim() : null,
       // plugin: the plug-in's name and attribute values (only a plug-in of the application)
       ...(d.action === 'plugin' ? pluginAction(ctx, d.code, d.config) : {}),
+      // (156) set_style: checked properties and values; open_report_dialog: the dialog's key (checked by the database)
+      ...(d.action === 'set_style' ? { styles: safeStyles(d.config) } : {}),
+      // (161) set_value without SQL on a component event: the event's value (a date, node id, …) into the affected items
+      ...(d.action === 'set_value' && !d.code?.trim() && COMPONENT_EVENTS.has(d.event) ? { eventValue: true } : {}),
+      ...(d.action === 'open_report_dialog' ? { dialog: /^[a-z]{3,10}$/.test(d.code?.trim() ?? '') ? d.code!.trim() : null } : {}),
     }));
 
 function pluginAction(ctx: PageContext, name: string | null, config: Record<string, any> | null | undefined) {
@@ -65,6 +74,12 @@ function conditionHolds(type: string | null, expected: string | null, value: str
     case 'in_list': return (expected ?? '').split(',').map((x) => x.trim()).includes(value);
     case 'is_null': return value === '';
     case 'is_not_null': return value !== '';
+    // (156) greater / less: numbers as numbers, else text (ISO dates sort as text); not_in_list
+    case 'greater': return value !== '' && compareValues(value, expected ?? '') > 0;
+    case 'greater_equal': return value !== '' && compareValues(value, expected ?? '') >= 0;
+    case 'less': return value !== '' && compareValues(value, expected ?? '') < 0;
+    case 'less_equal': return value !== '' && compareValues(value, expected ?? '') <= 0;
+    case 'not_in_list': return !(expected ?? '').split(',').map((x) => x.trim()).includes(value);
     default: return true;
   }
 }
@@ -412,18 +427,19 @@ export async function renderPage(ctx: PageContext) {
       ${ctx.detached}
     </div>
     <script type="application/json" id="pgkiln-meta">${raw(
-      JSON.stringify({ csrf: ctx.session.csrf_token, das, texts: clientTexts(ctx), dialogs: dialogShapes(ctx), ...timeZoneMeta(ctx), session: sessionMeta(ctx) }).replace(/</g, '\\u003c'),
+      JSON.stringify({ csrf: ctx.session.csrf_token, das, ...(ctx.savedGrids?.length ? { savedGrids: ctx.savedGrids } : {}), texts: clientTexts(ctx), dialogs: dialogShapes(ctx), ...timeZoneMeta(ctx), session: sessionMeta(ctx) }).replace(/</g, '\\u003c'),
     )}</script>`;
   return chrome(ctx, main, title);
 }
 
 /** Response to a successful submit inside a dialog: tells the opener to close it. */
-export function dialogClosePage(ctx: PageContext) {
+/** (157) `items`: the values a close_dialog process hands to the page below (items of the same name there are set). */
+export function dialogClosePage(ctx: PageContext, items?: Record<string, string>) {
   return documentShell(
     ctx.app.name,
     html`<main class="t-dialog-main"><p>${ctx.locale.t('dialog.done')} <a href="${ctx.base}/${ctx.app.home_page}">${ctx.locale.t('dialog.continue')}</a></p></main>`,
     't-dialog-page',
-    { 'data-dialog-close': '1', 'data-dialog-page': String(ctx.page.page_no) },
+    { 'data-dialog-close': '1', 'data-dialog-page': String(ctx.page.page_no), ...(items && Object.keys(items).length ? { 'data-dialog-items': JSON.stringify(items) } : {}) },
     '',
     { lang: ctx.locale.lang, dir: ctx.locale.dir, theme: ctx.locale.theme, style: ctx.locale.style },
   );

package/src/runtime/routes.ts

@@ -443,6 +443,8 @@ export async function runtimeRoutes(app: FastifyInstance) {
     if (flash) ctx.messages.push(flash);
     const flashError = takeFlash(ctx.session, '__FLASH_ERROR');
     if (flashError) ctx.errors.page.push(flashError);
+    const saved = takeFlash(ctx.session, '__GRID_SAVED');
+    if (typeof saved === 'string') ctx.savedGrids = saved.split(',').map(Number).filter(Number.isInteger);
     // Actions → Download CSV / Excel / PDF: r<region id>_csv=1, _xlsx=1 or _pdf=1
     const downloadKey = [...ctx.params.keys()].find((k) => /^r\d+_(csv|xlsx|pdf)$/.test(k));
     // a document template: ?doc=NAME (see documents.ts)
@@ -629,10 +631,12 @@ export async function runtimeRoutes(app: FastifyInstance) {
       return reply.headers(downloadHeaders(ctx.download)).send(ctx.download.content);
     }
     if (messages.length) ctx.session.state.__FLASH = messages.join(' ');
+    // (161) the page that comes back runs the saved grids' grid_save dynamic actions
+    if (ctx.savedGrids?.length && !ctx.dialog) ctx.session.state.__GRID_SAVED = ctx.savedGrids.join(',');
     await saveState(ctx.session);
-    if (ctx.dialog) return reply.type('text/html').send(dialogClosePage(ctx));
+    if (ctx.dialog) return reply.type('text/html').send(dialogClosePage(ctx, ctx.closeDialog));
     // (sprint 54) a grid's Save comes back to the grid's search, page, sort and view
-    const back = branchTo || button.target_page ? '' : gridReturn(ctx, button.name);
+    const back = branchTo || button.target_page || ctx.resetPagination ? '' : gridReturn(ctx, button.name);
     return reply.redirect(branchTo ?? (button.target_page ? `${ctx.base}/${button.target_page}` : back ? `${self}${self.includes('?') ? '&' : '?'}${back}` : self), 303);
   });
 

package/src/runtime/tree.ts

@@ -64,14 +64,15 @@ export async function renderTree(ctx: PageContext, r: Region): Promise<Raw> {
         });
       label = html`<a ${linkAttrs(ctx, link.page, items)}>${label}</a>`;
     }
-    if (!n.children.length) return html`<li class="tree-leaf">${label}</li>`;
+    // (161) data-node: what a tree_selection_change dynamic action's condition sees
+    if (!n.children.length) return html`<li class="tree-leaf" data-node="${n.id}">${label}</li>`;
     const open = depth < expanded ? raw(' open') : '';
     const children = html`<ul>${n.children.map((ch) => draw(ch, depth + 1))}</ul>`;
     // a linked branch: the link is a row of its own and the disclosure only toggles (no link inside <summary>)
     if (linkOk && link)
-      return html`<li class="tree-branch"><span class="tree-row">${label} <span class="tree-count" aria-hidden="true">${n.children.length}</span></span>
+      return html`<li class="tree-branch" data-node="${n.id}"><span class="tree-row">${label} <span class="tree-count" aria-hidden="true">${n.children.length}</span></span>
         <details${open}><summary><span class="sr-only">${n.label} (${n.children.length})</span></summary>${children}</details></li>`;
-    return html`<li><details${open}><summary>${label} <span class="tree-count">${n.children.length}</span></summary>
+    return html`<li data-node="${n.id}"><details${open}><summary>${label} <span class="tree-count">${n.children.length}</span></summary>
       ${children}</details></li>`;
   };
   return html`<ul class="tree-view">${roots.map((n) => draw(n, 0))}</ul>`;

package/src/runtime/workflow-diagram.ts

@@ -0,0 +1,45 @@
+// (sprint 160, CD-7) Workflow Diagram region (APEX 24.2+): one workflow instance drawn as its steps, the ones it went
+// through (green), where it is now (blue) and a failed step (red); each step's tooltip says when it was reached and
+// what happened. config {"instance_item": "P9_WORKFLOW_ID"}. The instance comes through meta.workflows, as the
+// application's role: only workflows the user started or administers (the Workflow Console's rule). Server-rendered SVG.
+import { owner, savepoint } from '../db.ts';
+import { html, type Raw } from '../html.ts';
+import type { Region } from '../metadata.ts';
+import { workflowDiagram, type Step } from '../workflow.ts';
+import { publicError, type PageContext } from './context.ts';
+import { cell } from './report.ts';
+
+export async function renderWorkflowDiagram(ctx: PageContext, r: Region): Promise<Raw> {
+  const t = ctx.locale.t;
+  const itemName = typeof r.config.instance_item === 'string' ? r.config.instance_item.toUpperCase() : '';
+  const id = (itemName ? (ctx.session.state[itemName] ?? '') : '').trim();
+  if (!/^\d{1,18}$/.test(id)) return html`<p class="empty">${r.config.empty ?? t('workflows.none')}</p>`;
+  const c = ctx.client!;
+  let w: { id: string; title: string; state: string; current_step: string | null; error: string | null; active_steps: string[] } | undefined;
+  let events: { at: string; step: string | null; event: string; detail: string | null }[] = [];
+  try {
+    w = (await savepoint(c, () => c.query('select id::text, title, state, current_step, error, active_steps from meta.workflows where id = $1::bigint', [id]))).rows[0];
+    if (w) events = (await savepoint(c, () => c.query('select at::text, step, event, detail from meta.workflow_events where workflow_id = $1::bigint order by at, id', [id]))).rows;
+  } catch (e) {
+    return html`<div class="alert alert-error" role="alert">${await publicError(ctx, e, `workflow diagram "${r.title ?? r.id}"`)}</div>`;
+  }
+  // not one the user may see (or none): the same as no instance
+  if (!w) return html`<p class="empty">${r.config.empty ?? t('workflows.none')}</p>`;
+  // the steps of its version: only after the view let this user see the instance (the steps hold SQL)
+  const steps = (await owner.query<{ steps: Step[] }>('select steps from meta.workflow where id = $1::bigint and app_id = $2', [id, ctx.app.id])).rows[0]?.steps ?? [];
+  const reached = new Set(events.filter((e) => e.step).map((e) => e.step!));
+  const active = w.state === 'completed' || w.state === 'terminated' ? [] : w.active_steps.length ? w.active_steps : w.current_step ? [w.current_step] : [];
+  const failed = w.state === 'faulted' ? active : [];
+  const done = [...reached].filter((s) => !active.includes(s));
+  const notes = new Map<string, string>();
+  // events without a step (started, terminated) belong to the first step's history
+  for (const e of events) {
+    const step = e.step ?? steps[0]?.name;
+    if (step) notes.set(step, [notes.get(step), `${cell(e.at, 1184, ctx.locale.format)}: ${e.event}${e.detail ? ` (${e.detail})` : ''}`].filter(Boolean).join('\n'));
+  }
+  return html`<div class="wf-wrap wf-instance" data-state="${w.state}">
+    <p class="muted u-mt0">${w.title} · ${t(`workflows.state.${w.state}`)}</p>
+    ${w.error ? html`<div class="alert alert-error" role="alert">${w.error}</div>` : ''}
+    ${workflowDiagram(steps, { active: failed.length ? [] : active, failed, done, notes, id: `r${r.id}` })}
+  </div>`;
+}

package/src/workflow.ts

@@ -917,12 +917,16 @@ export async function startWorkflowRunner() {
  * marks the steps an instance is at (several with parallel branches); `id`
  * keeps the arrow marker unique when a page shows several diagrams.
  */
-export function workflowDiagram(steps: Step[], opts: { active?: string[]; id?: string; standalone?: { title: string } } = {}): Raw {
+export function workflowDiagram(steps: Step[], opts: { active?: string[]; id?: string; standalone?: { title: string };
+  /** (160) the steps the instance went through, a step that failed, a tooltip per step (who and when) */
+  done?: string[]; failed?: string[]; notes?: Map<string, string> } = {}): Raw {
   if (!Array.isArray(steps) || !steps.length || steps.some((s) => !s || typeof s !== 'object' || typeof s.name !== 'string')) return html``;
   // (123) the export is an XML file: no control characters (the template escapes the rest)
   const txt = (v: unknown) => String(v ?? '').replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\ufffe\uffff]/g, '');
   const marker = `wf-arrow${opts.id ? `-${opts.id}` : ''}`;
   const active = new Set(opts.active ?? []);
+  const done = new Set(opts.done ?? []);
+  const failed = new Set(opts.failed ?? []);
   // levels: the longest path from the first step (cycles are cut)
   const level = new Map<string, number>([[steps[0].name, 0]]);
   const edges: { from: string; to: string; label: string; branch?: boolean }[] = [];
@@ -977,7 +981,9 @@ export function workflowDiagram(steps: Step[], opts: { active?: string[]; id?: s
     })}
     ${steps.map((s) => {
       const p = pos.get(s.name)!;
-      return html`<g class="wf-node wf-${TYPES.includes(s.type) ? s.type : 'unknown'}${active.has(s.name) ? ' wf-active' : ''}"><rect x="${p.x}" y="${p.y}" width="${W}" height="${H}" rx="${s.type === 'parallel' || s.type === 'join' ? 20 : 8}"/>
+      const note = opts.notes?.get(s.name);
+      const mark = failed.has(s.name) ? ' wf-failed' : active.has(s.name) ? ' wf-active' : done.has(s.name) ? ' wf-done' : '';
+      return html`<g class="wf-node wf-${TYPES.includes(s.type) ? s.type : 'unknown'}${mark}">${note ? html`<title>${txt(note)}</title>` : ''}<rect x="${p.x}" y="${p.y}" width="${W}" height="${H}" rx="${s.type === 'parallel' || s.type === 'join' ? 20 : 8}"/>
         <text x="${p.x + W / 2}" y="${p.y + 18}" class="wf-name">${txt(s.name)}</text>
         <text x="${p.x + W / 2}" y="${p.y + 34}" class="wf-type">${txt(typeText(s))}</text></g>`;
     })}
@@ -996,6 +1002,8 @@ const SVG_STYLE = `
 .wf-send_mail rect { stroke: #17794a; stroke-width: 2; }
 .wf-draft rect { fill: #fafafa; stroke: #8a8f98; stroke-width: 1.5; stroke-dasharray: 6 4; }
 .wf-active rect { fill: #e6efff; stroke: #2f6fde; stroke-width: 3; }
+.wf-done rect { fill: #e7f5ed; stroke: #17794a; }
+.wf-failed rect { fill: #fde7e4; stroke: #b42318; stroke-width: 3; }
 text { font-family: system-ui, -apple-system, "Segoe UI", Roboto, sans-serif; }
 .wf-name { fill: #1d2129; font-size: 12px; font-weight: 600; text-anchor: middle; }
 .wf-type { fill: #5d6470; font-size: 10px; text-anchor: middle; }