@hotmeshio/long-tail 0.19.0 → 0.20.0

package/build/services/interceptor/index.js

@@ -47,6 +47,11 @@ const context_2 = require("../iam/context");
 const publish_1 = require("../../lib/events/publish");
 const envelope_1 = require("../iam/envelope");
 const DEFAULT_ACTIVITY_QUEUE = 'lt-interceptor';
+/** The result payload a completed event carries: the workflow's `data` when it returned the envelope shape. */
+function resultData(result) {
+    const data = result?.data;
+    return data && typeof data === 'object' && !Array.isArray(data) ? data : undefined;
+}
 /**
  * Register the Long Tail interceptors in a single call.
  *
@@ -120,6 +125,7 @@ function createLTInterceptor(options) {
                     workflowName: wf.workflowName,
                     taskQueue: taskQueue0,
                     status: 'completed',
+                    data: resultData(result0),
                 });
                 return result0;
             }
@@ -138,6 +144,7 @@ function createLTInterceptor(options) {
                     workflowName: wf.workflowName,
                     taskQueue: taskQueue2,
                     status: 'completed',
+                    data: resultData(result2),
                 });
                 return result2;
             }

package/build/services/invocation-access.d.ts

@@ -0,0 +1,18 @@
+import type { LTWorkflowConfig } from '../types/config';
+export interface InvocationRoleGrant {
+    role: string;
+    type: string;
+}
+export declare const INVOCATION_ROLE_TYPES: {
+    readonly SUPERADMIN: "superadmin";
+    readonly ADMIN: "admin";
+};
+export declare const ADMIN_ROLE = "admin";
+/** Superadmin anywhere, or the named admin role held as admin type, invokes every workflow. */
+export declare function hasGlobalInvocationAccess(roles: readonly InvocationRoleGrant[], authRole?: string): boolean;
+/**
+ * The one invocation predicate, shared by the invoke gate and the per-caller
+ * list so the two can never disagree. An empty invocation_roles list opens
+ * the workflow to every authenticated caller.
+ */
+export declare function canInvokeWorkflow(config: Pick<LTWorkflowConfig, 'invocable' | 'invocation_roles'>, roles: readonly InvocationRoleGrant[], authRole?: string): boolean;

package/build/services/invocation-access.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ADMIN_ROLE = exports.INVOCATION_ROLE_TYPES = void 0;
+exports.hasGlobalInvocationAccess = hasGlobalInvocationAccess;
+exports.canInvokeWorkflow = canInvokeWorkflow;
+exports.INVOCATION_ROLE_TYPES = {
+    SUPERADMIN: 'superadmin',
+    ADMIN: 'admin',
+};
+exports.ADMIN_ROLE = 'admin';
+/** Superadmin anywhere, or the named admin role held as admin type, invokes every workflow. */
+function hasGlobalInvocationAccess(roles, authRole) {
+    if (authRole === exports.INVOCATION_ROLE_TYPES.SUPERADMIN)
+        return true;
+    return roles.some((r) => r.type === exports.INVOCATION_ROLE_TYPES.SUPERADMIN)
+        || roles.some((r) => r.role === exports.ADMIN_ROLE && r.type === exports.INVOCATION_ROLE_TYPES.ADMIN);
+}
+/**
+ * The one invocation predicate, shared by the invoke gate and the per-caller
+ * list so the two can never disagree. An empty invocation_roles list opens
+ * the workflow to every authenticated caller.
+ */
+function canInvokeWorkflow(config, roles, authRole) {
+    if (!config.invocable)
+        return false;
+    if (config.invocation_roles.length === 0)
+        return true;
+    if (hasGlobalInvocationAccess(roles, authRole))
+        return true;
+    const held = new Set(roles.map((r) => r.role));
+    return config.invocation_roles.some((r) => held.has(r));
+}

package/build/services/knowledge/index.d.ts

@@ -1,4 +1,5 @@
 export * from './lookup-cache';
+export * from './lookup-refs';
 export interface KnowledgeVersionMeta {
     version: number;
     change_summary: string | null;

package/build/services/knowledge/index.js

@@ -24,6 +24,7 @@ exports.listKnowledgeVersions = listKnowledgeVersions;
 const db_1 = require("../../lib/db");
 const sql_1 = require("./sql");
 __exportStar(require("./lookup-cache"), exports);
+__exportStar(require("./lookup-refs"), exports);
 /** The immutable snapshot at (domain, key, version), uncached full shape. */
 async function getKnowledgeVersion(domain, key, version) {
     const pool = (0, db_1.getPool)();

package/build/services/knowledge/lookup-refs.d.ts

@@ -0,0 +1,7 @@
+import type { EscalationLookupRef } from '../../types/escalation';
+/**
+ * One message per ref whose pinned edition does not exist, naming what does.
+ * Shape is the caller's job (assertLookupRefs); this answers the second
+ * question a saver has: is there an edition behind the pin.
+ */
+export declare function describeMissingLookupRefs(refs: EscalationLookupRef[]): Promise<string[]>;

package/build/services/knowledge/lookup-refs.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeMissingLookupRefs = describeMissingLookupRefs;
+const db_1 = require("../../lib/db");
+const lookup_cache_1 = require("./lookup-cache");
+const sql_1 = require("./sql");
+/**
+ * One message per ref whose pinned edition does not exist, naming what does.
+ * Shape is the caller's job (assertLookupRefs); this answers the second
+ * question a saver has: is there an edition behind the pin.
+ */
+async function describeMissingLookupRefs(refs) {
+    const problems = [];
+    for (const ref of refs) {
+        const snapshot = await (0, lookup_cache_1.getKnowledgeSnapshot)(ref.domain, ref.key, ref.version);
+        if (snapshot)
+            continue;
+        const { rows } = await (0, db_1.getPool)().query(sql_1.LIST_KNOWLEDGE_VERSIONS, [ref.domain, ref.key]);
+        const versions = rows.map((r) => Number(r.version)).sort((a, b) => a - b);
+        const where = versions.length
+            ? `editions: ${versions.map((v) => `v${v}`).join(', ')}`
+            : `no knowledge entry ${ref.domain}/${ref.key}`;
+        problems.push(`Lookup ref ${ref.domain}/${ref.key} v${ref.version} names no edition (${where})`);
+    }
+    return problems;
+}

package/build/services/mcp/db-server/schemas.d.ts

@@ -7,12 +7,12 @@ export declare const findTasksSchema: z.ZodObject<{
     limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
 }, "strip", z.ZodTypeAny, {
     limit: number;
-    status?: "pending" | "in_progress" | "completed" | "needs_intervention" | "failed" | undefined;
+    status?: "completed" | "pending" | "in_progress" | "needs_intervention" | "failed" | undefined;
     workflow_type?: string | undefined;
     workflow_id?: string | undefined;
     origin_id?: string | undefined;
 }, {
-    status?: "pending" | "in_progress" | "completed" | "needs_intervention" | "failed" | undefined;
+    status?: "completed" | "pending" | "in_progress" | "needs_intervention" | "failed" | undefined;
     workflow_type?: string | undefined;
     workflow_id?: string | undefined;
     origin_id?: string | undefined;

package/build/services/workflow-invocation.js

@@ -46,6 +46,7 @@ exports.InvocationError = void 0;
 exports.invokeWorkflow = invokeWorkflow;
 exports.checkInvocationRoles = checkInvocationRoles;
 const hotmesh_1 = require("@hotmeshio/hotmesh");
+const invocation_access_1 = require("./invocation-access");
 const workers_1 = require("../workers");
 const configService = __importStar(require("./config"));
 const userService = __importStar(require("./user"));
@@ -152,15 +153,9 @@ async function checkInvocationRoles(workflowType, userId, authRole) {
     if (!user) {
         throw new InvocationError('User not registered', 403);
     }
-    const userRoles = user.roles.map((r) => r.role);
-    const hasInvocationRole = wfConfig.invocation_roles.some((r) => userRoles.includes(r));
-    if (!hasInvocationRole) {
-        // superadmin and admin/admin bypass role checks
-        const hasGlobalAccess = user.roles.some((r) => r.type === 'superadmin')
-            || user.roles.some((r) => r.role === 'admin' && r.type === 'admin');
-        if (!hasGlobalAccess) {
-            throw new InvocationError('Insufficient role for invocation', 403);
-        }
+    // invocable is resolveTaskQueue's concern; this gate decides roles only.
+    if (!(0, invocation_access_1.canInvokeWorkflow)({ ...wfConfig, invocable: true }, user.roles, authRole)) {
+        throw new InvocationError('Insufficient role for invocation', 403);
     }
 }
 /**

package/build/shared/form-validation/field-validator.d.ts

@@ -38,6 +38,7 @@ export declare function resolveChecklistDefault(fieldSchema: Record<string, unkn
  * which remains the at-least-one check.
  */
 export declare function validateRequireAll(value: unknown, fieldSchema: Record<string, unknown> | undefined, ctx?: Record<string, unknown>): string | undefined;
+export declare const INVALID_JSON = "Invalid JSON";
 /**
  * Runtime type check against the field's declared JSON Schema `type`. Guards
  * the payload contract for API-first callers (a form widget already produces

package/build/shared/form-validation/field-validator.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.X_LT_DEFAULT_CHECKED = void 0;
+exports.INVALID_JSON = exports.X_LT_DEFAULT_CHECKED = void 0;
 exports.resolveChecklistItems = resolveChecklistItems;
 exports.resolveChecklistDefault = resolveChecklistDefault;
 exports.validateRequireAll = validateRequireAll;
@@ -87,6 +87,18 @@ function validateRequireAll(value, fieldSchema, ctx) {
         return undefined;
     return `${incomplete} of ${mandatory.length} checks incomplete`;
 }
+exports.INVALID_JSON = 'Invalid JSON';
+/** The json editor holds unparseable text as a string at the field's key. */
+function isJsonWidget(fieldSchema) {
+    return fieldSchema?.['x-lt-widget'] === 'json';
+}
+/** A list is edited through the json editor or a multi-select; any other list value is display only. */
+function isEditableList(fieldSchema) {
+    return isJsonWidget(fieldSchema) || fieldSchema?.[x_lt_options_1.X_LT_OPTIONS] !== undefined;
+}
+function plural(n, noun) {
+    return `${n} ${noun}${n === 1 ? '' : 's'}`;
+}
 /**
  * Runtime type check against the field's declared JSON Schema `type`. Guards
  * the payload contract for API-first callers (a form widget already produces
@@ -109,9 +121,13 @@ function validateFieldType(value, fieldSchema) {
         case 'boolean':
             return typeof value === 'boolean' ? undefined : 'Expected true or false';
         case 'array':
-            return Array.isArray(value) ? undefined : 'Expected a list';
+            if (Array.isArray(value))
+                return undefined;
+            return isJsonWidget(fieldSchema) && typeof value === 'string' ? exports.INVALID_JSON : 'Expected a list';
         case 'object':
-            return typeof value === 'object' && !Array.isArray(value) ? undefined : 'Expected an object';
+            if (typeof value === 'object' && !Array.isArray(value))
+                return undefined;
+            return isJsonWidget(fieldSchema) && typeof value === 'string' ? exports.INVALID_JSON : 'Expected an object';
         default:
             return undefined;
     }
@@ -136,7 +152,7 @@ function validateFieldConstraints(value, fieldSchema, ctx) {
     // interpolated list that currently offers nothing fails closed — a stale
     // cascade child value never submits.
     const allowed = (0, x_lt_options_1.resolveFieldOptions)(fieldSchema, ctx);
-    if (allowed !== undefined && value !== undefined && value !== null && value !== '') {
+    if (allowed !== undefined && value !== undefined && value !== null && value !== '' && !Array.isArray(value)) {
         if (allowed.length === 0) {
             return 'No valid options for this selection';
         }
@@ -144,6 +160,12 @@ function validateFieldConstraints(value, fieldSchema, ctx) {
             return `Must be one of: ${allowed.map((o) => String(o.value)).join(', ')}`;
         }
     }
+    if (Array.isArray(value)) {
+        return isEditableList(fieldSchema) ? validateListConstraints(value, fieldSchema, allowed, ctx) : undefined;
+    }
+    if (value !== null && typeof value === 'object') {
+        return validateMapConstraints(value, fieldSchema, ctx);
+    }
     if (typeof value === 'string') {
         const s = value.trim();
         if (s === '')
@@ -196,6 +218,65 @@ function validateFieldConstraints(value, fieldSchema, ctx) {
     }
     return undefined;
 }
+/**
+ * An edited list: every item must belong to the field's `x-lt-options` when
+ * declared, the length must sit within `minItems`/`maxItems`, and each item
+ * must satisfy `items`. An empty list passes; presence is the required
+ * check's job.
+ */
+function validateListConstraints(value, fieldSchema, allowed, ctx) {
+    if (value.length === 0)
+        return undefined;
+    if (allowed !== undefined) {
+        if (allowed.length === 0)
+            return 'No valid options for this selection';
+        if (value.some((v) => !allowed.some((o) => o.value === v))) {
+            return `Must be one of: ${allowed.map((o) => String(o.value)).join(', ')}`;
+        }
+    }
+    const minItems = resolveNumericConstraint(fieldSchema.minItems, undefined, ctx);
+    if (minItems !== undefined && value.length < minItems)
+        return `At least ${plural(minItems, 'item')}`;
+    const maxItems = resolveNumericConstraint(fieldSchema.maxItems, undefined, ctx);
+    if (maxItems !== undefined && value.length > maxItems)
+        return `At most ${plural(maxItems, 'item')}`;
+    const items = fieldSchema.items;
+    if (items && typeof items === 'object' && !Array.isArray(items)) {
+        const itemSchema = items;
+        for (let i = 0; i < value.length; i++) {
+            const err = validateFieldType(value[i], itemSchema) ?? validateFieldConstraints(value[i], itemSchema, ctx);
+            if (err)
+                return `Item ${i + 1}: ${err}`;
+        }
+    }
+    return undefined;
+}
+/**
+ * A map value: keys must belong to `propertyNames.enum` when declared, and
+ * every value must satisfy an object-shaped `additionalProperties`.
+ */
+function validateMapConstraints(value, fieldSchema, ctx) {
+    const entries = Object.entries(value);
+    if (entries.length === 0)
+        return undefined;
+    const propertyNames = fieldSchema.propertyNames;
+    const allowedKeys = Array.isArray(propertyNames?.enum) ? propertyNames.enum.map(String) : undefined;
+    if (allowedKeys) {
+        const unknown = entries.find(([k]) => !allowedKeys.includes(k));
+        if (unknown)
+            return `Unknown key "${unknown[0]}". Allowed: ${allowedKeys.join(', ')}`;
+    }
+    const ap = fieldSchema.additionalProperties;
+    if (ap && typeof ap === 'object' && !Array.isArray(ap)) {
+        const valueSchema = ap;
+        for (const [k, v] of entries) {
+            const err = validateFieldType(v, valueSchema) ?? validateFieldConstraints(v, valueSchema, ctx);
+            if (err)
+                return `"${k}": ${err}`;
+        }
+    }
+    return undefined;
+}
 function resolveNumericConstraint(staticVal, dynamicPath, ctx) {
     if (typeof staticVal === 'number')
         return staticVal;
@@ -232,13 +313,20 @@ function validateField(value, fieldSchema, isRequired, isTouched, ctx) {
     if (isRequired) {
         if (value === undefined || value === null)
             return 'Required';
-        if (typeof value === 'boolean' && !value)
+        // A checkbox must be checked; a boolean with an option list is answered by either value.
+        if (typeof value === 'boolean' && !value && (0, x_lt_options_1.resolveFieldOptions)(fieldSchema, ctx) === undefined)
             return 'Required';
         if (typeof value === 'string' && value.trim() === '')
             return 'Required';
+        // A picked or edited list needs one item; a plain list value is not checked.
+        if (Array.isArray(value) && value.length === 0 && isEditableList(fieldSchema))
+            return 'Required';
         if (typeof value === 'object' && !Array.isArray(value) && value !== null) {
             const vals = Object.values(value);
-            if (vals.length === 0 || vals.every((v) => !v))
+            if (vals.length === 0)
+                return 'Required';
+            // A json map is answered by any key; every other object needs one truthy value.
+            if (!isJsonWidget(fieldSchema) && vals.every((v) => !v))
                 return 'Required';
         }
     }

package/build/shared/form-validation/index.d.ts

@@ -19,3 +19,4 @@ export * from './x-lt-options';
 export * from './ctx-path';
 export * from './field-validator';
 export * from './validate-resolver-payload';
+export * from './invoke-context';

package/build/shared/form-validation/index.js

@@ -35,3 +35,4 @@ __exportStar(require("./x-lt-options"), exports);
 __exportStar(require("./ctx-path"), exports);
 __exportStar(require("./field-validator"), exports);
 __exportStar(require("./validate-resolver-payload"), exports);
+__exportStar(require("./invoke-context"), exports);

package/build/shared/form-validation/invoke-context.d.ts

@@ -0,0 +1,8 @@
+import type { ResolverValidationContext } from './validate-resolver-payload';
+/**
+ * The context an invoke form validates and renders against. The pass itself
+ * supplies the live values under `input` and `resolver`; `metadata` is the
+ * envelope metadata and `lookup` holds resolved versioned knowledge editions
+ * keyed by `as ?? key`. The lookup domain is present only when supplied.
+ */
+export declare function buildInvokeFormContext(metadata: Record<string, unknown> | null | undefined, lookup?: Record<string, unknown> | null): ResolverValidationContext;

package/build/shared/form-validation/invoke-context.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildInvokeFormContext = buildInvokeFormContext;
+/**
+ * The context an invoke form validates and renders against. The pass itself
+ * supplies the live values under `input` and `resolver`; `metadata` is the
+ * envelope metadata and `lookup` holds resolved versioned knowledge editions
+ * keyed by `as ?? key`. The lookup domain is present only when supplied.
+ */
+function buildInvokeFormContext(metadata, lookup) {
+    return { metadata: metadata ?? {}, ...(lookup ? { lookup } : {}) };
+}

package/build/shared/form-validation/validate-resolver-payload.d.ts

@@ -31,7 +31,7 @@ export type { FieldError } from './field-validator';
  * dynamic constraints against. `resolver` is supplied by the pass itself
  * (the flat form values under validation) — callers provide the rest.
  */
-export type ResolverValidationContext = Omit<ShowIfContext, 'resolver'>;
+export type ResolverValidationContext = Omit<ShowIfContext, 'resolver' | 'input'>;
 /**
  * Validate FLAT form values against the form schema. This is the dashboard's
  * entry point (the values the user edits, keyed by field name).

package/build/shared/form-validation/validate-resolver-payload.js

@@ -44,6 +44,7 @@ function validateResolverForm(schema, formValues, ctx) {
     const liveCtx = {
         ...(ctx ?? {}),
         resolver: formValues,
+        input: formValues,
     };
     const errors = [];
     for (const [field, fieldSchema] of Object.entries(properties)) {

package/build/shared/form-validation/x-lt-help.d.ts

@@ -1,5 +1,5 @@
-/** The token domains a help template may reference. */
-export declare const HELP_DOMAINS: readonly ["escalation", "metadata", "envelope", "payload", "resolver", "lookup"];
+/** The token domains a help template may reference. `input` is the invoke-form name for the live values `resolver` also carries. */
+export declare const HELP_DOMAINS: readonly ["escalation", "metadata", "envelope", "payload", "resolver", "lookup", "input"];
 export type HelpDomain = (typeof HELP_DOMAINS)[number];
 export type HelpTokenContext = Partial<Record<HelpDomain, Record<string, unknown> | null>>;
 /** Replace every `{{domain.path}}` token with its value from the context. */

package/build/shared/form-validation/x-lt-help.js

@@ -23,8 +23,8 @@ exports.defaultHelpMarkdown = defaultHelpMarkdown;
  * `x-lt-help` is absent.
  */
 const x_lt_bind_1 = require("./x-lt-bind");
-/** The token domains a help template may reference. */
-exports.HELP_DOMAINS = ['escalation', 'metadata', 'envelope', 'payload', 'resolver', 'lookup'];
+/** The token domains a help template may reference. `input` is the invoke-form name for the live values `resolver` also carries. */
+exports.HELP_DOMAINS = ['escalation', 'metadata', 'envelope', 'payload', 'resolver', 'lookup', 'input'];
 const TOKEN_PATTERN = /\{\{\s*([^{}]+?)\s*\}\}/g;
 const MISSING_VALUE = '—';
 function formatTokenValue(value) {

package/build/shared/form-validation/x-lt-options.d.ts

@@ -1,12 +1,12 @@
 export declare const X_LT_OPTIONS = "x-lt-options";
-export type OptionValue = string | number;
+export type OptionValue = string | number | boolean;
 /** One resolved option: the payload value and the rendered label. */
 export interface ResolvedOption {
     value: OptionValue;
     label: string;
 }
 /**
- * The field's effective option list: the static `enum` when present, else the
- * entries at the token's `"domain.path"`.
+ * The field's effective option list: the static `enum` when present, else an
+ * inline literal list, else the entries at the token's `"domain.path"`.
  */
 export declare function resolveFieldOptions(fieldSchema: Record<string, unknown> | null | undefined, ctx: Record<string, unknown> | undefined): ResolvedOption[] | undefined;

package/build/shared/form-validation/x-lt-options.js

@@ -10,7 +10,9 @@ exports.resolveFieldOptions = resolveFieldOptions;
  * offer a different legal set per escalation (e.g. `[1..N]` where N rides the
  * envelope, or a versioned knowledge lookup under the `lookup` domain).
  *
- *   x-lt-options   "domain.path" or an ORDERED array of paths — e.g.
+ *   x-lt-options   "domain.path", an ORDERED array of paths, or an inline
+ *                  literal list (an array with no string entries: `{ value,
+ *                  label }` objects, numbers, or booleans) — e.g.
  *                  "envelope.left_quantity_options" or
  *                  ["lookup.reasons.items", "envelope.reject_reason_items"].
  *                  With an array, the first entry that resolves to options
@@ -42,7 +44,15 @@ exports.resolveFieldOptions = resolveFieldOptions;
 const ctx_path_1 = require("./ctx-path");
 exports.X_LT_OPTIONS = 'x-lt-options';
 function isScalar(v) {
-    return typeof v === 'string' || (typeof v === 'number' && Number.isFinite(v));
+    return typeof v === 'string' || typeof v === 'boolean' || (typeof v === 'number' && Number.isFinite(v));
+}
+/**
+ * An array token with no string entries is the option list itself, written
+ * inline. A bare string is always a context path, so a literal string value
+ * is written as `{ value, label }`.
+ */
+function isLiteralList(token) {
+    return Array.isArray(token) && token.length > 0 && !token.some((e) => typeof e === 'string');
 }
 /** Normalize one array entry, mixed arrays resolving each entry independently. */
 function toOption(entry) {
@@ -58,19 +68,23 @@ function toOption(entry) {
     return null;
 }
 /**
- * The field's effective option list: the static `enum` when present, else the
- * entries at the token's `"domain.path"`.
+ * The field's effective option list: the static `enum` when present, else an
+ * inline literal list, else the entries at the token's `"domain.path"`.
  */
 function resolveFieldOptions(fieldSchema, ctx) {
     if (!fieldSchema)
         return undefined;
     // Enum entries pass through verbatim as values (whatever their type), each
-    // labeled by its string form — the legacy membership contract is unchanged.
+    // labeled by its string form.
     const staticEnum = fieldSchema.enum;
     if (Array.isArray(staticEnum) && staticEnum.length > 0) {
         return staticEnum.map((v) => ({ value: v, label: String(v) }));
     }
     const token = fieldSchema[exports.X_LT_OPTIONS];
+    if (isLiteralList(token)) {
+        const options = token.map(toOption).filter((o) => o !== null);
+        return options.length > 0 ? options : undefined;
+    }
     const paths = (typeof token === 'string' ? [token] : Array.isArray(token) ? token : [])
         .filter((p) => typeof p === 'string' && p.length > 0);
     if (paths.length === 0)

package/build/shared/form-validation/x-lt-show-if.d.ts

@@ -3,5 +3,11 @@ export type ShowIfContext = HelpTokenContext;
 /**
  * Evaluates an x-lt-showIf condition. Returns true when the field should be
  * shown. Returns true when condition is absent, non-string, or context is null.
+ * An array of conditions shows the field only when every one holds.
  */
 export declare function evaluateShowIf(condition: unknown, ctx: ShowIfContext | null | undefined): boolean;
+/**
+ * `x-lt-hide-if-empty`: the field is suppressed while its value is empty
+ * (null, undefined, '', false, or 0). Render and validation share this test.
+ */
+export declare function isHiddenIfEmpty(fieldSchema: Record<string, unknown> | undefined, value: unknown): boolean;

package/build/shared/form-validation/x-lt-show-if.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.evaluateShowIf = evaluateShowIf;
+exports.isHiddenIfEmpty = isHiddenIfEmpty;
 /**
  * x-lt-showIf — conditional field visibility. A form_schema property may
  * declare `x-lt-showIf: "domain.path"` to show the field only when the value
@@ -54,8 +55,11 @@ function resolvePath(expr, ctx) {
 /**
  * Evaluates an x-lt-showIf condition. Returns true when the field should be
  * shown. Returns true when condition is absent, non-string, or context is null.
+ * An array of conditions shows the field only when every one holds.
  */
 function evaluateShowIf(condition, ctx) {
+    if (Array.isArray(condition))
+        return condition.every((c) => evaluateShowIf(c, ctx));
     if (typeof condition !== 'string' || condition.length === 0)
         return true;
     if (!ctx)
@@ -82,3 +86,12 @@ function evaluateShowIf(condition, ctx) {
         return true;
     return negate ? !isTruthy(value) : isTruthy(value);
 }
+/**
+ * `x-lt-hide-if-empty`: the field is suppressed while its value is empty
+ * (null, undefined, '', false, or 0). Render and validation share this test.
+ */
+function isHiddenIfEmpty(fieldSchema, value) {
+    if (fieldSchema?.['x-lt-hide-if-empty'] !== true)
+        return false;
+    return value === null || value === undefined || value === '' || value === false || value === 0;
+}

package/build/start/workers.js

@@ -51,6 +51,8 @@ const mcp_1 = require("../services/mcp");
 const yamlWorkflowWorkers = __importStar(require("../services/yaml-workflow/workers"));
 const migrate_1 = require("../lib/db/migrate");
 const apply_report_1 = require("./apply-report");
+const escalation_2 = require("../types/escalation");
+const lookup_refs_1 = require("../services/knowledge/lookup-refs");
 /**
  * Create a named no-op workflow function for readonly/observer workers.
  * The function name is used by `registerWorker` for discovery.
@@ -221,6 +223,13 @@ async function startWorkers(startConfig, workers, builtinMcpServerFactories) {
                 for (const w of workersWithConfig) {
                     const workflowType = w.workflow.name;
                     const c = w.config;
+                    if (c.inputLookups !== undefined) {
+                        (0, escalation_2.assertLookupRefs)(c.inputLookups);
+                        // Editions may be seeded after registration; a missing pin warns here and surfaces on the Invoke Tool page.
+                        for (const problem of await (0, lookup_refs_1.describeMissingLookupRefs)(c.inputLookups)) {
+                            logger_1.loggerRegistry.warn(`[long-tail] ${workflowType}: ${problem}`);
+                        }
+                    }
                     const declaration = {
                         workflow_type: workflowType,
                         task_queue: w.taskQueue,
@@ -233,6 +242,9 @@ async function startWorkers(startConfig, workers, builtinMcpServerFactories) {
                         consumes: c.consumes ?? [],
                         tool_tags: c.toolTags ?? [],
                         envelope_schema: c.envelopeSchema ?? null,
+                        input_schema: c.inputSchema ?? null,
+                        icon: c.icon ?? null,
+                        input_lookups: c.inputLookups ?? null,
                         resolver_schema: c.resolverSchema ?? null,
                         cron_schedule: c.cronSchedule ?? null,
                         execute_as: c.executeAs ?? null,