pgkiln 0.80.0 → 0.82.0

package/src/metadata.ts

@@ -164,7 +164,7 @@ export interface Region {
   title: string | null;
   /** (0.31, 073) optional, unique on the page */
   static_id?: string | null;
-  type: 'login' | 'report' | 'form' | 'chart' | 'cards' | 'static' | 'grid' | 'calendar' | 'dynamic' | 'facets' | 'tasks' | 'workflows' | 'map' | 'tree' | 'template_component' | 'smart_filters' | 'display_selector' | 'list' | 'data_reporter' | 'ai_assistant' | 'plugin' | 'url' | 'search' | 'form_designer' | 'classic_report' | 'breadcrumb' | 'help_text';
+  type: 'login' | 'report' | 'form' | 'chart' | 'cards' | 'static' | 'grid' | 'calendar' | 'dynamic' | 'facets' | 'tasks' | 'workflows' | 'map' | 'tree' | 'template_component' | 'smart_filters' | 'display_selector' | 'list' | 'data_reporter' | 'ai_assistant' | 'plugin' | 'url' | 'search' | 'form_designer' | 'classic_report' | 'breadcrumb' | 'help_text' | 'workflow_diagram';
   source: string | null;
   table_name: string | null;
   pk_column: string | null;
@@ -172,6 +172,9 @@ export interface Region {
   columns: number;
   template: 'standard' | 'plain' | 'collapsible' | 'hero' | 'title_bar' | 'buttons_container' | 'inline_dialog' | 'inline_drawer' | 'wizard';
   condition: string | null;
+  /** (147) the condition's type (null: `condition` is SQL) and value */
+  condition_type?: ConditionType | null;
+  condition_value?: string | null;
   authz: string | null;
   config: Record<string, any>;
   /** a REST data source the region reads (its source, if any, is SQL over the CTE "rest") */
@@ -189,7 +192,9 @@ export type ItemType =
   | 'richtext' | 'markdown' | 'rating' | 'combobox' | 'daterange' | 'qrcode' | 'plugin'
   | 'shuttle' | 'select_one' | 'select_many'
   // (086) display image, geocoded address
-  | 'image' | 'address';
+  | 'image' | 'address'
+  // (151) image upload and autocomplete (presets of file and combobox, see presetItem), percent graph, display map
+  | 'image_upload' | 'autocomplete' | 'percent_graph' | 'display_map';
 
 export interface Item {
   id: number;
@@ -206,6 +211,10 @@ export interface Item {
   required: boolean;
   help: string | null;
   readonly_condition: string | null;
+  /** (147) a server-side condition: when false the item is not rendered and not accepted */
+  condition_type?: ConditionType | null;
+  condition_expr?: string | null;
+  condition_value?: string | null;
   authz: string | null;
   config: Record<string, any>;
 }
@@ -222,6 +231,9 @@ export interface Button {
   document?: string | null;
   target_items: Record<string, string>;
   condition: string | null;
+  /** (147) the condition's type (null: `condition` is SQL) and value */
+  condition_type?: ConditionType | null;
+  condition_value?: string | null;
   authz: string | null;
   hot: boolean;
   confirm: string | null;
@@ -248,9 +260,20 @@ export interface MenuEntry {
   icon?: string;
 }
 
-/** A condition of a computation or branch (see migration 029). */
+/** (147) The server-side condition types every component shares (meta.condition_ok). */
+export const CONDITION_TYPES = [
+  'sql', 'exists', 'not_exists', 'function_body',
+  'request_in', 'request_not_in',
+  'item_null', 'item_not_null', 'item_zero', 'item_not_zero', 'item_null_or_zero', 'item_not_null_or_zero',
+  'item_equals', 'item_not_equals', 'item_equals_item', 'item_not_equals_item', 'item_in_list', 'item_not_in_list',
+  'page_in', 'page_not_in', 'page_is_dialog', 'page_is_not_dialog',
+  'user_signed_in', 'user_public', 'language_in', 'language_not_in', 'always', 'never',
+] as const;
+export type ConditionType = (typeof CONDITION_TYPES)[number];
+
+/** A server-side condition (migrations 029, 147). */
 export interface Condition {
-  condition_type: 'sql' | 'exists' | 'not_exists' | 'item_null' | 'item_not_null' | 'item_equals' | 'item_not_equals' | 'request_in' | null;
+  condition_type: ConditionType | null;
   condition_expr: string | null;
   condition_value: string | null;
 }
@@ -295,9 +318,11 @@ export interface DynamicAction {
     /** (085) */
     | 'after_refresh' | 'selection_change' | 'focus' | 'blur' | 'key_release' | 'before_submit' | 'custom'
     /** (124) a menu button's entry {"action": NAME} was chosen (trigger: entry or menu button names) */
-    | 'menu_entry';
+    | 'menu_entry'
+    /** (149) */
+    | 'double_click' | 'key_down' | 'key_press' | 'mouse_enter' | 'mouse_leave' | 'select' | 'resize' | 'scroll' | 'page_unload' | 'before_refresh' | 'facets_change';
   trigger_element: string | null;
-  condition_type: 'equals' | 'not_equals' | 'in_list' | 'is_null' | 'is_not_null' | null;
+  condition_type: 'equals' | 'not_equals' | 'in_list' | 'is_null' | 'is_not_null' | 'greater' | 'greater_equal' | 'less' | 'less_equal' | 'not_in_list' | null;
   condition_value: string | null;
   action: 'show' | 'hide' | 'enable' | 'disable' | 'set_value' | 'execute_sql' | 'refresh_region' | 'refresh_item' | 'alert' | 'submit'
     | 'set_focus' | 'add_class' | 'remove_class' | 'show_success' | 'show_error' | 'clear_errors' | 'ai_generate'
@@ -310,7 +335,9 @@ export interface DynamicAction {
     /** (085) */
     | 'confirm' | 'close_dialog' | 'cancel_dialog' | 'clear' | 'open_region' | 'close_region' | 'download' | 'print' | 'current_position' | 'share'
     /** (124) a modal "please wait" overlay (message: its text) until remove_wait_popup or the next page */
-    | 'wait_popup' | 'remove_wait_popup';
+    | 'wait_popup' | 'remove_wait_popup'
+    /** (149) */
+    | 'cancel_event' | 'set_style' | 'collapse_tree' | 'expand_tree' | 'show_ai_assistant' | 'trigger_geocoding' | 'open_report_dialog';
   affected_items: string | null;
   affected_region_id: number | null;
   code: string | null;
@@ -321,22 +348,40 @@ export interface DynamicAction {
   /** (069) a plug-in action's attribute values: {"attributes": {…}} */
   config?: Record<string, any> | null;
   authz: string | null;
+  /** (147) a server-side condition: when false the dynamic action isn't on the page */
+  server_condition_type?: ConditionType | null;
+  server_condition_expr?: string | null;
+  server_condition_value?: string | null;
 }
 
 export interface Validation {
   id: number;
   name: string;
   item_name: string | null;
-  type: 'not_null' | 'sql' | 'regex';
+  /** (148) APEX's validation types (migration 148) */
+  type: 'sql' | 'exists' | 'not_exists' | 'function_body' | 'function_error'
+    | 'not_null' | 'not_null_or_zero' | 'not_zero' | 'no_spaces' | 'alphanumeric' | 'numeric' | 'valid_date' | 'valid_timestamp'
+    | 'equals' | 'not_equals' | 'in_list' | 'not_in_list' | 'chars_only' | 'chars_any' | 'chars_none' | 'regex';
   expression: string | null;
   message: string;
   when_button: string | null;
+  /** (148) an authorization scheme; Always execute (also for DELETE); where the error shows */
+  authz?: string | null;
+  always_execute?: boolean;
+  display_location?: 'inline_and_notification' | 'inline' | 'notification' | null;
+  /** (147) a server-side condition: when false the validation is skipped */
+  condition_type?: ConditionType | null;
+  condition_expr?: string | null;
+  condition_value?: string | null;
 }
 
 export interface Process {
   id: number;
   name: string;
-  type: 'form_dml' | 'grid_dml' | 'sql' | 'data_load' | 'invoke_api' | 'download' | 'chain' | 'workflow' | 'ai_generate' | 'plugin' | 'send_push' | 'send_email';
+  type: 'form_dml' | 'grid_dml' | 'sql' | 'data_load' | 'invoke_api' | 'download' | 'chain' | 'workflow' | 'ai_generate' | 'plugin' | 'send_push' | 'send_email'
+    /** (150) */
+    | 'close_dialog' | 'clear_session_state' | 'reset_pagination' | 'user_preferences' | 'server_geocoding' | 'print_report'
+    | 'human_task_create' | 'human_task_manage' | 'form_init';
   region_id: number | null;
   code: string | null;
   config: Record<string, unknown> | null;
@@ -420,7 +465,25 @@ export async function loadApp(alias: string) {
   );
 }
 
+/**
+ * (151, CD-5) APEX's item types that are presets of pgkiln's: an Image Upload is a file item for pictures (image/*,
+ * cropping, a maximum size before upload), a Text Field with autocomplete a one-value combobox. The runtime sees the
+ * preset (every file and list check applies); the builder and exports keep the type as chosen.
+ */
+export function presetItem(i: Item): Item {
+  if (i.type === 'image_upload')
+    return { ...i, type: 'file', config: { accept: 'image/*', crop: 'free', max_px: 1600, ...(i.config ?? {}), preset: 'image_upload' } };
+  if (i.type === 'autocomplete') return { ...i, type: 'combobox', config: { ...(i.config ?? {}), multiple: false, preset: 'autocomplete' } };
+  return i;
+}
+
 export async function loadPage(appId: number, pageNo: number) {
+  const page = await loadPageRows(appId, pageNo);
+  if (page) page.items = page.items.map(presetItem);
+  return page;
+}
+
+function loadPageRows(appId: number, pageNo: number) {
   return runtime.one<Page>(
     `select p.id, p.app_id, p.page_no, p.name, p.title, p.requires_auth, p.parent_page, p.mode,
             p.protection, p.authz, p.warn_unsaved, p.page_template, p.help,

package/src/runtime/authz.ts

@@ -1,10 +1,11 @@
 import { secondStepWithin } from '../account-mfa.ts';
 import { applyBinds } from '../binds.ts';
-import type { AuthzScheme } from '../metadata.ts';
+import type { AuthzScheme, Condition } from '../metadata.ts';
 import { savepoint } from '../db.ts';
 import { bindValues, publicError, stripSemicolon, type PageContext, type Visibility } from './context.ts';
 import { saveButton, saveRequest } from './grid.ts';
 import { selectionOf } from './report.ts';
+import { conditionHolds, conditionOf, serverConditionOf } from './logic.ts';
 
 export class Forbidden extends Error {}
 /** (sprint 131) The page needs a second step more recent than the session's: ask for one, then come back. */
@@ -90,14 +91,15 @@ export async function pageAllowed(ctx: PageContext, pageNo: number) {
 export async function computeVisibility(ctx: PageContext): Promise<Visibility> {
   const vis: Visibility = { regions: new Set(), items: new Set(), editable: new Set(), buttons: new Map(), dynamicActions: new Set() };
   for (const r of ctx.page.regions)
-    if ((await isAuthorized(ctx, r.authz)) && (await sqlTrue(ctx, r.condition, `condition of region "${r.title ?? r.id}"`)))
+    if ((await isAuthorized(ctx, r.authz)) && (await conditionHolds(ctx, conditionOf(r), `condition of region "${r.title ?? r.id}"`)))
       vis.regions.add(r.id);
 
   for (const i of ctx.page.items) {
     if (i.region_id !== null && !vis.regions.has(i.region_id)) continue;
     if (!(await isAuthorized(ctx, i.authz))) continue;
+    if (i.condition_type && !(await conditionHolds(ctx, i as Condition, `condition of item ${i.name}`))) continue;
     vis.items.add(i.name);
-    if (i.type === 'hidden' || i.type === 'display' || i.type === 'qrcode' || i.type === 'image') continue;
+    if (i.type === 'hidden' || i.type === 'display' || i.type === 'qrcode' || i.type === 'image' || i.type === 'percent_graph' || i.type === 'display_map') continue;
     // fail closed: a broken read-only condition makes the item read-only
     if (i.readonly_condition && (await sqlTrue(ctx, i.readonly_condition, `read-only condition of ${i.name}`, true))) continue;
     vis.editable.add(i.name);
@@ -112,7 +114,7 @@ export async function computeVisibility(ctx: PageContext): Promise<Visibility> {
   for (const b of ctx.page.buttons) {
     if (b.region_id !== null && !vis.regions.has(b.region_id)) continue;
     if (!(await isAuthorized(ctx, b.authz))) continue;
-    if (!(await sqlTrue(ctx, b.condition, `condition of button ${b.name}`))) continue;
+    if (!(await conditionHolds(ctx, conditionOf(b), `condition of button ${b.name}`))) continue;
     vis.buttons.set(b.name, b);
   }
 
@@ -132,7 +134,9 @@ export async function computeVisibility(ctx: PageContext): Promise<Visibility> {
     if (r.type === 'grid' && vis.regions.has(r.id) && ctx.page.processes.some((p) => p.type === 'grid_dml' && p.region_id === r.id))
       vis.buttons.set(saveRequest(r), saveButton(r));
 
-  for (const d of ctx.page.dynamic_actions) if (await isAuthorized(ctx, d.authz)) vis.dynamicActions.add(d.id);
+  for (const d of ctx.page.dynamic_actions)
+    if ((await isAuthorized(ctx, d.authz)) && (await conditionHolds(ctx, serverConditionOf(d), `server-side condition of dynamic action "${d.name}"`)))
+      vis.dynamicActions.add(d.id);
   ctx.vis = vis;
   return vis;
 }

package/src/runtime/context.ts

@@ -74,6 +74,10 @@ export interface PageContext {
   wholePage?: boolean;
   /** a download process's file, sent instead of the page (processes.ts) */
   download?: Download;
+  /** (157) a close_dialog process ran: the items handed to the page below (closes the modal page after the submit) */
+  closeDialog?: Record<string, string>;
+  /** (157) a reset_pagination process ran: reports and grids start on their first page after the submit */
+  resetPagination?: boolean;
   /** running a background chain (process-jobs.ts): no request, no browser */
   background?: boolean;
   /** debug messages of this request, when the app's debug level is on (src/debug.ts) */

package/src/runtime/da-styles.ts

@@ -0,0 +1,37 @@
+// (sprint 156, CD-3) The Set Style dynamic action: CSS properties from a fixed list, with plain values. The builder
+// refuses others (styleProblem); the page only ever gets the ones that pass (safeStyles), set through the CSSOM
+// (element.style), which the Content-Security-Policy allows without 'unsafe-inline'.
+
+export const STYLE_PROPERTIES = new Set([
+  'color', 'background-color', 'border-color', 'outline-color', 'font-weight', 'font-style', 'font-size', 'text-decoration', 'text-transform',
+  'text-align', 'opacity', 'visibility', 'border-width', 'border-style', 'padding', 'margin', 'width', 'max-width', 'min-height',
+]);
+/** colours, lengths, keywords, numbers: no url(), quotes, semicolons, braces, backslashes or expressions */
+const VALUE = /^[#a-zA-Z0-9 .,%()+-]{1,60}$/;
+const BAD = /url\s*\(|expression|var\s*\(|attr\s*\(|image|\/\*/i;
+
+export function styleProblem(styles: unknown): string | null {
+  if (styles === undefined || styles === null) return 'Set style: {"styles": {"color": "#b42318", "font-weight": "bold"}} in the attributes.';
+  if (typeof styles !== 'object' || Array.isArray(styles)) return 'Set style: "styles" is an object of CSS properties and values.';
+  const entries = Object.entries(styles as Record<string, unknown>);
+  if (!entries.length || entries.length > 10) return 'Set style: 1 to 10 properties.';
+  for (const [k, v] of entries) {
+    if (!STYLE_PROPERTIES.has(k)) return `Set style: ${k} isn't one of ${[...STYLE_PROPERTIES].join(', ')}.`;
+    if (typeof v !== 'string' || !VALUE.test(v) || BAD.test(v)) return `Set style: the value of ${k} is a colour, length or keyword (letters, digits, # . , % ( ) + -), without url() or var().`;
+  }
+  return null;
+}
+
+/** The properties of a Set Style action that pass, as {property: value}. */
+export function safeStyles(config: Record<string, any> | null | undefined): Record<string, string> {
+  const s = config?.styles;
+  if (!s || typeof s !== 'object' || Array.isArray(s)) return {};
+  return Object.fromEntries(Object.entries(s).filter(([k, v]) => STYLE_PROPERTIES.has(k) && typeof v === 'string' && VALUE.test(v) && !BAD.test(v)).slice(0, 10)) as Record<string, string>;
+}
+
+/** The client-side comparison of greater / less conditions: numbers as numbers, ISO dates as dates, else text. */
+export function compareValues(a: string, b: string): number {
+  const num = /^\s*-?\d+(\.\d+)?\s*$/;
+  if (num.test(a) && num.test(b)) return Number(a) - Number(b);
+  return a < b ? -1 : a > b ? 1 : 0;
+}

package/src/runtime/documents.ts

@@ -23,7 +23,8 @@ interface ReportQuery {
   authz: string | null;
 }
 
-export async function renderDocument(ctx: PageContext, name: string) {
+/** (157) `offered`: a print_report process of the page asks for it (the page offers it). */
+export async function renderDocument(ctx: PageContext, name: string, offered = false) {
   const c = ctx.client!;
   // metadata through the runtime connection: the page's transaction already runs as the app's role
   const tpl = await runtime.one<DocumentTemplate>('select * from meta.document_template where app_id = $1 and name = upper($2)', [ctx.app.id, name.slice(0, 100)]);
@@ -33,7 +34,7 @@ export async function renderDocument(ctx: PageContext, name: string) {
   if (!found || !(await isAuthorized(ctx, found.authz))) throw new Forbidden(ctx.locale.t('error.document_unavailable'));
   // without signing in (a public page of an app that has sign-in) only the documents the page itself offers
   // with a visible document button: ?doc= on any public page would otherwise hand out every template
-  if (ctx.app.authentication !== 'none' && !ctx.session.username) {
+  if (ctx.app.authentication !== 'none' && !ctx.session.username && !offered) {
     const offered = [...(ctx.vis?.buttons.values() ?? [])].some((b) => b.action === 'document' && (b.document ?? '').toUpperCase() === found.name);
     if (!offered) throw new Forbidden(ctx.locale.t('error.document_unavailable'));
   }

package/src/runtime/engine.ts

@@ -1,7 +1,7 @@
 import pg from 'pg';
 import { applyBinds, literal } from '../binds.ts';
 import { runtime, savepoint, type Client } from '../db.ts';
-import type { Item, Process, Region } from '../metadata.ts';
+import type { Condition, Item, Process, Region, Validation } from '../metadata.ts';
 import { isAuthorized } from './authz.ts';
 import { gridDml } from './grid.ts';
 import { dropObjects, dropObjectsSince, formRegion, isMultiple, isTempId, removals, REMOVE, saveFileLists, storedFiles, storeOf, storeTempFile, tempIds } from './files.ts';
@@ -14,8 +14,10 @@ import { runPendingAi } from '../ai/requests.ts';
 import { runAiProcess } from './ai.ts';
 import { itemMask, LOV_CHECKED, lovContains, MULTI_VALUE, ratingMax, splitValues } from './items.ts';
 import { formatNumber, isPlainNumber } from '../numformat.ts';
-import { conditionHolds } from './logic.ts';
+import { parseDateMask } from './format.ts';
+import { conditionHolds, functionBody } from './logic.ts';
 import { runPluginProcess } from './plugins.ts';
+import { runDeclarative } from './process-types.ts';
 import { BACKGROUND_TYPES, downloadFile, sendEmailProcess, sendPushProcess, workflowProcess, type ChainConfig } from './processes.ts';
 import { bindValues, dbg, publicError, stripSemicolon, substitute, timed, toState, type Errors, type PageContext } from './context.ts';
 
@@ -138,6 +140,76 @@ async function storedFileExists(ctx: PageContext, r: Region, column: string) {
   return res.rows[0]?.ok === true;
 }
 
+const VALID_TIMESTAMP = /^(\d{4}-\d{2}-\d{2})[ T](\d{2}):(\d{2})(:(\d{2})(\.\d{1,6})?)?$/;
+const isZero = (v: string) => isPlainNumber(v) && Number(v) === 0;
+
+/**
+ * (148, CD-1) Does a validation pass? true, false (its message), or an error text (function_error). Item types
+ * test the item's posted value; format checks pass an empty one (as in APEX). SQL types run as the app's role.
+ */
+async function validationPasses(ctx: PageContext, v: Validation, value: string | null): Promise<boolean | string> {
+  const c = ctx.client!;
+  const expr = v.expression ?? '';
+  const sql = async (text: string) => (await savepoint(c, () => c.query(text))).rows[0]?.ok === true;
+  switch (v.type) {
+    case 'sql':
+      return sql(`select (${stripSemicolon(applyBinds(v.expression ?? 'true', bindValues(ctx)))})::boolean as ok`);
+    case 'exists':
+    case 'not_exists': {
+      const found = await sql(`select exists (${stripSemicolon(applyBinds(expr, bindValues(ctx)))}) as ok`);
+      return v.type === 'exists' ? found : !found;
+    }
+    case 'function_body': {
+      const r = await savepoint(c, () => functionBody(ctx, expr));
+      return r === 'true' || r === 't';
+    }
+    case 'function_error': {
+      const r = await savepoint(c, () => functionBody(ctx, expr));
+      return r === null || r.trim() === '' ? true : r;
+    }
+    case 'not_null':
+      return value !== null;
+    case 'not_null_or_zero':
+      return value !== null && !isZero(value);
+    case 'not_zero':
+      return value === null || !isZero(value);
+    case 'equals':
+      return value === (v.expression ?? null) || (value === null && (v.expression ?? '') === '');
+    case 'not_equals':
+      return !(value === (v.expression ?? null) || (value === null && (v.expression ?? '') === ''));
+    case 'in_list':
+      return value !== null && expr.split(':').includes(value);
+    case 'not_in_list':
+      return value === null || !expr.split(':').includes(value);
+  }
+  // format checks: an empty item passes
+  if (value === null) return true;
+  switch (v.type) {
+    case 'no_spaces':
+      return !/\s/.test(value);
+    case 'alphanumeric':
+      return /^[\p{L}\p{N}]+$/u.test(value);
+    case 'numeric':
+      return isPlainNumber(value);
+    case 'valid_date':
+      return parseDateMask(value, ctx.app.date_format ?? 'YYYY-MM-DD', ctx.locale.lang) !== null;
+    case 'valid_timestamp': {
+      const m = VALID_TIMESTAMP.exec(value.trim());
+      return !!m && parseDateMask(m[1], 'YYYY-MM-DD', ctx.locale.lang) !== null && Number(m[2]) < 24 && Number(m[3]) < 60 && Number(m[5] ?? 0) < 60;
+    }
+    case 'chars_only':
+      return [...value].every((ch) => expr.includes(ch));
+    case 'chars_any':
+      return [...value].some((ch) => expr.includes(ch));
+    case 'chars_none':
+      return ![...value].some((ch) => expr.includes(ch));
+    case 'regex':
+      return (await savepoint(c, () => c.query(`select ${literal(value)} ~ ${literal(expr)} as ok`))).rows[0].ok === true;
+    default:
+      return false; // an unknown type fails closed
+  }
+}
+
 /**
  * The page's checks before processing. A DELETE request skips the item checks (required, list,
  * number and format: the values don't matter for a delete) and the validations of every button,
@@ -212,21 +284,26 @@ export async function validate(ctx: PageContext) {
   }
 
   for (const v of ctx.page.validations) {
-    if (v.when_button ? v.when_button !== ctx.request : deleting) continue;
+    // (148) Always execute: also for a DELETE request
+    if (v.when_button ? v.when_button !== ctx.request : deleting && !v.always_execute) continue;
     if (v.item_name && (!vis.items.has(v.item_name) || errors.items[v.item_name])) continue;
+    if (v.authz && !(await isAuthorized(ctx, v.authz))) continue;
+    if (v.condition_type && !(await conditionHolds(ctx, v as Condition, `condition of validation ${v.name}`))) continue;
     const value = v.item_name ? (state[v.item_name] ?? null) : null;
-    try {
-      let ok = true;
-      if (v.type === 'not_null') ok = value !== null;
-      else if (v.type === 'regex') {
-        if (value !== null) ok = (await savepoint(c, () => c.query(`select ${literal(value)} ~ ${literal(v.expression ?? '')} as ok`))).rows[0].ok;
-      } else {
-        const sql = `select (${stripSemicolon(applyBinds(v.expression ?? 'true', bindValues(ctx)))})::boolean as ok`;
-        ok = (await savepoint(c, () => c.query(sql))).rows[0].ok === true;
+    // (148) where the error shows: inline (as before), inline and in the notification, or the notification only
+    const report = (msg: string) => {
+      const inline = v.item_name && vis.items.has(v.item_name) && !errors.items[v.item_name];
+      if (v.display_location === 'notification' || !inline) errors.page.push(msg);
+      else {
+        errors.items[v.item_name!] = msg;
+        if (v.display_location === 'inline_and_notification') errors.page.push(msg);
       }
-      if (!ok) fail(v.item_name, v.message);
+    };
+    try {
+      const outcome = await validationPasses(ctx, v, value);
+      if (outcome !== true) report(typeof outcome === 'string' ? outcome : v.message);
     } catch (e) {
-      fail(v.item_name, `${v.message} (${await publicError(ctx, e, `validation ${v.name}`)})`);
+      report(`${v.message} (${await publicError(ctx, e, `validation ${v.name}`)})`);
     }
   }
 
@@ -547,6 +624,11 @@ async function runOneStep(ctx: PageContext, p: Process, names: Set<string>, dept
       case 'send_email': return await sendEmailProcess(ctx, p);
       case 'ai_generate': return (await runAiProcess(ctx, p, names)).message;
       case 'plugin': return await runPluginProcess(ctx, p.config, p.name);
+      // (157, CD-4) close_dialog, clear_session_state, reset_pagination, user_preferences, server_geocoding,
+      // print_report, human_task_create, human_task_manage, form_init
+      case 'close_dialog': case 'clear_session_state': case 'reset_pagination': case 'user_preferences': case 'server_geocoding':
+      case 'print_report': case 'human_task_create': case 'human_task_manage': case 'form_init':
+        return await runDeclarative(ctx, p, names);
       case 'download':
         // sent instead of the page (routes.ts); the first download of a request wins
         ctx.download ??= await downloadFile(ctx, p);

package/src/runtime/items.ts

@@ -1,3 +1,4 @@
+import { tileAttribution, tileUrl } from '../maptiles.ts';
 import { applyBinds } from '../binds.ts';
 import { icon } from '../icons.ts';
 import { pluginAttributes, pluginData, pluginOf } from './plugins.ts';
@@ -235,6 +236,30 @@ function maskedValue(ctx: PageContext, item: Item, value: string) {
 const LOCATION = /^\s*(-?\d{1,2}(?:\.\d+)?)\s*,\s*(-?\d{1,3}(?:\.\d+)?)\s*$/;
 
 /** Render one item (field wrapper included). Hidden items are never rendered. */
+/**
+ * (151) A Display Map item: one map tile around "lat,lng" (the value, or config.coordinates_item's) with a pin, from the
+ * map regions' tile server; its position is a class of the page's stylesheet (the CSP allows no inline styles).
+ */
+function displayMap(ctx: PageContext, item: Item, value: string): Raw {
+  const source = typeof item.config?.coordinates_item === 'string' ? (ctx.session.state[item.config.coordinates_item.toUpperCase()] ?? '') : value;
+  const at = LOCATION.exec(source);
+  const lat = at ? Number(at[1]) : NaN;
+  const lng = at ? Number(at[2]) : NaN;
+  if (!at || Math.abs(lat) > 85 || Math.abs(lng) > 180) return html`<div class="display-value" id="${item.name}"> </div>`;
+  const z = Number.isInteger(item.config?.zoom) && item.config.zoom >= 1 && item.config.zoom <= 19 ? item.config.zoom : 15;
+  const n = 2 ** z;
+  const fx = ((lng + 180) / 360) * n;
+  const r = (lat * Math.PI) / 180;
+  const fy = ((1 - Math.log(Math.tan(r) + 1 / Math.cos(r)) / Math.PI) / 2) * n;
+  const [x, y] = [Math.floor(fx), Math.floor(fy)];
+  const src = tileUrl().replace('{s}', 'a').replace('{z}', String(z)).replace('{x}', String(x)).replace('{y}', String(y));
+  const pin = ctx.css.cls(`left:${((fx - x) * 100).toFixed(2)}%;top:${((fy - y) * 100).toFixed(2)}%`);
+  return html`<figure class="display-map" id="${item.name}">
+    <div class="display-map-tile"><img src="${src}" alt="${ctx.locale.t('item.map_of', { position: source.trim() })}" width="256" height="256" loading="lazy"><span class="display-map-pin ${pin}" aria-hidden="true"></span></div>
+    <figcaption><small>${tileAttribution()}</small> · <a href="https://www.openstreetmap.org/?mlat=${String(lat)}&amp;mlon=${String(lng)}#map=${String(z)}/${String(lat)}/${String(lng)}" target="_blank" rel="noopener noreferrer">${ctx.locale.t('item.show_map')}</a></figcaption>
+  </figure>`;
+}
+
 export async function renderItem(ctx: PageContext, item: Item, hiddenByDa = false): Promise<Raw | ''> {
   if (item.type === 'hidden' || !ctx.vis!.items.has(item.name)) return '';
   const value = ctx.session.state[item.name] ?? item.default_value ?? '';
@@ -270,6 +295,14 @@ export async function renderItem(ctx: PageContext, item: Item, hiddenByDa = fals
     control = qrControl(ctx, item, value);
   } else if (item.type === 'image') {
     control = imageControl(ctx, item, value);
+  } else if (item.type === 'percent_graph') {
+    // (151) a 0–100 value as a bar; the number is its accessible text
+    const n = /^\s*-?\d+(\.\d+)?\s*$/.test(value) ? Math.max(0, Math.min(100, Number(value))) : null;
+    control = n === null
+      ? html`<div class="display-value" id="${id}"> </div>`
+      : html`<div class="percent-graph" id="${id}"><progress max="100" value="${String(n)}" aria-label="${label}">${String(n)}%</progress><span class="percent-graph-value">${String(Math.round(n))}%</span></div>`;
+  } else if (item.type === 'display_map') {
+    control = displayMap(ctx, item, value);
   } else if (!editable && (item.type === 'richtext' || item.type === 'markdown')) {
     // rebuilt from the allow-list every time: the value may come from the table, not from this form
     control = html`<div class="display-value rich-text" id="${id}">${raw((item.type === 'markdown' ? markdownHtml(value) : sanitizeHtml(value)) || ' ')}</div>`;

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`;