@uipath/maestro-builder-sdk 6.17.5 → 6.18.0

package/dist/bpmn/intsvc.js

@@ -1,6 +1,6 @@
 import { createTypedNode, typedNodeOutputVar } from './typed-node.js';
 import { connectorBindingRef } from './connector.js';
-import { eventFilterJmes, eventFilterProblem, readEventFilter } from '../core/event-filters.js';
+import { eventFilterJmes, eventFilterProblem, jmesString, jmesStringProblem, readEventFilter } from '../core/event-filters.js';
 /**
  * Which extension type an external invocation lowers to.
  *
@@ -128,7 +128,12 @@ export function createConnectorEvent(ctx, n) {
  */
 export function eventFilterBody(nodeId, scope, filters) {
     const scopeEntries = Object.entries(scope ?? {}).filter(([, v]) => v !== undefined && v !== null && String(v) !== '');
-    const scopeClauses = scopeEntries.map(([k, v]) => `(${k} == '${String(v).replace(/'/g, "\\'")}')`);
+    const scopeClauses = scopeEntries.map(([k, v]) => {
+        const problem = jmesStringProblem(String(v));
+        if (problem)
+            throw new Error(`connector event "${nodeId}": \`filter.${k}\`: ${problem}`);
+        return `(${k} == ${jmesString(String(v))})`;
+    });
     const conditions = (filters ?? []).map((leaf, i) => {
         const { read } = readEventFilter(leaf);
         if (!read) {

package/dist/bpmn/serialize.js

@@ -456,7 +456,7 @@ export const SCRIPT_ARGS_ENVELOPE = { vars: '=vars', metadata: '=metadata' };
 export function defaultScriptInputSchema(args) {
     const properties = {};
     for (const k of Object.keys(args))
-        properties[k] = k in SCRIPT_ARGS_ENVELOPE ? { type: 'object' } : {};
+        properties[k] = Object.hasOwn(SCRIPT_ARGS_ENVELOPE, k) ? { type: 'object' } : {};
     return { type: 'object', properties };
 }
 function createScriptTask(ctx, n) {

package/dist/bpmn/typed-node.js

@@ -2,6 +2,7 @@ import { createRequire } from 'node:module';
 import { resolveFromRegistry } from './registry-fallback.js';
 import { nestConnectorBody } from '../core/connector-inputs.js';
 import { types } from '../core/expr.js';
+import { ownEntry } from '../core/own-entry.js';
 const require = createRequire(import.meta.url);
 const REGISTRY = require('./registry-types.json');
 /** Every extension type in the snapshot, sorted. */
@@ -270,10 +271,10 @@ function contextRows(m, type, spec, supplied, verbatim = false) {
     // platform is known to accept fields the registry omits.
     const known = new Set([
         ...spec.context.map((f) => f.name),
-        ...(REGISTRY_GAPS[type]?.extraContext ?? []),
+        ...(ownEntry(REGISTRY_GAPS, type)?.extraContext ?? []),
         // A field the platform REQUIRES is necessarily one it permits, so recording it as
         // required is enough — an `extraContext` twin is not also needed.
-        ...(REGISTRY_GAPS[type]?.requiredContext ?? []),
+        ...(ownEntry(REGISTRY_GAPS, type)?.requiredContext ?? []),
     ]);
     const unknown = Object.keys(supplied).filter((k) => !known.has(k));
     if (unknown.length) {
@@ -669,7 +670,7 @@ export function missingRequiredContext(type, context = {}, inline) {
         .context.filter((f) => f.required && unset(f.name) && (f.default ?? '') === '')
         .map((f) => f.name);
     // Fields the platform requires that the snapshot does not — see `REGISTRY_GAPS`.
-    const gaps = (REGISTRY_GAPS[type]?.requiredContext ?? []).filter((name) => !declared.includes(name) && unset(name));
+    const gaps = (ownEntry(REGISTRY_GAPS, type)?.requiredContext ?? []).filter((name) => !declared.includes(name) && unset(name));
     return [...declared, ...gaps];
 }
 /**
@@ -697,7 +698,7 @@ export function missingRequiredInputs(type, inputs = {},
  * agree with the CLI instead of guessing on either side of it.
  */
 context = {}, inline) {
-    const notEnforced = new Set(REGISTRY_GAPS[type]?.notEnforcedInputs ?? []);
+    const notEnforced = new Set(ownEntry(REGISTRY_GAPS, type)?.notEnforcedInputs ?? []);
     return registryType(type, inline)
         .inputs.filter((f) => f.required &&
         !notEnforced.has(f.name) &&

package/dist/case/compile-cli.js

@@ -24,6 +24,7 @@ import { flagValue, runWhenInvokedDirectly } from '../cli-run.js';
 import { ensureTypeScriptRuntime } from '../node-runtime.js';
 import { CASE_FORMAT_PROFILE } from './format-profile.js';
 import { sha256Uuid } from '../core/stable-id.js';
+import { isRecord } from '../core/node-envelope.js';
 export async function run(argv) {
     if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
         console.error('usage: compile <case.ts | BaseName> [-o caseplan.json]');
@@ -283,9 +284,6 @@ function visitRecords(value, visit) {
     for (const child of Object.values(value))
         visitRecords(child, visit);
 }
-function isRecord(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
 function stringValue(value) {
     return typeof value === 'string' && value.length > 0 ? value : undefined;
 }

package/dist/case/decompile.js

@@ -1,6 +1,8 @@
 import { commentText } from '../core/comment-text.js';
+import { tsLiteral, tsNumber } from '../core/ts-literal.js';
 import { CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS } from './format-profile.js';
 import { preserveSchemaVersion } from '../schema-version.js';
+import { ownEntry } from '../core/own-entry.js';
 const TASK_KIND_METHOD = {
     process: 'process',
     agent: 'agent',
@@ -9,20 +11,11 @@ const TASK_KIND_METHOD = {
     'case-management': 'caseManagement',
     'flow-process': 'flowProcess',
 };
-function str(value) {
-    return JSON.stringify(value).replace(/[\u2028\u2029]/g, (char) => `\\u${char.charCodeAt(0).toString(16)}`);
-}
 function boolLit(value) {
     return value ? 'true' : 'false';
 }
 function key(value) {
-    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value) ? value : str(value);
-}
-function literal(value) {
-    const rendered = JSON.stringify(value);
-    if (rendered === undefined)
-        throw new Error('cannot decompile a non-JSON value.');
-    return rendered.replace(/[\u2028\u2029]/g, (char) => `\\u${char.charCodeAt(0).toString(16)}`);
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value) ? value : tsLiteral(value);
 }
 function opts(entries) {
     const parts = entries.filter((entry) => entry[1] !== undefined)
@@ -122,8 +115,8 @@ function waitConnectorSpec(bag, owner, refs) {
         if (connectorKey === 'placeholder' && operation === 'placeholder')
             return '{}';
         return opts([
-            ['connectorKey', str(connectorKey)],
-            ['operation', str(operation)],
+            ['connectorKey', tsLiteral(connectorKey)],
+            ['operation', tsLiteral(operation)],
         ]);
     }
     return resolvedSubscriptionSource(bag, owner, 'event', refs);
@@ -195,13 +188,13 @@ function resolvedSubscriptionSource(bag, owner, kind, refs) {
     const where = subscriptionWhere(bag, owner);
     const filters = subscriptionFilters(config, owner);
     return opts([
-        ['connector', str(identity.key)],
-        ['event', str(identity.event)],
-        ['where', where !== undefined ? literal(where) : undefined],
-        ['filters', filters !== undefined ? literal(filters) : undefined],
-        ['connection', connection !== undefined ? str(connection) : undefined],
-        ['folder', folder !== undefined ? str(folder) : undefined],
-        ['version', identity.version !== '1.0.0' ? str(identity.version) : undefined],
+        ['connector', tsLiteral(identity.key)],
+        ['event', tsLiteral(identity.event)],
+        ['where', where !== undefined ? tsLiteral(where) : undefined],
+        ['filters', filters !== undefined ? tsLiteral(filters) : undefined],
+        ['connection', connection !== undefined ? tsLiteral(connection) : undefined],
+        ['folder', folder !== undefined ? tsLiteral(folder) : undefined],
+        ['version', identity.version !== '1.0.0' ? tsLiteral(identity.version) : undefined],
     ]);
 }
 function emitRule(rule, refs) {
@@ -220,20 +213,20 @@ function emitRule(rule, refs) {
             });
             label = `__UNRESOLVED_STAGE_ID__:${stageIds[0]}`;
         }
-        entries.push(['stage', str(label)]);
+        entries.push(['stage', tsLiteral(label)]);
     }
     if (rule.selectedTasksIds !== undefined) {
         const names = rule.selectedTasksIds.map((id) => {
             const name = refs.taskNameById.get(id);
             if (name !== undefined)
-                return str(name);
+                return tsLiteral(name);
             const message = `rule "${rule.rule}" references unknown task id "${id}".`;
             diagnose(refs, {
                 code: 'UNKNOWN_TASK_REFERENCE',
                 message,
                 location: `rule:${rule.id ?? rule.rule}`,
             });
-            return str(`__UNRESOLVED_TASK_ID__:${id}`);
+            return tsLiteral(`__UNRESOLVED_TASK_ID__:${id}`);
         });
         entries.push(['tasks', `[${names.join(', ')}]`]);
     }
@@ -246,18 +239,18 @@ function emitRule(rule, refs) {
         const sla = rule.slaId && refs.slaNameById.get(rule.slaId);
         if (!sla)
             throw new Error(`sla-status-change rule references unnamed or unknown SLA id "${rule.slaId ?? ''}".`);
-        entries.push(['sla', str(sla)]);
+        entries.push(['sla', tsLiteral(sla)]);
         if (rule.escalationId !== undefined) {
             const escalation = refs.escalationNameById.get(rule.escalationId);
             if (!escalation)
                 throw new Error(`sla-status-change rule references unnamed or unknown escalation id "${rule.escalationId}".`);
-            entries.push(['escalation', str(escalation)]);
+            entries.push(['escalation', tsLiteral(escalation)]);
         }
     }
     if (rule.conditionExpression !== undefined)
-        entries.push(['expression', str(rule.conditionExpression)]);
+        entries.push(['expression', tsLiteral(rule.conditionExpression)]);
     const options = opts(entries);
-    return options ? `rule(${str(rule.rule)}, ${options})` : `rule(${str(rule.rule)})`;
+    return options ? `rule(${tsLiteral(rule.rule)}, ${options})` : `rule(${tsLiteral(rule.rule)})`;
 }
 function emitRuleArg(condition, refs) {
     const groups = condition.rules ?? [];
@@ -272,7 +265,7 @@ function emitEntryWhen(out, depth, condition, refs, stage) {
     // only while that default was a constant: now that an omitted name is DERIVED
     // from the owner, dropping it would make decompile → compile rename the rule.
     // Round-trip identity over the existing corpus beats a tidier generated source.
-    const displayName = condition.displayName ? str(condition.displayName) : undefined;
+    const displayName = condition.displayName ? tsLiteral(condition.displayName) : undefined;
     const options = opts([
         ['displayName', displayName],
         ['isInterrupting', stage && condition.isInterrupting !== undefined ? boolLit(condition.isInterrupting) : undefined],
@@ -282,7 +275,7 @@ function emitEntryWhen(out, depth, condition, refs, stage) {
 }
 function emitExitWhen(out, depth, condition, refs, selectNextStage) {
     // See emitEntryWhen: the name is preserved verbatim so the round trip is exact.
-    const displayName = condition.displayName ? str(condition.displayName) : undefined;
+    const displayName = condition.displayName ? tsLiteral(condition.displayName) : undefined;
     let exitToStage;
     if (condition.exitToStageId !== undefined) {
         let label = refs.stageLabelById.get(condition.exitToStageId);
@@ -295,12 +288,12 @@ function emitExitWhen(out, depth, condition, refs, selectNextStage) {
             });
             label = `__UNRESOLVED_STAGE_ID__:${condition.exitToStageId}`;
         }
-        exitToStage = str(label);
+        exitToStage = tsLiteral(label);
     }
     const options = opts([
         ['displayName', displayName],
         ['marksStageComplete', condition.marksStageComplete !== undefined ? boolLit(condition.marksStageComplete) : undefined],
-        ['type', condition.type !== undefined ? str(condition.type) : undefined],
+        ['type', condition.type !== undefined ? tsLiteral(condition.type) : undefined],
         ['exitToStage', exitToStage],
         ['selectNextStage', selectNextStage],
     ]);
@@ -310,7 +303,7 @@ function emitExitWhen(out, depth, condition, refs, selectNextStage) {
 function emitCompleteWhen(out, depth, condition, refs) {
     // See emitEntryWhen: the name is preserved verbatim so the round trip is exact.
     const displayName = condition.displayName
-        ? str(condition.displayName)
+        ? tsLiteral(condition.displayName)
         : undefined;
     const options = opts([
         ['displayName', displayName],
@@ -323,13 +316,13 @@ function actionFields(rows) {
     if (!rows?.length)
         return undefined;
     return `[${rows.map((row) => opts([
-        ['name', str(row.name ?? '')],
-        ['type', row.type && row.type !== 'string' ? str(row.type) : undefined],
-        ['subType', row.subType !== undefined ? str(row.subType) : undefined],
-        ['displayName', row.displayName !== undefined ? str(row.displayName) : undefined],
-        ['value', row.value !== undefined ? literal(row.value) : undefined],
-        ['required', row.required !== undefined ? literal(row.required) : undefined],
-        ['options', row.options !== undefined ? literal(row.options) : undefined],
+        ['name', tsLiteral(row.name ?? '')],
+        ['type', row.type && row.type !== 'string' ? tsLiteral(row.type) : undefined],
+        ['subType', row.subType !== undefined ? tsLiteral(row.subType) : undefined],
+        ['displayName', row.displayName !== undefined ? tsLiteral(row.displayName) : undefined],
+        ['value', row.value !== undefined ? tsLiteral(row.value) : undefined],
+        ['required', row.required !== undefined ? tsLiteral(row.required) : undefined],
+        ['options', row.options !== undefined ? tsLiteral(row.options) : undefined],
     ])).join(', ')}]`;
 }
 function bindingName(value, refs) {
@@ -400,10 +393,10 @@ function selectNextStageByExit(plan, refs) {
         if (context.has('folderKey') && folder === undefined)
             throw new Error('select-next-stage connector folderKey must reference a root binding.');
         connectorSource = opts([
-            ['connectorKey', str(connectorKey)],
-            ['operation', str(operation)],
-            ['connection', connection !== undefined ? str(connection) : undefined],
-            ['folder', folder !== undefined ? str(folder) : undefined],
+            ['connectorKey', tsLiteral(connectorKey)],
+            ['operation', tsLiteral(operation)],
+            ['connection', connection !== undefined ? tsLiteral(connection) : undefined],
+            ['folder', folder !== undefined ? tsLiteral(folder) : undefined],
         ]);
     }
     const exits = (plan.nodes ?? []).filter(isStage)
@@ -412,7 +405,7 @@ function selectNextStageByExit(plan, refs) {
     if (exits.length !== 1)
         throw new Error(`select-next-stage connector requires exactly one wait-for-user exit; found ${exits.length}.`);
     return new Map([[exits[0], opts([
-                ['objectName', str(objectName)],
+                ['objectName', tsLiteral(objectName)],
                 ['connector', connectorSource],
             ])]]);
 }
@@ -476,12 +469,12 @@ function connectorCall(task, refs, library) {
     const connection = bindingName(context.get('connection')?.value, refs);
     const folder = bindingName(context.get('folderKey')?.value, refs);
     const options = opts([
-        ['connection', connection !== undefined ? str(connection) : undefined],
-        ['folder', folder !== undefined ? str(folder) : undefined],
-        ['version', identity.version !== '1.0.0' ? str(identity.version) : undefined],
-        ['object', identity.object !== undefined ? str(identity.object) : undefined],
+        ['connection', connection !== undefined ? tsLiteral(connection) : undefined],
+        ['folder', folder !== undefined ? tsLiteral(folder) : undefined],
+        ['version', identity.version !== '1.0.0' ? tsLiteral(identity.version) : undefined],
+        ['object', identity.object !== undefined ? tsLiteral(identity.object) : undefined],
     ]);
-    return `.connector(${str(identity.key)}, ${str(identity.action)}, ${literal(inputs)}${options ? `, ${options}` : ''})`;
+    return `.connector(${tsLiteral(identity.key)}, ${tsLiteral(identity.action)}, ${tsLiteral(inputs)}${options ? `, ${options}` : ''})`;
 }
 function externalCall(task, refs, library) {
     const kind = task.type;
@@ -558,12 +551,12 @@ function externalCall(task, refs, library) {
     if (output.name !== 'response' || output.type !== 'json' || output.source !== '.'
         || typeof output.var !== 'string' || output.id !== output.var)
         throw new Error(`${owner} has an unsupported response output.`);
-    const descriptor = `{ nodeType: ${str(resolved.nodeType)}, version: ${str(resolved.version)} }`;
+    const descriptor = `{ nodeType: ${tsLiteral(resolved.nodeType)}, version: ${tsLiteral(resolved.version)} }`;
     const options = opts([
-        ['connection', str(binding('connection'))],
-        ['folder', str(binding('folderKey'))],
-        ['mode', str(mode)],
-        ['inputs', literal(inputs)],
+        ['connection', tsLiteral(binding('connection'))],
+        ['folder', tsLiteral(binding('folderKey'))],
+        ['mode', tsLiteral(mode)],
+        ['inputs', tsLiteral(inputs)],
     ]);
     const method = kind === 'external-agent' ? 'externalAgent' : 'externalWorkflow';
     return `.${method}(${descriptor}, ${options})`;
@@ -571,16 +564,17 @@ function externalCall(task, refs, library) {
 function emitTaskKind(task, refs, library) {
     const kind = task.type;
     const data = task.data ?? {};
-    if (TASK_KIND_METHOD[kind]) {
+    const method = ownEntry(TASK_KIND_METHOD, kind);
+    if (method) {
         if (kind !== 'flow-process' && data.name === undefined && data.folderPath === undefined) {
             if ((Array.isArray(data.inputs) && data.inputs.length) || (Array.isArray(data.outputs) && data.outputs.length))
                 throw new Error(`unresolved ${kind} task "${task.displayName ?? task.id ?? '?'}" cannot carry input or output bindings.`);
-            return `.unresolved(${str(kind)})`;
+            return `.unresolved(${tsLiteral(kind)})`;
         }
         const name = bindingDefault(data.name, refs);
         const folderPath = bindingDefault(data.folderPath, refs);
-        const folder = folderPath ? `, ${opts([['folder', str(folderPath)]])}` : '';
-        return `.${TASK_KIND_METHOD[kind]}(${str(name ?? '')}${folder})`;
+        const folder = folderPath ? `, ${opts([['folder', tsLiteral(folderPath)]])}` : '';
+        return `.${method}(${tsLiteral(name ?? '')}${folder})`;
     }
     if (kind === 'action') {
         let recipient;
@@ -589,15 +583,15 @@ function emitTaskKind(task, refs, library) {
             if (!Number.isFinite(type))
                 throw new Error(`task recipient has a non-numeric type "${data.recipient.Type}".`);
             recipient = type === 2
-                ? str(data.recipient.Value)
-                : opts([['type', String(type)], ['value', str(data.recipient.Value)]]);
+                ? tsLiteral(data.recipient.Value)
+                : opts([['type', String(type)], ['value', tsLiteral(data.recipient.Value)]]);
         }
         const spec = opts([
-            ['title', data.taskTitle !== undefined ? str(data.taskTitle) : undefined],
-            ['priority', data.priority && data.priority !== 'Medium' ? str(data.priority) : undefined],
+            ['title', data.taskTitle !== undefined ? tsLiteral(data.taskTitle) : undefined],
+            ['priority', data.priority && data.priority !== 'Medium' ? tsLiteral(data.priority) : undefined],
             ['recipient', recipient],
-            ['labels', data.labels !== undefined ? str(data.labels) : undefined],
-            ['actionCatalogName', data.actionCatalogName !== undefined ? str(data.actionCatalogName) : undefined],
+            ['labels', data.labels !== undefined ? tsLiteral(data.labels) : undefined],
+            ['actionCatalogName', data.actionCatalogName !== undefined ? tsLiteral(data.actionCatalogName) : undefined],
             ['inputs', actionFields(data.inputs)],
             ['outputs', actionFields(data.outputs)],
         ]);
@@ -609,9 +603,9 @@ function emitTaskKind(task, refs, library) {
         return externalCall(task, refs, library);
     if (kind === 'wait-for-timer') {
         const spec = opts([
-            ['duration', data.timeDuration !== undefined ? str(data.timeDuration) : undefined],
-            ['date', data.timeDate !== undefined ? str(data.timeDate) : undefined],
-            ['cycle', data.timeCycle !== undefined ? str(data.timeCycle) : undefined],
+            ['duration', data.timeDuration !== undefined ? tsLiteral(data.timeDuration) : undefined],
+            ['date', data.timeDate !== undefined ? tsLiteral(data.timeDate) : undefined],
+            ['cycle', data.timeCycle !== undefined ? tsLiteral(data.timeCycle) : undefined],
         ]);
         return `.waitForTimer(${spec})`;
     }
@@ -625,25 +619,25 @@ function emitTaskKind(task, refs, library) {
         message,
         location: `task:${task.id ?? task.displayName ?? '?'}`,
     });
-    return `.__UNRESOLVED_TASK_KIND__(${str(kind)}, ${literal(data)})`;
+    return `.__UNRESOLVED_TASK_KIND__(${tsLiteral(kind)}, ${tsLiteral(data)})`;
 }
 function ioArg(rows, kind) {
     const valueField = kind === 'inputs' ? 'value' : 'source';
     const entries = rows.map((row) => {
         const name = kind === 'inputs' ? row.name : row.var;
-        const value = str(row[valueField] ?? '');
+        const value = tsLiteral(row[valueField] ?? '');
         const cell = row.type && row.type !== 'string'
-            ? `{ ${valueField}: ${value}, type: ${str(row.type)} }`
+            ? `{ ${valueField}: ${value}, type: ${tsLiteral(row.type)} }`
             : value;
         return `${key(String(name ?? ''))}: ${cell}`;
     });
     return `{ ${entries.join(', ')} }`;
 }
 function emitTask(out, depth, task, lane, refs, library) {
-    out.line(depth, `.task(${str(task.displayName ?? '')}, t => t`);
+    out.line(depth, `.task(${tsLiteral(task.displayName ?? '')}, t => t`);
     const inner = depth + 1;
     out.line(inner, emitTaskKind(task, refs, library));
-    if (TASK_KIND_METHOD[task.type]) {
+    if (ownEntry(TASK_KIND_METHOD, task.type)) {
         const data = task.data ?? {};
         if (Array.isArray(data.inputs) && data.inputs.length)
             out.line(inner, `.inputs(${ioArg(data.inputs, 'inputs')})`);
@@ -655,9 +649,9 @@ function emitTask(out, depth, task, lane, refs, library) {
     if (task.shouldRunOnlyOnce !== undefined)
         out.line(inner, task.shouldRunOnlyOnce ? '.runOnce()' : '.runOnReEntry()');
     if (task.description)
-        out.line(inner, `.description(${str(task.description)})`);
+        out.line(inner, `.description(${tsLiteral(task.description)})`);
     if (task.skipCondition)
-        out.line(inner, `.skipWhen(${str(task.skipCondition)})`);
+        out.line(inner, `.skipWhen(${tsLiteral(task.skipCondition)})`);
     for (const condition of task.entryConditions ?? [])
         emitEntryWhen(out, inner, condition, refs, false);
     out.line(depth, lane > 0 ? `, ${opts([['lane', String(lane)]])})` : ')');
@@ -673,18 +667,18 @@ function escalationSource(escalation, slaName, index) {
             throw new Error(`SLA escalation "${escalation.displayName ?? escalation.id ?? index}" has unsupported recipient scope "${recipient.scope}".`);
         const helper = recipient.scope === 'User' ? 'toUser' : 'toGroup';
         const target = recipient.target ?? '';
-        const value = recipient.value !== undefined && recipient.value !== target ? `, ${str(recipient.value)}` : '';
-        return `${helper}(${str(target)}${value})`;
+        const value = recipient.value !== undefined && recipient.value !== target ? `, ${tsLiteral(recipient.value)}` : '';
+        return `${helper}(${tsLiteral(target)}${value})`;
     });
     const generatedName = `Escalation rule ${index + 1} - ${slaName}`;
     const trigger = escalation.triggerInfo?.type;
     if (trigger !== 'at-risk' && trigger !== 'sla-breached')
         throw new Error(`SLA escalation "${escalation.displayName ?? escalation.id ?? index}" has unsupported trigger "${trigger}".`);
     return `escalation(${opts([
-        ['displayName', escalation.displayName && escalation.displayName !== generatedName ? str(escalation.displayName) : undefined],
-        ['trigger', str(trigger)],
+        ['displayName', escalation.displayName && escalation.displayName !== generatedName ? tsLiteral(escalation.displayName) : undefined],
+        ['trigger', tsLiteral(trigger)],
         ['atRiskPercentage', trigger === 'at-risk' && escalation.triggerInfo?.atRiskPercentage !== undefined
-                ? String(escalation.triggerInfo.atRiskPercentage)
+                ? tsNumber(escalation.triggerInfo.atRiskPercentage)
                 : undefined],
         ['notify', `[${notify.join(', ')}]`],
     ])})`;
@@ -693,20 +687,20 @@ function slaSource(sla, index) {
     const displayName = sla.displayName ?? `SLA ${index + 1}`;
     const escalations = (sla.escalationRule ?? []).map((entry, escalationIndex) => escalationSource(entry, displayName, escalationIndex));
     return opts([
-        ['displayName', sla.displayName !== undefined ? str(sla.displayName) : undefined],
-        ['count', sla.count !== undefined ? String(sla.count) : undefined],
-        ['unit', sla.unit !== undefined ? str(sla.unit) : undefined],
-        ['when', sla.expression !== undefined && sla.expression !== '=js:true' ? str(sla.expression) : undefined],
+        ['displayName', sla.displayName !== undefined ? tsLiteral(sla.displayName) : undefined],
+        ['count', sla.count !== undefined ? tsNumber(sla.count) : undefined],
+        ['unit', sla.unit !== undefined ? tsLiteral(sla.unit) : undefined],
+        ['when', sla.expression !== undefined && sla.expression !== '=js:true' ? tsLiteral(sla.expression) : undefined],
         ['escalations', escalations.length ? `[${escalations.join(', ')}]` : undefined],
     ]);
 }
 function emitStage(out, depth, stage, refs, library, selectNextStage) {
     const exception = stage.type.endsWith('ExceptionStage') || stage.stageType === 'secondary' || stage.data?.stageType === 'secondary';
     const data = stage.data ?? {};
-    out.line(depth, `.${exception ? 'exceptionStage' : 'stage'}(${str(data.label ?? '')}, s => s`);
+    out.line(depth, `.${exception ? 'exceptionStage' : 'stage'}(${tsLiteral(data.label ?? '')}, s => s`);
     const inner = depth + 1;
     if (data.description)
-        out.line(inner, `.description(${str(data.description)})`);
+        out.line(inner, `.description(${tsLiteral(data.description)})`);
     if (data.isRequired !== undefined)
         out.line(inner, data.isRequired ? '.required()' : '.required(false)');
     for (const condition of data.entryConditions ?? [])
@@ -721,15 +715,15 @@ function emitStage(out, depth, stage, refs, library, selectNextStage) {
 function varSpec(entry) {
     const body = entry.body ?? entry._jsonSchema;
     if (entry.type === 'jsonSchema' && body !== undefined && entry.default === undefined)
-        return `jsonSchema(${literal(body)})`;
+        return `jsonSchema(${tsLiteral(body)})`;
     if (entry.default !== undefined || (entry.type === 'jsonSchema' && body !== undefined)) {
         return opts([
-            ['type', str(entry.type)],
-            ['default', entry.default !== undefined ? literal(entry.default) : undefined],
-            ['body', entry.type === 'jsonSchema' && body !== undefined ? literal(body) : undefined],
+            ['type', tsLiteral(entry.type)],
+            ['default', entry.default !== undefined ? tsLiteral(entry.default) : undefined],
+            ['body', entry.type === 'jsonSchema' && body !== undefined ? tsLiteral(body) : undefined],
         ]);
     }
-    return str(entry.type);
+    return tsLiteral(entry.type);
 }
 function isResolvedConnectorOutput(row, triggerId, resolved) {
     if (!resolved || row.elementId !== triggerId)
@@ -753,7 +747,7 @@ function producedVariableNames(plan) {
             continue;
         for (const lane of node.data?.tasks ?? [])
             for (const task of lane)
-                if (TASK_KIND_METHOD[task.type])
+                if (ownEntry(TASK_KIND_METHOD, task.type))
                     for (const row of task.data?.outputs ?? [])
                         if (row.var)
                             produced.add(row.var);
@@ -776,10 +770,10 @@ function emitVariables(out, depth, plan, triggerNameById) {
             continue;
         const body = variable.body ?? variable._jsonSchema;
         const type = variable.type === 'jsonSchema' && body !== undefined
-            ? `jsonSchema(${literal(body)})`
-            : str(variable.type);
-        const defaultValue = variable.default !== undefined ? `, ${literal(variable.default)}` : '';
-        out.line(depth, `.var(${str(variable.name)}, ${type}${defaultValue})`);
+            ? `jsonSchema(${tsLiteral(body)})`
+            : tsLiteral(variable.type);
+        const defaultValue = variable.default !== undefined ? `, ${tsLiteral(variable.default)}` : '';
+        out.line(depth, `.var(${tsLiteral(variable.name)}, ${type}${defaultValue})`);
     }
 }
 function triggerData(node) {
@@ -804,16 +798,16 @@ function bridgeRows(plan, triggerId, bag) {
 }
 function triggerSource(node, index, plan, refs) {
     const { label, description, bag } = triggerData(node);
-    const name = label !== `Trigger ${index + 1}` ? str(label) : undefined;
+    const name = label !== `Trigger ${index + 1}` ? tsLiteral(label) : undefined;
     if (!bag?.serviceType || bag.serviceType === 'None')
-        return `manualTrigger(${opts([['name', name], ['description', description ? str(description) : undefined]])})`;
+        return `manualTrigger(${opts([['name', name], ['description', description ? tsLiteral(description) : undefined]])})`;
     if (bag.serviceType === 'Intsvc.TimerTrigger' || bag.serviceType === 'timer') {
         if (bag.timerType !== undefined && bag.timerType !== 'timeCycle')
             throw new Error(`timer trigger "${label ?? node.id ?? index}" has unsupported timerType "${bag.timerType}".`);
         return `timerTrigger(${opts([
-            ['every', bag.timeCycle !== undefined ? str(bag.timeCycle) : undefined],
+            ['every', bag.timeCycle !== undefined ? tsLiteral(bag.timeCycle) : undefined],
             ['name', name],
-            ['description', description ? str(description) : undefined],
+            ['description', description ? tsLiteral(description) : undefined],
         ])})`;
     }
     if (bag.serviceType === 'Intsvc.EventTrigger') {
@@ -825,16 +819,16 @@ function triggerSource(node, index, plan, refs) {
             : undefined;
         const outputShape = outputs.length
             ? `{ ${outputs.map((row) => {
-                const source = str(row.source ?? '');
+                const source = tsLiteral(row.source ?? '');
                 const cell = row.type && row.type !== 'string'
-                    ? `{ source: ${source}, type: ${str(row.type)} }`
+                    ? `{ source: ${source}, type: ${tsLiteral(row.type)} }`
                     : source;
                 return `${key(String(row.var ?? row.name ?? ''))}: ${cell}`;
             }).join(', ')} }`
             : undefined;
         return `eventTrigger(${opts([
             ['name', name],
-            ['description', description ? str(description) : undefined],
+            ['description', description ? tsLiteral(description) : undefined],
             ['subscription', subscription],
             ['outputs', outputShape],
         ])})`;
@@ -866,7 +860,7 @@ function caseAppSource(config) {
             throw new Error(`caseAppConfig section "${section.title}" detail "${nested[0]}" is not primitive.`);
         return { id: section.id, title: section.title, details };
     });
-    return literal({ summary: config.caseSummary, sections });
+    return tsLiteral({ summary: config.caseSummary, sections });
 }
 function refuseUnsupportedAuthoring(plan) {
     if (plan.metadata?.adhocCaseEndData !== undefined)
@@ -1152,7 +1146,7 @@ export function decompileWithDiagnostics(plan, options = {}) {
     });
     if (triggers.length)
         out.line(0, '');
-    out.line(0, `${preservation ? 'const caseDefinition =' : 'export default'} casePlan(${str(slugId(plan))})`);
+    out.line(0, `${preservation ? 'const caseDefinition =' : 'export default'} casePlan(${tsLiteral(slugId(plan))})`);
     const depth = 1;
     // The declared grammar version first, mirroring the document's own key order
     // and emitted even when it equals this SDK's write version: preserving means
@@ -1167,14 +1161,14 @@ export function decompileWithDiagnostics(plan, options = {}) {
     if (schema.problem)
         out.line(depth, `// TODO: ${commentText(schema.problem)}`);
     if (plan.name !== undefined)
-        out.line(depth, `.name(${str(plan.name)})`);
+        out.line(depth, `.name(${tsLiteral(plan.name)})`);
     if (plan.description !== undefined)
-        out.line(depth, `.description(${str(plan.description)})`);
+        out.line(depth, `.description(${tsLiteral(plan.description)})`);
     if (metadata.caseIdentifier !== undefined) {
         const type = metadata.caseIdentifierType && metadata.caseIdentifierType !== 'constant'
-            ? `, ${str(metadata.caseIdentifierType)}`
+            ? `, ${tsLiteral(metadata.caseIdentifierType)}`
             : '';
-        out.line(depth, `.identifier(${str(metadata.caseIdentifier)}${type})`);
+        out.line(depth, `.identifier(${tsLiteral(metadata.caseIdentifier)}${type})`);
     }
     if (metadata.caseAppConfig !== undefined)
         out.line(depth, `.caseApp(${caseAppSource(metadata.caseAppConfig)})`);
@@ -1198,7 +1192,7 @@ export function decompileWithDiagnostics(plan, options = {}) {
     out.line(depth, '.build();');
     if (preservation) {
         out.line(0, '');
-        out.line(0, `export default preserveCaseJson(caseDefinition, ${literal(preservation)});`);
+        out.line(0, `export default preserveCaseJson(caseDefinition, ${tsLiteral(preservation)});`);
     }
     const imports = ['casePlan', 'rule', 'manualTrigger', 'timerTrigger', 'eventTrigger', 'jsonSchema', 'escalation', 'toUser', 'toGroup'];
     if (preservation)
@@ -1210,7 +1204,7 @@ export function decompileWithDiagnostics(plan, options = {}) {
                 .replace(/[\r\n]+/g, ' ')),
         ].join('\n')}\n\n`
         : '';
-    const source = `import { ${imports.join(', ')} } from ${str(options.importSpecifier ?? './case-sdk.js')};\n\n${diagnosticHeader}${out.toString()}\n`;
+    const source = `import { ${imports.join(', ')} } from ${tsLiteral(options.importSpecifier ?? './case-sdk.js')};\n\n${diagnosticHeader}${out.toString()}\n`;
     return { source, diagnostics };
 }
 export function decompile(plan, options = {}) {

package/dist/case/entry-points.js

@@ -27,6 +27,7 @@
  * `elementId`); its `output` projects every Out-arg (default from the Out-arg's
  * `inputOutputs` companion).
  */
+import { ownEntry } from '../core/own-entry.js';
 /** The fixed JobAttachment definition a `file` property `$ref`s into. */
 export const JOB_ATTACHMENT_DEFINITION = {
     type: 'object',
@@ -52,7 +53,7 @@ function propertyForVar(v) {
     }
     // Build in the platform's key order: type, format, title, default.
     const out = {};
-    const tf = TYPE_FORMAT[type];
+    const tf = ownEntry(TYPE_FORMAT, type);
     if (tf) {
         out.type = tf.type;
         if (tf.format)