@uipath/maestro-builder-sdk 6.17.5 → 6.18.0

package/dist/decompile.js

@@ -36,6 +36,7 @@ import { fileURLToPath } from 'node:url';
 import { inferScriptShape } from './core/script-return.js';
 import { DEFAULT_TRIGGER_ID } from './core/expr.js';
 import { commentText } from './core/comment-text.js';
+import { tsLiteral, tsNumber, tsText } from './core/ts-literal.js';
 import { parseIxpProjectType } from './core/actions.js';
 import { readFlowGlobals } from './flow-variables.js';
 import { missingBindingLabels } from './core/binding-messages.js';
@@ -127,11 +128,11 @@ function verClause(node) {
         const shipped = [...CORE_DEFINITION_KEYS]
             .filter((k) => k.startsWith(`${node.type}@`))
             .map((k) => k.slice(node.type.length + 1));
-        warnOnce(`node ${str(node.id)} pins ${node.type}@${tv}, but this SDK bundles ${node.type}@${shipped.join(', ') || '<none>'} only; `
-            + `\`compile\` will refuse the emitted { version: ${str(tv)} } (versions resolve exactly, flow-builder-sdk#71). `
+        warnOnce(`node ${tsLiteral(node.id)} pins ${node.type}@${tv}, but this SDK bundles ${node.type}@${shipped.join(', ') || '<none>'} only; `
+            + `\`compile\` will refuse the emitted { version: ${tsLiteral(tv)} } (versions resolve exactly, flow-builder-sdk#71). `
             + `The source keeps the file's pair; to recompile, drop that { version } and the node takes the SDK's pinned version.`);
     }
-    return `version: ${str(tv)}`;
+    return `version: ${tsLiteral(tv)}`;
 }
 function verArg(node) {
     const clause = verClause(node);
@@ -148,7 +149,7 @@ function triggerOptParts(node) {
         parts.push(ver);
     const label = node.display?.label;
     if (typeof label === 'string' && label !== definitionLabel(node))
-        parts.push(`label: ${str(label)}`);
+        parts.push(`label: ${tsLiteral(label)}`);
     return parts;
 }
 /** `triggerOptParts` as the `.trigger(spec, { ... })` options argument. */
@@ -176,7 +177,7 @@ function optsArgWith(node, ctx, extra) {
     // compile. Equal-to-default is omitted so ordinary flows stay quiet.
     const label = node.display?.label;
     if (typeof label === 'string' && label !== node.id)
-        parts.push(`label: ${str(label)}`);
+        parts.push(`label: ${tsLiteral(label)}`);
     const updates = ctx.flow.variables?.variableUpdates?.[node.id] ?? [];
     if (updates.length) {
         const entries = updates.map((u) => `${key(u.variableId)}: ${emitVal(u.expression, ctx.imp, ctx.inputNames)}`);
@@ -233,27 +234,13 @@ function isTrigger(type) {
     return type.startsWith('core.trigger.') || type.startsWith('uipath.connector.event.') || type.startsWith('uipath.connector.trigger.');
 }
 // ─── Injection-safe source emitters (ported verbatim from case/decompile.ts) ──
-/**
- * A JS/TS string literal (double-quoted, correctly escaped). `JSON.stringify`
- * escapes quotes, backslashes and control chars — so untrusted `.flow` values
- * (labels, expressions, code) can never break out of the literal. We also escape
- * U+2028/U+2029 (legal in JSON, historically illegal in JS string literals).
- * Non-string input still serializes to inert JSON (never executable).
- */
-function str(s) {
-    return JSON.stringify(s).replace(/[\u2028\u2029]/g, (c) => '\\u' + c.charCodeAt(0).toString(16));
-}
 /** A boolean literal, coerced so an untrusted non-boolean can never reach source verbatim. */
 function boolLit(v) {
     return v ? 'true' : 'false';
 }
 /** An object key: a bare identifier when legal, otherwise a quoted string. */
 function key(k) {
-    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(k) ? k : str(k);
-}
-/** An arbitrary JSON-serializable value as a TS literal (used for var defaults). */
-function literal(v) {
-    return JSON.stringify(v);
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(k) ? k : tsLiteral(k);
 }
 /** Render an options object from present entries; '' when nothing is present. */
 function opts(entries) {
@@ -283,7 +270,7 @@ class Imports {
     }
     line(specifier) {
         const names = [...this.used].sort();
-        return `import { ${names.join(', ')} } from ${str(specifier)};`;
+        return `import { ${names.join(', ')} } from ${tsLiteral(specifier)};`;
     }
 }
 // ─── Expression inversion ─────────────────────────────────────────────────────
@@ -344,7 +331,7 @@ function emitRef(jsBody, imp, inputNames) {
     const PATH = '[A-Za-z_]\\w*(?:\\.[A-Za-z_]\\w*|\\[\\d+\\])*';
     // !!$vars.<step>.output  →  ran('step')
     if ((m = body.match(/^!!\$vars\.([A-Za-z_]\w*)\.output$/)))
-        return `${imp.use('ran')}(${str(m[1])})`;
+        return `${imp.use('ran')}(${tsLiteral(m[1])})`;
     // $vars.<step>.output[.<path>]  →  out('step'[, 'path'])
     if ((m = body.match(new RegExp(`^\\$vars\\.([A-Za-z_]\\w*)\\.output(?:\\.(${PATH}))?$`)))) {
         // A flow INPUT is published as the trigger's output, so
@@ -352,20 +339,20 @@ function emitRef(jsBody, imp, inputNames) {
         // Recover the author's spelling rather than the mechanical `out('start', …)`;
         // both re-serialize identically, but only one reads like the source.
         if (m[1] === currentTriggerId && m[2] !== undefined && inputNames.has(m[2])) {
-            return `${imp.use('input')}(${str(m[2])})`;
+            return `${imp.use('input')}(${tsLiteral(m[2])})`;
         }
-        return m[2] === undefined ? `${imp.use('out')}(${str(m[1])})` : `${imp.use('out')}(${str(m[1])}, ${str(m[2])})`;
+        return m[2] === undefined ? `${imp.use('out')}(${tsLiteral(m[1])})` : `${imp.use('out')}(${tsLiteral(m[1])}, ${tsLiteral(m[2])})`;
     }
     // $vars.<step>.error[.<field>]  →  err('step'[, 'field'])
     if ((m = body.match(new RegExp(`^\\$vars\\.([A-Za-z_]\\w*)\\.error(?:\\.(${PATH}))?$`)))) {
-        return m[2] === undefined ? `${imp.use('err')}(${str(m[1])})` : `${imp.use('err')}(${str(m[1])}, ${str(m[2])})`;
+        return m[2] === undefined ? `${imp.use('err')}(${tsLiteral(m[1])})` : `${imp.use('err')}(${tsLiteral(m[1])}, ${tsLiteral(m[2])})`;
     }
     // $vars.<name>  →  input('name') for a declared input, else v('name').
     // The bare spelling predates flow inputs moving to `<trigger>.output.<name>`;
     // still read it so an older artifact decompiles.
     if ((m = body.match(/^\$vars\.([A-Za-z_]\w*)$/))) {
         const name = m[1];
-        return inputNames.has(name) ? `${imp.use('input')}(${str(name)})` : `${imp.use('v')}(${str(name)})`;
+        return inputNames.has(name) ? `${imp.use('input')}(${tsLiteral(name)})` : `${imp.use('v')}(${tsLiteral(name)})`;
     }
     // Composite / unrecognized: a raw JS expression template.
     return `${imp.use('js')}${jsTemplate(body)}`;
@@ -380,14 +367,17 @@ function emitRef(jsBody, imp, inputNames) {
  * builder takes `Expr | string | unknown` (bare values pass through `toExpr`).
  */
 function emitVal(v, imp, inputNames) {
+    // a present-but-undefined value stays the TS expression `undefined` (the behaviour this branch shipped; opts() drops an entry whose value is undefined before it reaches here)
+    if (v === undefined)
+        return 'undefined';
     const raw = unwrapSource(v);
     if (raw !== undefined && !Array.isArray(v)) {
         if (raw.startsWith('=js:'))
             return emitRef(raw.slice(4), imp, inputNames);
-        return str(raw); // a literal string (valid as Expr via toExpr, or as a raw string input)
+        return tsLiteral(raw); // a literal string (valid as Expr via toExpr, or as a raw string input)
     }
     // A raw JSON literal (number / boolean / null / array / object).
-    return literal(v);
+    return tsLiteral(v);
 }
 /** A bare (unprefixed) JS expression, as decision/switch nodes store it. */
 function emitBareExpr(raw, imp, inputNames) {
@@ -530,7 +520,7 @@ function emitStepSpec(node, imp, inputNames, o, graph) {
             // infers from the body first (see `scriptOutputs`), so a script whose type
             // is already plain in its code round-trips without it — emitting one there
             // would add an argument the author never wrote to every such step.
-            return `${imp.use('script')}(${opts([['code', str(code)], ...scriptReturnsOpt(node, code)])})`;
+            return `${imp.use('script')}(${opts([['code', tsLiteral(code)], ...scriptReturnsOpt(node, code)])})`;
         }
         case T.delay: {
             // serialize's `delayInputs` writes `{timerType, timerPreset, timerValue?}`
@@ -538,18 +528,18 @@ function emitStepSpec(node, imp, inputNames, o, graph) {
             // wait. Invert all three spellings.
             if (inputs.timerType === 'timeDate') {
                 const until = typeof inputs.timerDate === 'string' ? inputs.timerDate : '';
-                return `${imp.use('delay')}(${opts([['until', str(until)]])})`;
+                return `${imp.use('delay')}(${opts([['until', tsLiteral(until)]])})`;
             }
             const duration = inputs.timerPreset === 'custom'
                 ? (typeof inputs.timerValue === 'string' ? inputs.timerValue : '')
                 : (typeof inputs.timerPreset === 'string' ? inputs.timerPreset : '');
-            return `${imp.use('delay')}(${opts([['duration', str(duration)]])})`;
+            return `${imp.use('delay')}(${opts([['duration', tsLiteral(duration)]])})`;
         }
         case T.documentClassify:
         case T.dynamicExtract: {
             const fr = unwrapSource(inputs.fileRef) ?? '';
-            const fileSrc = fr.startsWith('=js:') ? emitBareExpr(fr.slice(4), imp, inputNames) : str(fr);
-            const pageRange = typeof inputs.pageRange === 'string' && inputs.pageRange !== '' ? str(inputs.pageRange) : undefined;
+            const fileSrc = fr.startsWith('=js:') ? emitBareExpr(fr.slice(4), imp, inputNames) : tsLiteral(fr);
+            const pageRange = typeof inputs.pageRange === 'string' && inputs.pageRange !== '' ? tsLiteral(inputs.pageRange) : undefined;
             if (node.type === T.documentClassify) {
                 const split = unwrapPlain(inputs.splitPages);
                 return `${imp.use('documentClassify')}(${opts([
@@ -558,7 +548,7 @@ function emitStepSpec(node, imp, inputNames, o, graph) {
                     ['splitPages', split === true ? 'true' : undefined],
                 ])})`;
             }
-            const schema = inputs.schemaDocument !== undefined ? literal(inputs.schemaDocument) : undefined;
+            const schema = inputs.schemaDocument !== undefined ? tsLiteral(inputs.schemaDocument) : undefined;
             return `${imp.use('dynamicExtract')}(${opts([
                 ['fileRef', fileSrc],
                 ['schema', schema],
@@ -570,9 +560,9 @@ function emitStepSpec(node, imp, inputNames, o, graph) {
         case T.dataFabricUpdate:
         case T.dataFabricDelete: {
             const cfg = (inputs.entityConfig ?? {});
-            const entity = str(String(cfg.entityName ?? ''));
-            const folder = typeof cfg._folderKey === 'string' ? str(cfg._folderKey) : undefined;
-            const resourceKey = typeof cfg._resourceKey === 'string' ? str(cfg._resourceKey) : undefined;
+            const entity = tsText(cfg.entityName);
+            const folder = typeof cfg._folderKey === 'string' ? tsLiteral(cfg._folderKey) : undefined;
+            const resourceKey = typeof cfg._resourceKey === 'string' ? tsLiteral(cfg._resourceKey) : undefined;
             const val = (v) => {
                 // 1.3 let `recordId` and a create's field value be a `{ type:
                 // 'jsExpression', expression }` object as well as a `=js:` string. A
@@ -582,14 +572,14 @@ function emitStepSpec(node, imp, inputNames, o, graph) {
                     return emitBareExpr(String(obj.expression ?? ''), imp, inputNames);
                 }
                 const raw = typeof v === 'string' ? v : String(v ?? '');
-                return raw.startsWith('=js:') ? emitBareExpr(raw.slice(4), imp, inputNames) : str(raw);
+                return raw.startsWith('=js:') ? emitBareExpr(raw.slice(4), imp, inputNames) : tsLiteral(raw);
             };
             const fieldObject = (rows) => {
                 const list = Array.isArray(rows) ? rows : [];
                 return `{ ${list.map((r) => `${key(String(r.field ?? ''))}: ${val(r.value)}`).join(', ')} }`;
             };
             const record = cfg.recordSource === 'fromRead'
-                ? `{ fromRead: ${str(String(cfg.readEntityNodeId ?? ''))} }`
+                ? `{ fromRead: ${tsText(cfg.readEntityNodeId)} }`
                 : `{ byId: ${val(cfg.recordId)} }`;
             if (node.type === T.dataFabricRead) {
                 // The array is what the platform serializer reads and what compile
@@ -597,8 +587,8 @@ function emitStepSpec(node, imp, inputNames, o, graph) {
                 // here so a canvas-authored file still decompiles. Both flatten to the
                 // builder's row list, where `or: true` marks each new OR alternative.
                 const filterRow = (r, or = false) => opts([
-                    ['field', str(String(r.field ?? ''))],
-                    ['operator', r.operator !== undefined && r.operator !== '=' ? str(String(r.operator)) : undefined],
+                    ['field', tsText(r.field)],
+                    ['operator', r.operator !== undefined && r.operator !== '=' ? tsLiteral(String(r.operator)) : undefined],
                     ['value', val(r.value)],
                     ['or', or ? 'true' : undefined],
                 ]);
@@ -621,15 +611,15 @@ function emitStepSpec(node, imp, inputNames, o, graph) {
                 // `resultMode` only exists from 1.4, and recovering it re-selects 1.4 on
                 // the way back out — so a 1.0 node stays a 1.0 node through the round trip.
                 const mode = cfg.resultMode === 'single' || cfg.resultMode === 'multiple'
-                    ? str(cfg.resultMode) : undefined;
+                    ? tsLiteral(cfg.resultMode) : undefined;
                 const sort = cfg._sort && typeof cfg._sort === 'object'
                     ? opts([
-                        ['field', str(String(cfg._sort.field ?? ''))],
-                        ['direction', cfg._sort.direction === 'desc' ? str('desc') : undefined],
+                        ['field', tsText(cfg._sort.field)],
+                        ['direction', cfg._sort.direction === 'desc' ? tsLiteral('desc') : undefined],
                     ])
                     : undefined;
                 const fields = Array.isArray(cfg._selectedFieldNames) && cfg._selectedFieldNames.length
-                    ? `[${cfg._selectedFieldNames.map((f) => str(String(f))).join(', ')}]`
+                    ? `[${cfg._selectedFieldNames.map((f) => tsLiteral(String(f))).join(', ')}]`
                     : undefined;
                 return `${imp.use('dataFabricRead')}(${opts([
                     ['entity', entity], ['filters', filters], ['resultMode', mode],
@@ -661,7 +651,7 @@ function emitStepSpec(node, imp, inputNames, o, graph) {
                 const raw = typeof x === 'string' ? x : String(x?.expression ?? x ?? '');
                 return raw.startsWith('=js:') ? emitBareExpr(raw.slice(4), imp, inputNames)
                     : raw.startsWith('$vars.') ? emitBareExpr(raw, imp, inputNames)
-                        : str(raw);
+                        : tsLiteral(raw);
             };
             if (node.type === T.createOutgoingCall) {
                 return `${imp.use('createOutgoingCall')}(${opts([['from', v(i.from)], ['to', v(i.to)]])})`;
@@ -690,16 +680,16 @@ function emitStepSpec(node, imp, inputNames, o, graph) {
                 // value, so it must not come back as one.
                 if (raw === undefined || raw === '')
                     return undefined;
-                return raw.startsWith('=js:') ? emitBareExpr(raw.slice(4), imp, inputNames) : str(raw);
+                return raw.startsWith('=js:') ? emitBareExpr(raw.slice(4), imp, inputNames) : tsLiteral(raw);
             };
             const priority = unwrapPlain(inputs.priority);
             return `${imp.use('queueItem')}(${opts([
-                ['queue', str(String(q.name ?? ''))],
-                ['folderPath', str(String(q.folderPath ?? ''))],
-                ['key', str(String(q.key ?? ''))],
+                ['queue', tsText(q.name)],
+                ['folderPath', tsText(q.folderPath)],
+                ['key', tsText(q.key)],
                 ['item', rows.length ? objLit(rows) : '{}'],
                 // `Normal` is the definition's default — only a departure was authored.
-                ['priority', typeof priority === 'string' && priority !== 'Normal' ? str(priority) : undefined],
+                ['priority', typeof priority === 'string' && priority !== 'Normal' ? tsLiteral(priority) : undefined],
                 ['reference', optStr('reference')],
                 ['deferDate', optStr('deferDate')],
                 ['dueDate', optStr('dueDate')],
@@ -741,7 +731,7 @@ function emitStepSpec(node, imp, inputNames, o, graph) {
                 const raw = typeof x === 'string' ? x : String(x?.expression ?? x ?? '');
                 return raw.startsWith('=js:') ? emitBareExpr(raw.slice(4), imp, inputNames)
                     : raw.startsWith('$vars.') ? emitBareExpr(raw, imp, inputNames)
-                        : str(raw);
+                        : tsLiteral(raw);
             };
             const num = (x) => {
                 if (x === undefined || x === null)
@@ -813,16 +803,16 @@ function emitStepSpec(node, imp, inputNames, o, graph) {
                 const model = (i.model ?? {});
                 const nested = (k) => typeof model[k] === 'string' && model[k] !== '' ? model[k] : undefined;
                 return `${imp.use('ixpExtract')}(${opts([
-                    ['project', str(node.type)],
+                    ['project', tsLiteral(node.type)],
                     // `modelName`/`projectName` are one value in two fields; either recovers it.
-                    ['modelName', str(plain('modelName') ?? plain('projectName') ?? nested('modelName') ?? '')],
-                    ['name', str(nested('modelDisplayName') ?? plain('modelName') ?? '')],
-                    ['folderName', str(plain('folderName') ?? nested('folderName') ?? '')],
-                    ['fileRef', fr.startsWith('=js:') ? emitBareExpr(fr.slice(4), imp, inputNames) : str(fr)],
-                    ['pageRange', plain('pageRange') !== undefined ? str(plain('pageRange')) : undefined],
-                    ['versionTag', plain('versionTag') !== undefined ? str(plain('versionTag')) : undefined],
+                    ['modelName', tsLiteral(plain('modelName') ?? plain('projectName') ?? nested('modelName') ?? '')],
+                    ['name', tsLiteral(nested('modelDisplayName') ?? plain('modelName') ?? '')],
+                    ['folderName', tsLiteral(plain('folderName') ?? nested('folderName') ?? '')],
+                    ['fileRef', fr.startsWith('=js:') ? emitBareExpr(fr.slice(4), imp, inputNames) : tsLiteral(fr)],
+                    ['pageRange', plain('pageRange') !== undefined ? tsLiteral(plain('pageRange')) : undefined],
+                    ['versionTag', plain('versionTag') !== undefined ? tsLiteral(plain('versionTag')) : undefined],
                     ['description', plain('description') ?? nested('description') !== undefined
-                            ? str((plain('description') ?? nested('description'))) : undefined],
+                            ? tsLiteral((plain('description') ?? nested('description'))) : undefined],
                 ])})`;
             }
             // Every family this SDK AUTHORS is recovered above — a guard test asserts
@@ -866,23 +856,16 @@ function scriptReturnsOpt(node, code) {
         // A field map is the richer statement, so it wins when there is one.
         const entries = Object.entries(props)
             .filter(([, v]) => typeof v?.type === 'string')
-            .map(([k, v]) => [k, str(v.type)]);
+            .map(([k, v]) => [k, tsLiteral(v.type)]);
         if (entries.length > 0)
             return [['returns', opts(entries)]];
     }
-    return [['returns', str(declared)]];
+    return [['returns', tsLiteral(declared)]];
 }
 /** Key-sorted copy, so a property map compares by content and not by order. */
 function sortKeys(o) {
     return Object.fromEntries(Object.entries(o).sort(([a], [b]) => a.localeCompare(b)));
 }
-/** A validated numeric literal — never emit a raw JSON value that could carry code. */
-function numLit(v) {
-    const n = Number(v);
-    if (!Number.isFinite(n))
-        throw new Error(`decompile: expected a number, got ${JSON.stringify(v)}.`);
-    return String(n);
-}
 /**
  * Invert an HTTP node. The plain node (`core.action.http`) keeps its request at
  * the top level (`url` / `method` / `headers` / `queryParams` / `body` /
@@ -907,28 +890,28 @@ function emitHttp(node, managed, imp, inputNames) {
     const headersSrc = emitValMap(headers, imp, inputNames) || undefined;
     const querySrc = emitValMap(query, imp, inputNames) || undefined;
     const contentType = !managed && typeof inputs.contentType === 'string' && inputs.contentType !== 'application/json'
-        ? str(inputs.contentType) : undefined;
-    const timeout = typeof inputs.timeout === 'string' && inputs.timeout !== 'PT15M' ? str(inputs.timeout) : undefined;
-    const retry = inputs.retryCount !== undefined && Number(inputs.retryCount) !== 0 ? numLit(inputs.retryCount) : undefined;
+        ? tsLiteral(inputs.contentType) : undefined;
+    const timeout = typeof inputs.timeout === 'string' && inputs.timeout !== 'PT15M' ? tsLiteral(inputs.timeout) : undefined;
+    const retry = inputs.retryCount !== undefined && Number(inputs.retryCount) !== 0 ? tsNumber(inputs.retryCount) : undefined;
     const branchRows = Array.isArray(inputs.branches) ? inputs.branches : [];
     const branchesSrc = branchRows.length
         ? `[${branchRows.map((b) => {
             const cond = unwrapSource(b.conditionExpression) ?? '';
             const expr = emitBareExpr(cond.startsWith('=js:') ? cond.slice(4) : cond, imp, inputNames);
-            return `{ name: ${str(String(b.name ?? b.id ?? ''))}, condition: ${expr} }`;
+            return `{ name: ${tsText(b.name ?? b.id)}, condition: ${expr} }`;
         }).join(', ')}]`
         : undefined;
     const connectionValue = detail.connectionId ?? detail.connectionResourceId ?? req.connection;
     const connection = managed && typeof connectionValue === 'string' && connectionValue !== 'ImplicitConnection'
-        ? str(connectionValue) : undefined;
+        ? tsLiteral(connectionValue) : undefined;
     const folder = managed && typeof detail.connectionFolderKey === 'string' && detail.connectionFolderKey.length > 0
-        ? str(detail.connectionFolderKey) : undefined;
+        ? tsLiteral(detail.connectionFolderKey) : undefined;
     const targetConnector = managed && typeof req.targetConnector === 'string'
         && req.targetConnector !== 'uipath-uipath-http'
-        ? str(req.targetConnector) : undefined;
+        ? tsLiteral(req.targetConnector) : undefined;
     const spec = opts([
         ['url', emitVal(req.url ?? '', imp, inputNames)],
-        ['method', method !== 'GET' ? str(method) : undefined],
+        ['method', method !== 'GET' ? tsLiteral(method) : undefined],
         ['headers', headersSrc],
         ['query', querySrc],
         ['body', bodySrc],
@@ -964,43 +947,43 @@ function emitTransform(node, imp, inputNames) {
         const cfg = op?.config ?? {};
         if (op?.type === 'filter') {
             const filters = (cfg.filters ?? []).map((f) => objLit([
-                ['field', str(f.field)],
-                ['condition', str(f.condition)],
-                ...(f.value !== undefined ? [['value', literal(f.value)]] : []),
+                ['field', tsLiteral(f.field)],
+                ['condition', tsLiteral(f.condition)],
+                ...(f.value !== undefined ? [['value', tsLiteral(f.value)]] : []),
             ]));
             return objLit([
-                ['type', str('filter')],
-                ...(cfg.operation !== undefined ? [['operation', str(cfg.operation)]] : []),
+                ['type', tsLiteral('filter')],
+                ...(cfg.operation !== undefined ? [['operation', tsLiteral(cfg.operation)]] : []),
                 ['filters', `[${filters.join(', ')}]`],
             ]);
         }
         if (op?.type === 'map') {
             const mappings = (cfg.mappings ?? []).map((m) => objLit([
-                ['field', str(m.field)],
-                ...(m.transformation && m.transformation !== 'copy' ? [['transformation', str(m.transformation)]] : []),
-                ...(m.renameTo ? [['renameTo', str(m.renameTo)]] : []),
+                ['field', tsLiteral(m.field)],
+                ...(m.transformation && m.transformation !== 'copy' ? [['transformation', tsLiteral(m.transformation)]] : []),
+                ...(m.renameTo ? [['renameTo', tsLiteral(m.renameTo)]] : []),
             ]));
             return objLit([
-                ['type', str('map')],
+                ['type', tsLiteral('map')],
                 ...(cfg.keepOriginalFields ? [['keepOriginalFields', boolLit(cfg.keepOriginalFields)]] : []),
                 ['mappings', `[${mappings.join(', ')}]`],
             ]);
         }
         // groupBy
         const aggs = (cfg.aggregations ?? []).map((a) => objLit([
-            ['operation', str(a.operation)],
-            ['alias', str(a.alias)],
-            ...(a.field ? [['field', str(a.field)]] : []),
+            ['operation', tsLiteral(a.operation)],
+            ['alias', tsLiteral(a.alias)],
+            ...(a.field ? [['field', tsLiteral(a.field)]] : []),
         ]));
         return objLit([
-            ['type', str('groupBy')],
-            ['groupByField', str(cfg.groupByField)],
+            ['type', tsLiteral('groupBy')],
+            ['groupByField', tsLiteral(cfg.groupByField)],
             ['aggregations', `[${aggs.join(', ')}]`],
         ]);
     });
     const spec = opts([
         ['collection', collection],
-        ['variant', variant ? str(variant) : undefined],
+        ['variant', variant ? tsLiteral(variant) : undefined],
         ['operations', `[${opSrcs.join(', ')}]`],
     ]);
     return `${imp.use('transform')}(${spec})`;
@@ -1180,7 +1163,7 @@ function emitAgentCluster(node, imp, inputNames, graph) {
     };
     const promptSrc = (v) => {
         const raw = plain(v);
-        return raw === undefined ? undefined : str(unrender(raw));
+        return raw === undefined ? undefined : tsLiteral(unrender(raw));
     };
     const inputRows = refs
         // Emit in the file's own order, not the length-sorted one.
@@ -1192,7 +1175,7 @@ function emitAgentCluster(node, imp, inputNames, graph) {
     });
     const outVars = (Array.isArray(i.agentOutputVariables) ? i.agentOutputVariables : []);
     const returns = outVars.length
-        ? objLit(outVars.map((v) => [String(v.id ?? ''), str(String(v.type ?? 'string'))]))
+        ? objLit(outVars.map((v) => [String(v.id ?? ''), tsLiteral(String(v.type ?? 'string'))]))
         : undefined;
     // The resources, from the agent's own artifact edges.
     const resource = (port) => (graph?.outEdges(node.id) ?? [])
@@ -1212,12 +1195,12 @@ function emitAgentCluster(node, imp, inputNames, graph) {
                 const props = v?.properties;
                 if (!props || Object.keys(props).length === 0)
                     return undefined;
-                return objLit(Object.entries(props).map(([k, x]) => [k, str(String(x?.type ?? 'string'))]));
+                return objLit(Object.entries(props).map(([k, x]) => [k, tsLiteral(String(x?.type ?? 'string'))]));
             };
             return opts([
-                ['kind', str('clientside')],
-                ['name', str(rPlain(t, 'name') ?? '')],
-                ['description', rPlain(t, 'description') !== undefined ? str(rPlain(t, 'description')) : undefined],
+                ['kind', tsLiteral('clientside')],
+                ['name', tsLiteral(rPlain(t, 'name') ?? '')],
+                ['description', rPlain(t, 'description') !== undefined ? tsLiteral(rPlain(t, 'description')) : undefined],
                 ['inputs', schemaTypes(ti.inputSchema)],
                 ['returns', schemaTypes(ti.outputSchema)],
             ]);
@@ -1229,10 +1212,10 @@ function emitAgentCluster(node, imp, inputNames, graph) {
                 if (!row || row.mode !== 'text-builder')
                     return undefined;
                 const v = row.textValue;
-                return typeof v === 'number' ? String(v) : typeof v === 'string' ? str(v) : JSON.stringify(v);
+                return typeof v === 'number' ? String(v) : typeof v === 'string' ? tsLiteral(v) : JSON.stringify(v);
             };
             return opts([
-                ['kind', str('httpRequest')],
+                ['kind', tsLiteral('httpRequest')],
                 ['url', fixed('url')], ['method', fixed('method')],
                 ['headers', fixed('headers')], ['params', fixed('params')],
                 ['body', fixed('body')], ['timeout', fixed('timeout')],
@@ -1240,37 +1223,37 @@ function emitAgentCluster(node, imp, inputNames, graph) {
         }
         if (type.startsWith('uipath.agent.resource.tool.mcp.')) {
             return opts([
-                ['kind', str('mcp')],
-                ['name', str(rPlain(t, 'name') ?? '')],
-                ['key', str(rPlain(t, 'referenceKey') ?? '')],
+                ['kind', tsLiteral('mcp')],
+                ['name', tsLiteral(rPlain(t, 'name') ?? '')],
+                ['key', tsLiteral(rPlain(t, 'referenceKey') ?? '')],
                 // The mapper's field name for the canonical server slug.
-                ['slug', rPlain(t, 'serverUrl') !== undefined ? str(rPlain(t, 'serverUrl')) : undefined],
-                ['folderPath', rPlain(t, 'folderPath') !== undefined ? str(rPlain(t, 'folderPath')) : undefined],
-                ['mcpType', rPlain(t, 'mcpType') !== undefined ? str(rPlain(t, 'mcpType')) : undefined],
+                ['slug', rPlain(t, 'serverUrl') !== undefined ? tsLiteral(rPlain(t, 'serverUrl')) : undefined],
+                ['folderPath', rPlain(t, 'folderPath') !== undefined ? tsLiteral(rPlain(t, 'folderPath')) : undefined],
+                ['mcpType', rPlain(t, 'mcpType') !== undefined ? tsLiteral(rPlain(t, 'mcpType')) : undefined],
             ]);
         }
         if (type.startsWith('uipath.agent.resource.tool.a2a.')) {
             return opts([
-                ['kind', str('a2a')],
-                ['name', str(rPlain(t, 'name') ?? '')],
-                ['key', str(rPlain(t, 'referenceKey') ?? '')],
-                ['slug', str(rPlain(t, 'slug') ?? '')],
-                ['folderPath', rPlain(t, 'folderPath') !== undefined ? str(rPlain(t, 'folderPath')) : undefined],
+                ['kind', tsLiteral('a2a')],
+                ['name', tsLiteral(rPlain(t, 'name') ?? '')],
+                ['key', tsLiteral(rPlain(t, 'referenceKey') ?? '')],
+                ['slug', tsLiteral(rPlain(t, 'slug') ?? '')],
+                ['folderPath', rPlain(t, 'folderPath') !== undefined ? tsLiteral(rPlain(t, 'folderPath')) : undefined],
             ]);
         }
         if (type.startsWith('uipath.agent.resource.tool.builtin.')) {
             return opts([
-                ['kind', str('builtin')],
-                ['tool', str(type.slice('uipath.agent.resource.tool.builtin.'.length))],
-                ['description', rPlain(t, 'description') !== undefined ? str(rPlain(t, 'description')) : undefined],
+                ['kind', tsLiteral('builtin')],
+                ['tool', tsLiteral(type.slice('uipath.agent.resource.tool.builtin.'.length))],
+                ['description', rPlain(t, 'description') !== undefined ? tsLiteral(rPlain(t, 'description')) : undefined],
             ]);
         }
         if (type.startsWith('uipath.agent.resource.tool.ixp.')) {
             const tail = type.slice('uipath.agent.resource.tool.ixp.'.length);
             return opts([
-                ['kind', str('ixp')],
-                ['projectId', str(tail.slice(tail.indexOf('.') + 1))],
-                ['name', str(rPlain(t, 'name') ?? '')],
+                ['kind', tsLiteral('ixp')],
+                ['projectId', tsLiteral(tail.slice(tail.indexOf('.') + 1))],
+                ['name', tsLiteral(rPlain(t, 'name') ?? '')],
             ]);
         }
         // The per-instance resource kinds (process / api / flow / maestro / agent /
@@ -1292,13 +1275,13 @@ function emitAgentCluster(node, imp, inputNames, graph) {
                 return typeof row?.default === 'string' ? row.default : undefined;
             };
             return opts([
-                ['kind', str(ns[1])],
-                ['key', str(type.slice(ns[0].length))],
-                ['name', str(bound('name') ?? rPlain(t, 'name') ?? '')],
-                ['folderPath', str(bound('folderPath') ?? '')],
+                ['kind', tsLiteral(ns[1])],
+                ['key', tsLiteral(type.slice(ns[0].length))],
+                ['name', tsLiteral(bound('name') ?? rPlain(t, 'name') ?? '')],
+                ['folderPath', tsLiteral(bound('folderPath') ?? '')],
             ]);
         }
-        return opts([['kind', str('builtin')], ['tool', str('summarize')]]); // unreachable in practice
+        return opts([['kind', tsLiteral('builtin')], ['tool', tsLiteral('summarize')]]); // unreachable in practice
     });
     const contextSrc = resource('context').map((c) => {
         // `query` is a MODE TRIPLE, not a string: the author's value lands in
@@ -1310,17 +1293,17 @@ function emitAgentCluster(node, imp, inputNames, graph) {
                 : typeof q === 'string' && q !== '' ? q
                     : undefined;
         return opts([
-            ['name', str(rPlain(c, 'indexName') ?? String(c.display?.label ?? ''))],
-            ['id', str(rPlain(c, 'indexId') ?? '')],
-            ['folderPath', rPlain(c, 'folderPath') !== undefined ? str(rPlain(c, 'folderPath')) : undefined],
-            ['folderKey', rPlain(c, 'folderKey') !== undefined ? str(rPlain(c, 'folderKey')) : undefined],
-            ['query', queryText !== undefined ? str(queryText) : undefined],
+            ['name', tsLiteral(rPlain(c, 'indexName') ?? String(c.display?.label ?? ''))],
+            ['id', tsLiteral(rPlain(c, 'indexId') ?? '')],
+            ['folderPath', rPlain(c, 'folderPath') !== undefined ? tsLiteral(rPlain(c, 'folderPath')) : undefined],
+            ['folderKey', rPlain(c, 'folderKey') !== undefined ? tsLiteral(rPlain(c, 'folderKey')) : undefined],
+            ['query', queryText !== undefined ? tsLiteral(queryText) : undefined],
         ]);
     });
     const escalationSrc = resource('escalation').map((e) => {
         const ei = rInputs(e);
         const recipients = Array.isArray(ei.recipients)
-            ? ei.recipients.map((r) => str(String(r.value ?? '')))
+            ? ei.recipients.map((r) => tsText(r.value))
             : [];
         const outcomeNames = Object.keys((ei.outcomeMapping ?? {}));
         const isQuickForm = e.type === 'uipath.agent.resource.escalation.quick-form';
@@ -1330,24 +1313,24 @@ function emitAgentCluster(node, imp, inputNames, graph) {
         const app = ei.app;
         const extra = (ei._additionalProps ?? {});
         return opts([
-            ['variant', isQuickForm ? str('quick-form') : undefined],
-            ['name', str(rPlain(e, 'name') ?? '')],
-            ['description', rPlain(e, 'description') !== undefined ? str(rPlain(e, 'description')) : undefined],
+            ['variant', isQuickForm ? tsLiteral('quick-form') : undefined],
+            ['name', tsLiteral(rPlain(e, 'name') ?? '')],
+            ['description', rPlain(e, 'description') !== undefined ? tsLiteral(rPlain(e, 'description')) : undefined],
             ['fields', rows.length ? `[${rows.map((f) => opts([
-                    ['id', str(String(f.id ?? ''))],
-                    ['type', str(String(f.type ?? 'text'))],
-                    ['direction', str(String(f.direction ?? 'output'))],
+                    ['id', tsText(f.id)],
+                    ['type', tsLiteral(String(f.type ?? 'text'))],
+                    ['direction', tsLiteral(String(f.direction ?? 'output'))],
                 ])).join(', ')}]` : undefined],
             ['app', app === undefined ? undefined : opts([
-                    ['key', str(String(app.key ?? ''))],
-                    ['name', str(String(app.name ?? ''))],
-                    ['folderPath', typeof app.folderPath === 'string' && app.folderPath !== '' ? str(app.folderPath) : undefined],
+                    ['key', tsText(app.key)],
+                    ['name', tsText(app.name)],
+                    ['folderPath', typeof app.folderPath === 'string' && app.folderPath !== '' ? tsLiteral(app.folderPath) : undefined],
                 ])],
             ['recipients', recipients.length ? `[${recipients.join(', ')}]` : undefined],
-            ['outcomes', outcomeNames.length ? `[${outcomeNames.map((o) => str(o)).join(', ')}]` : undefined],
-            ['taskTitle', typeof extra.taskTitle === 'string' && extra.taskTitle !== '' ? str(extra.taskTitle) : undefined],
+            ['outcomes', outcomeNames.length ? `[${outcomeNames.map((o) => tsLiteral(o)).join(', ')}]` : undefined],
+            ['taskTitle', typeof extra.taskTitle === 'string' && extra.taskTitle !== '' ? tsLiteral(extra.taskTitle) : undefined],
             // 'medium' is the platform default.
-            ['priority', typeof extra.priority === 'string' && extra.priority !== 'medium' ? str(extra.priority) : undefined],
+            ['priority', typeof extra.priority === 'string' && extra.priority !== 'medium' ? tsLiteral(extra.priority) : undefined],
         ]);
     });
     const mem = resource('memory')[0];
@@ -1357,15 +1340,15 @@ function emitAgentCluster(node, imp, inputNames, graph) {
         const id = tail.slice(tail.indexOf('.') + 1);
         const mi = rInputs(mem);
         return opts([
-            ['name', str(rPlain(mem, 'name') ?? '')],
-            ['id', str(id)],
-            ['description', rPlain(mem, 'description') !== undefined ? str(rPlain(mem, 'description')) : undefined],
+            ['name', tsLiteral(rPlain(mem, 'name') ?? '')],
+            ['id', tsLiteral(id)],
+            ['description', rPlain(mem, 'description') !== undefined ? tsLiteral(rPlain(mem, 'description')) : undefined],
             // The platform defaults: few-shot on, similarity 0, k 3, hybrid search.
             ['dynamicFewShotLearning', unwrapPlain(mi.dynamicFewShotLearning) === false ? 'false' : undefined],
             ['semanticSimilarity', num(mi.semanticSimilarity) !== undefined && num(mi.semanticSimilarity) !== '0' ? num(mi.semanticSimilarity) : undefined],
             ['kValue', num(mi.kValue) !== undefined && num(mi.kValue) !== '3' ? num(mi.kValue) : undefined],
             ['searchMode', rPlain(mem, 'searchMode') !== undefined && rPlain(mem, 'searchMode') !== 'hybrid'
-                    ? str(rPlain(mem, 'searchMode')) : undefined],
+                    ? tsLiteral(rPlain(mem, 'searchMode')) : undefined],
         ]);
     })();
     const guardrails = Array.isArray(i.guardrails) && i.guardrails.length > 0
@@ -1375,22 +1358,22 @@ function emitAgentCluster(node, imp, inputNames, graph) {
     if (node.type === T.voiceAgent) {
         const v = (i.voice ?? {});
         const voiceSrc = Object.keys(v).length === 0 ? undefined : opts([
-            ['model', typeof v.model === 'string' ? str(v.model) : undefined],
-            ['persona', typeof v.persona === 'string' ? str(v.persona) : undefined],
+            ['model', typeof v.model === 'string' ? tsLiteral(v.model) : undefined],
+            ['persona', typeof v.persona === 'string' ? tsLiteral(v.persona) : undefined],
             ['temperature', num(v.temperature)],
             ['maxTokens', num(v.maxTokens)],
         ]);
         return `${imp.use('voiceAgent')}(${opts([
-            ['systemPrompt', promptSrc(i.systemPrompt) ?? str('')],
+            ['systemPrompt', promptSrc(i.systemPrompt) ?? tsLiteral('')],
             ['inputs', inputRows.length ? objLit(inputRows) : undefined],
             ['callContext', (() => {
                     const raw = plain(i.callContext) ?? '';
                     const js = raw.startsWith('=js:') ? raw.slice(4) : raw;
-                    return js.startsWith('$vars.') ? emitBareExpr(js, imp, inputNames) : str(js);
+                    return js.startsWith('$vars.') ? emitBareExpr(js, imp, inputNames) : tsLiteral(js);
                 })()],
             ['voice', voiceSrc],
             ['maxIterations', num(i.maxIterations)],
-            ['source', str(plain(i.source) ?? '')],
+            ['source', tsLiteral(plain(i.source) ?? '')],
         ])})`;
     }
     if (node.type === T.conversationalAgent) {
@@ -1407,7 +1390,7 @@ function emitAgentCluster(node, imp, inputNames, graph) {
             // `out(...)` and anything composite to a `js` template. Any other string
             // is literal text, as the product reads it (flow-schema
             // `coerceToExpressionValue`), even when it looks like `$vars.…`.
-            return raw.startsWith('=js:') ? emitRef(raw.slice(4), imp, inputNames) : str(raw);
+            return raw.startsWith('=js:') ? emitRef(raw.slice(4), imp, inputNames) : tsLiteral(raw);
         };
         // `'simple'` mode DERIVES the four runtime fields from `context`, so only
         // the context binding is the author's; recovering the derived ones would
@@ -1415,7 +1398,7 @@ function emitAgentCluster(node, imp, inputNames, graph) {
         const mode = typeof st.mode === 'string' ? st.mode : 'simple';
         const settingsSrc = mode === 'custom'
             ? opts([
-                ['mode', str('custom')],
+                ['mode', tsLiteral('custom')],
                 ['conversationId', settingExpr('conversationId')],
                 ['exchangeId', settingExpr('exchangeId')],
                 ['messages', settingExpr('messages')],
@@ -1423,8 +1406,8 @@ function emitAgentCluster(node, imp, inputNames, graph) {
             ])
             : opts([['context', settingExpr('context')]]);
         return `${imp.use('conversationalAgent')}(${opts([
-            ['model', str(plain(i.model) ?? '')],
-            ['systemPrompt', promptSrc(i.systemPrompt) ?? str('')],
+            ['model', tsLiteral(plain(i.model) ?? '')],
+            ['systemPrompt', promptSrc(i.systemPrompt) ?? tsLiteral('')],
             // `settings` is required on ConversationalAgentInputs, so an empty one
             // stays as `{}`, which check then reports as CONV_AGENT_NO_TURN.
             ['settings', settingsSrc || '{}'],
@@ -1432,19 +1415,19 @@ function emitAgentCluster(node, imp, inputNames, graph) {
             ['maxTokenPerResponse', num(i.maxTokenPerResponse)],
             ['maxIterations', num(i.maxIterations)],
             ['guardrails', guardrails],
-            ['source', str(plain(i.source) ?? '')],
+            ['source', tsLiteral(plain(i.source) ?? '')],
         ])})`;
     }
     return `${imp.use('inlineAgent')}(${opts([
-        ['model', str(plain(i.model) ?? '')],
-        ['systemPrompt', promptSrc(i.systemPrompt) ?? str('')],
-        ['userPrompt', promptSrc(i.userPrompt) ?? str('')],
+        ['model', tsLiteral(plain(i.model) ?? '')],
+        ['systemPrompt', promptSrc(i.systemPrompt) ?? tsLiteral('')],
+        ['userPrompt', promptSrc(i.userPrompt) ?? tsLiteral('')],
         ['inputs', inputRows.length ? objLit(inputRows) : undefined],
         ['returns', returns],
         ['temperature', num(i.temperature)],
         ['maxTokenPerResponse', num(i.maxTokenPerResponse)],
         ['maxIterations', num(i.maxIterations)],
-        ['mode', plain(i.mode) !== undefined ? str(plain(i.mode)) : undefined],
+        ['mode', plain(i.mode) !== undefined ? tsLiteral(plain(i.mode)) : undefined],
         ['guardrails', guardrails],
         ['context', list(contextSrc)],
         ['tools', list(toolSrc)],
@@ -1453,7 +1436,7 @@ function emitAgentCluster(node, imp, inputNames, graph) {
         // The agent's directory uuid is derived from the flow and step ids, but a
         // decompiled flow must keep the ORIGINAL — the sidecar lives at
         // `<source>/agent.json`, so a re-derived one would point at nothing.
-        ['source', str(plain(i.source) ?? '')],
+        ['source', tsLiteral(plain(i.source) ?? '')],
     ])})`;
 }
 /**
@@ -1496,11 +1479,11 @@ function emitHitl(node, imp, inputNames, graph) {
         const id = String(f.id ?? '');
         const direction = String(f.direction ?? 'output');
         return opts([
-            ['id', str(id)],
+            ['id', tsLiteral(id)],
             // serialize defaults a row's label to its id.
-            ['label', typeof f.label === 'string' && f.label !== id ? str(f.label) : undefined],
-            ['type', str(String(f.type ?? 'text'))],
-            ['direction', str(direction)],
+            ['label', typeof f.label === 'string' && f.label !== id ? tsLiteral(f.label) : undefined],
+            ['type', tsLiteral(String(f.type ?? 'text'))],
+            ['direction', tsLiteral(direction)],
             ['value', direction === 'input' || direction === 'inOut' ? bindingExpr(f.binding) : undefined],
             ['required', f.required === true ? 'true' : undefined],
         ]);
@@ -1509,7 +1492,7 @@ function emitHitl(node, imp, inputNames, graph) {
     const outcomes = outcomeRows.map((o) => {
         const name = String(o.name ?? '');
         // A bare string is the shorthand; only `action: 'End'` needs the object.
-        return o.action === 'End' ? opts([['name', str(name)], ['action', str('End')]]) : str(name);
+        return o.action === 'End' ? opts([['name', tsLiteral(name)], ['action', tsLiteral('End')]]) : tsLiteral(name);
     });
     // Delivery: only an override comes back. The definition's own default is what
     // serialize emits when the author wrote nothing.
@@ -1521,11 +1504,11 @@ function emitHitl(node, imp, inputNames, graph) {
         const assignee = (rec.assignee ?? {});
         const channels = Array.isArray(rec.channels) ? rec.channels : undefined;
         recipientSrc = opts([
-            ['channels', channels ? `[${channels.map((c) => str(c)).join(', ')}]` : undefined],
+            ['channels', channels ? `[${channels.map((c) => tsLiteral(c)).join(', ')}]` : undefined],
             ['assignee', opts([
-                    ['type', str(String(assignee.type ?? 'user'))],
-                    ['value', typeof assignee.value === 'string' ? str(assignee.value) : undefined],
-                    ['displayName', typeof assignee.displayName === 'string' ? str(assignee.displayName) : undefined],
+                    ['type', tsLiteral(String(assignee.type ?? 'user'))],
+                    ['value', typeof assignee.value === 'string' ? tsLiteral(assignee.value) : undefined],
+                    ['displayName', typeof assignee.displayName === 'string' ? tsLiteral(assignee.displayName) : undefined],
                 ])],
         ]);
     }
@@ -1540,15 +1523,15 @@ function emitHitl(node, imp, inputNames, graph) {
     const bindings = (i.appInputBindings ?? {});
     const appInputs = Object.keys(bindings).length === 0 ? undefined : objLit(Object.entries(bindings).map(([k, v]) => {
         const raw = String(v ?? '');
-        return [k, raw.startsWith('=') ? emitBareExpr(`$${raw.slice(1)}`, imp, inputNames) : str(raw)];
+        return [k, raw.startsWith('=') ? emitBareExpr(`$${raw.slice(1)}`, imp, inputNames) : tsLiteral(raw)];
     }));
     const appSrc = app === undefined ? undefined : opts([
         // `displayName` is serialize's echo of `name`; only `name` is authored.
-        ['name', str(String(app.name ?? ''))],
-        ['key', str(String(app.key ?? ''))],
-        ['folderPath', typeof app.folderPath === 'string' && app.folderPath !== '' ? str(app.folderPath) : undefined],
+        ['name', tsText(app.name)],
+        ['key', tsText(app.key)],
+        ['folderPath', typeof app.folderPath === 'string' && app.folderPath !== '' ? tsLiteral(app.folderPath) : undefined],
         ['appSystemName', app.appSystemName === null ? 'null'
-                : typeof app.appSystemName === 'string' ? str(app.appSystemName) : undefined],
+                : typeof app.appSystemName === 'string' ? tsLiteral(app.appSystemName) : undefined],
         ['inputs', appInputs],
     ]);
     // The validation station's own inputs ride as PLAIN `$vars.…` paths.
@@ -1557,15 +1540,15 @@ function emitHitl(node, imp, inputNames, graph) {
         if (raw === undefined)
             return undefined;
         const js = raw.startsWith('=js:') ? raw.slice(4) : raw;
-        return js.startsWith('$vars.') ? emitBareExpr(js, imp, inputNames) : str(js);
+        return js.startsWith('$vars.') ? emitBareExpr(js, imp, inputNames) : tsLiteral(js);
     };
     const render = plain(i.validationRenderType);
     const documentSrc = node.type !== T.hitlDocValidation ? undefined : opts([
-        ['extractionResult', stationExpr(i.extractionResult) ?? str('')],
-        ['storageBucket', plain(i.storageBucket) !== undefined ? str(plain(i.storageBucket)) : undefined],
-        ['documentId', plain(i.documentId) !== undefined ? str(plain(i.documentId)) : undefined],
+        ['extractionResult', stationExpr(i.extractionResult) ?? tsLiteral('')],
+        ['storageBucket', plain(i.storageBucket) !== undefined ? tsLiteral(plain(i.storageBucket)) : undefined],
+        ['documentId', plain(i.documentId) !== undefined ? tsLiteral(plain(i.documentId)) : undefined],
         // 'standard' is the definition's default.
-        ['render', render !== undefined && render !== 'standard' ? str(render) : undefined],
+        ['render', render !== undefined && render !== 'standard' ? tsLiteral(render) : undefined],
         ['taxonomy', stationExpr(i.taxonomy)],
     ]);
     // On the base node the VERSION says it: 1.1 routes per outcome, 1.2 adds the
@@ -1596,7 +1579,7 @@ function emitHitl(node, imp, inputNames, graph) {
     const fanOut = !outcomePorts && derivesHandles && !versionRoutesHitl(node) && outcomeIdsOfNode(node).length > 1
         && (legacyCompleted || graph?.convergedFanOut(node.id) === true);
     if (legacyCompleted) {
-        warnOnce(`human task ${str(node.id)} leaves on the legacy 'completed' handle, which Studio Web no longer draws `
+        warnOnce(`human task ${tsLiteral(node.id)} leaves on the legacy 'completed' handle, which Studio Web no longer draws `
             + `once a task has outcomes (it reads the edge as the primary outcome only). Recompiling emits one `
             + `outcome-<id> edge per outcome to the same step, so every outcome continues — what the edge meant `
             + `before flow-workbench #3512.`);
@@ -1604,11 +1587,11 @@ function emitHitl(node, imp, inputNames, graph) {
     const title = plain(i.title);
     const priority = plain(i.priority);
     return `${imp.use('hitl')}(${opts([
-        ['variant', variant !== undefined ? str(variant) : undefined],
+        ['variant', variant !== undefined ? tsLiteral(variant) : undefined],
         // serialize defaults the title to the step's own name.
-        ['title', title !== undefined && title !== node.id ? str(title) : undefined],
-        ['priority', priority !== undefined && priority !== 'Low' ? str(priority) : undefined],
-        ['labels', plain(i.labels) !== undefined ? str(plain(i.labels)) : undefined],
+        ['title', title !== undefined && title !== node.id ? tsLiteral(title) : undefined],
+        ['priority', priority !== undefined && priority !== 'Low' ? tsLiteral(priority) : undefined],
+        ['labels', plain(i.labels) !== undefined ? tsLiteral(plain(i.labels)) : undefined],
         ['recipient', recipientSrc],
         ['app', appSrc],
         ['document', documentSrc],
@@ -1645,7 +1628,7 @@ function unboundMarker(node, labels, key, action) {
     if (missing.length === 0)
         return '';
     const names = missing.join(' and ');
-    warnOnce(`node ${str(node.id)} (${node.type}) has no ${missing.join(' or ')} in the .flow (an unbound draft). `
+    warnOnce(`node ${tsLiteral(node.id)} (${node.type}) has no ${missing.join(' or ')} in the .flow (an unbound draft). `
         + `The source leaves ${missing.length > 1 ? 'them' : 'it'} out, and compile refuses the node (BINDING_MISSING) `
         + `until it names both labels: run \`${prepareCommand(key, action ?? '<action>')}\`, then pass `
         + `\`connection\` and \`folder\`.`);
@@ -1685,8 +1668,8 @@ function emitEventSubscription(node, imp, inputNames) {
                 .map((f) => eventFilterFromTreeLeaf(f))
                 .filter((f) => f !== undefined)
                 .map((f) => opts([
-                ['field', str(f.field)],
-                [f.operator, typeof f.value === 'string' ? str(f.value) : JSON.stringify(f.value)],
+                ['field', tsLiteral(f.field)],
+                [f.operator, typeof f.value === 'string' ? tsLiteral(f.value) : JSON.stringify(f.value)],
             ]));
         }
         catch {
@@ -1701,13 +1684,13 @@ function emitEventSubscription(node, imp, inputNames) {
     const conn = typeof detail?.connectionId === 'string' ? detail.connectionId : undefined;
     const folder = typeof detail?.connectionFolderKey === 'string' ? detail.connectionFolderKey : undefined;
     return opts([
-        ['connector', str(connector)],
-        ['event', str(event)],
+        ['connector', tsLiteral(connector)],
+        ['event', tsLiteral(event)],
         ['where', whereRows.length ? objLit(whereRows) : undefined],
-        ['object', object !== undefined ? str(object) : undefined],
+        ['object', object !== undefined ? tsLiteral(object) : undefined],
         ['filters', filterRows.length ? `[${filterRows.join(', ')}]` : undefined],
-        ['connection', conn !== undefined ? str(conn) : undefined],
-        ['folder', folder !== undefined ? str(folder) : undefined],
+        ['connection', conn !== undefined ? tsLiteral(conn) : undefined],
+        ['folder', folder !== undefined ? tsLiteral(folder) : undefined],
     ]) + unboundMarker(node, { connection: conn, folder }, connector, event);
 }
 /**
@@ -1780,18 +1763,18 @@ function emitPublishedResource(node, imp, inputNames) {
         .map(([k, v]) => [k, emitVal(v, imp, inputNames)]);
     const schema = def?.outputDefinition?.output?.schema?.properties;
     const returns = schema && Object.keys(schema).length > 0
-        ? objLit(Object.entries(schema).map(([k, v]) => [k, str(String(v?.type ?? 'string'))]))
+        ? objLit(Object.entries(schema).map(([k, v]) => [k, tsLiteral(String(v?.type ?? 'string'))]))
         : undefined;
     return `${imp.use(family.factory)}(${opts([
-        ['key', str(key)],
-        ['name', name !== undefined ? str(name) : undefined],
-        ['location', inSolution ? str('in-solution') : undefined],
-        ['folderPath', !inSolution && folderPath !== undefined ? str(folderPath) : undefined],
-        ['projectId', inSolution && projectId !== undefined ? str(projectId) : undefined],
+        ['key', tsLiteral(key)],
+        ['name', name !== undefined ? tsLiteral(name) : undefined],
+        ['location', inSolution ? tsLiteral('in-solution') : undefined],
+        ['folderPath', !inSolution && folderPath !== undefined ? tsLiteral(folderPath) : undefined],
+        ['projectId', inSolution && projectId !== undefined ? tsLiteral(projectId) : undefined],
         ['inputs', inputRows.length ? objLit(inputRows) : undefined],
         ['returns', returns],
-        ['form', family.form !== undefined ? str(family.form) : undefined],
-        ['completion', fireAndForget ? str('fire-and-forget') : undefined],
+        ['form', family.form !== undefined ? tsLiteral(family.form) : undefined],
+        ['completion', fireAndForget ? tsLiteral('fire-and-forget') : undefined],
     ])})`;
 }
 function emitConnector(node, imp, inputNames, o) {
@@ -1820,12 +1803,12 @@ function emitConnector(node, imp, inputNames, o) {
     const folder = typeof detail.connectionFolderKey === 'string' ? detail.connectionFolderKey : undefined;
     const object = connectorObjectName(detail.configuration);
     const optsSrc = opts([
-        ['connection', connection !== undefined ? str(connection) : undefined],
-        ['folder', folder !== undefined ? str(folder) : undefined],
-        ['object', object !== undefined ? str(object) : undefined],
+        ['connection', connection !== undefined ? tsLiteral(connection) : undefined],
+        ['folder', folder !== undefined ? tsLiteral(folder) : undefined],
+        ['object', object !== undefined ? tsLiteral(object) : undefined],
     ]);
     const inputsSrc = objLit(flat) || '{}';
-    const args = [str(split.key), str(split.action), inputsSrc, ...(optsSrc ? [optsSrc] : [])];
+    const args = [tsLiteral(split.key), tsLiteral(split.action), inputsSrc, ...(optsSrc ? [optsSrc] : [])];
     return `${imp.use('connector')}(${args.join(', ')})`
         + unboundMarker(node, { connection, folder }, split.key, split.action);
 }
@@ -1847,8 +1830,8 @@ function unsupportedSpec(node, imp, o) {
         const inputs = node.inputs ?? {};
         const inputsSrc = Object.keys(inputs).length > 0 ? JSON.stringify(inputs, null, 2) : undefined;
         return `${imp.use('rawNode')}(${opts([
-            ['nodeType', str(node.type)],
-            ['version', str(String(node.typeVersion ?? ''))],
+            ['nodeType', tsLiteral(node.type)],
+            ['version', tsText(node.typeVersion)],
             ['manifest', constName],
             ['inputs', inputsSrc],
         ])})`;
@@ -1879,7 +1862,7 @@ const TYPE_NAMES = new Set([
 function typeExpr(type, imp) {
     if (TYPE_NAMES.has(type))
         return `${imp.use('types')}.${type}`;
-    return str(type);
+    return tsLiteral(type);
 }
 /**
  * A global carrying metadata decompiles to the rich VarSpec spelling
@@ -1889,15 +1872,15 @@ function typeExpr(type, imp) {
 function declExpr(g, withDefault, imp, shared) {
     const meta = [];
     if (withDefault && g.defaultValue !== undefined)
-        meta.push(`default: ${literal(g.defaultValue)}`);
+        meta.push(`default: ${tsLiteral(g.defaultValue)}`);
     if (g.description !== undefined)
-        meta.push(`description: ${str(g.description)}`);
+        meta.push(`description: ${tsLiteral(g.description)}`);
     if (g.subType !== undefined)
-        meta.push(`subType: ${str(g.subType)}`);
+        meta.push(`subType: ${tsLiteral(g.subType)}`);
     if (g.schema !== undefined)
-        meta.push(`schema: ${literal(g.schema)}`);
+        meta.push(`schema: ${tsLiteral(g.schema)}`);
     if (shared !== undefined)
-        meta.push(`shared: ${str(shared)}`);
+        meta.push(`shared: ${tsLiteral(shared)}`);
     if (meta.length === 0)
         return typeExpr(g.type, imp);
     return `{ type: ${typeExpr(g.type, imp)}, ${meta.join(', ')} }`;
@@ -1954,50 +1937,49 @@ function emitVariables(e, depth, flow, imp, epTriggers = new Set(), shared) {
         e.line(depth, `.output(${shape(outputs, true)})`);
     for (const g of inouts) {
         const rich = declExpr(g, false, imp);
-        const def = g.defaultValue !== undefined ? `, ${literal(g.defaultValue)}` : '';
-        e.line(depth, `.var(${str(g.name ?? g.id)}, ${rich}${def})`);
+        const def = g.defaultValue !== undefined ? `, ${tsLiteral(g.defaultValue)}` : '';
+        e.line(depth, `.var(${tsLiteral(g.name ?? g.id)}, ${rich}${def})`);
     }
 }
 // ─── Trigger ──────────────────────────────────────────────────────────────────
+/**
+ * The trigger factory call for a root trigger node, or `undefined` for a type
+ * this file cannot read back. Both the default root (`.trigger(...)`) and every
+ * extra root (`.entryPoint(id, ...)`) read it.
+ */
+function triggerFactory(t, imp, inputNames) {
+    // Decompiled source spells the default `manual()` out on purpose: it is more
+    // explicit than hand-authored source so the node's exact definition version
+    // survives recompilation (design §5.3).
+    if (t.type === T.triggerManual)
+        return `${imp.use('manual')}()`;
+    if (t.type === T.triggerScheduled)
+        return `${imp.use('scheduled')}(${opts([['every', tsLiteral(scheduleEvery(t))]])})`;
+    // The form schema is DERIVED from the root's inputs at compile time, so
+    // nothing of it needs recovering — the factory takes no arguments.
+    if (t.type === T.triggerForm)
+        return `${imp.use('formTrigger')}()`;
+    if (t.type === T.triggerConversation)
+        return `${imp.use('conversationTrigger')}()`;
+    if (t.type === T.triggerVoice)
+        return `${imp.use('voiceTrigger')}()`;
+    // A connector EVENT trigger — the same subscription body as a mid-flow wait.
+    const sub = emitEventSubscription(t, imp, inputNames);
+    if (sub !== undefined)
+        return `${imp.use('onEvent')}(${sub})`;
+    return undefined;
+}
 function emitTrigger(e, depth, trigger, imp, o, inputNames = new Set()) {
     // The trigger's id is addressable — a flow's inputs are published as its
     // output — so a renamed one has to survive the round trip. `start` is the
     // default and stays implicit.
     if (trigger.id && trigger.id !== DEFAULT_TRIGGER_ID)
-        e.line(depth, `.triggerId(${str(trigger.id)})`);
-    if (trigger.type === T.triggerManual) {
-        // The default trigger, spelled out: decompiled source is deliberately more
-        // explicit than hand-authored source so the node's exact definition version
-        // survives recompilation (design §5.3).
-        e.line(depth, `.trigger(${imp.use('manual')}()${triggerOptsArg(trigger)})`);
-        return;
-    }
-    if (trigger.type === T.triggerScheduled) {
-        e.line(depth, `.trigger(${imp.use('scheduled')}(${opts([['every', str(scheduleEvery(trigger))]])})${triggerOptsArg(trigger)})`);
+        e.line(depth, `.triggerId(${tsLiteral(trigger.id)})`);
+    const factory = triggerFactory(trigger, imp, inputNames);
+    if (factory !== undefined) {
+        e.line(depth, `.trigger(${factory}${triggerOptsArg(trigger)})`);
         return;
     }
-    if (trigger.type === T.triggerForm) {
-        // The schema is DERIVED from the flow's inputs at compile time, so nothing
-        // of it needs recovering — the factory takes no arguments.
-        e.line(depth, `.trigger(${imp.use('formTrigger')}()${triggerOptsArg(trigger)})`);
-        return;
-    }
-    if (trigger.type === T.triggerConversation) {
-        e.line(depth, `.trigger(${imp.use('conversationTrigger')}()${triggerOptsArg(trigger)})`);
-        return;
-    }
-    if (trigger.type === T.triggerVoice) {
-        e.line(depth, `.trigger(${imp.use('voiceTrigger')}()${triggerOptsArg(trigger)})`);
-        return;
-    }
-    // A connector EVENT trigger — the same subscription body as a mid-flow wait.
-    {
-        const sub = emitEventSubscription(trigger, imp, inputNames);
-        if (sub !== undefined) {
-            e.line(depth, `.trigger(${imp.use('onEvent')}(${sub})${triggerOptsArg(trigger)})`);
-            return;
-        }
-    }
     if (o.bestEffort === false) {
         throw new Error(`decompile: unsupported trigger type "${trigger.type}".`);
     }
@@ -2183,14 +2165,14 @@ function isIdentityEndSource(raw, name) {
 function returnOptsArg(node) {
     const parts = [];
     if (node.id !== 'end')
-        parts.push(`name: ${str(node.id)}`);
+        parts.push(`name: ${tsLiteral(node.id)}`);
     const ver = verClause(node);
     if (ver)
         parts.push(ver);
     // The serializer labels an unlabelled End `End`, so that needs no carrying.
     const label = node.display?.label;
     if (typeof label === 'string' && label !== 'End')
-        parts.push(`label: ${str(label)}`);
+        parts.push(`label: ${tsLiteral(label)}`);
     return parts.length ? `, { ${parts.join(', ')} }` : '';
 }
 /**
@@ -2229,7 +2211,7 @@ function region(cursor, stop, scope, ipdom, ctx, refInto) {
     while (cursor !== undefined && cursor !== stop && cursor !== EXIT) {
         // A ref forward: this path re-enters a step the main path reaches later.
         if (refInto?.has(cursor)) {
-            segs.push(`.stepToRef(${str(cursor)})`);
+            segs.push(`.stepToRef(${tsLiteral(cursor)})`);
             return segs;
         }
         const node = ctx.graph.byId.get(cursor);
@@ -2241,7 +2223,7 @@ function region(cursor, stop, scope, ipdom, ctx, refInto) {
         // terminates are excluded: they are not named steps, so there is nothing a ref
         // could resolve against, and each path emitting its own is already correct.
         if (ctx.emitted.has(cursor) && node.type !== T.end && node.type !== T.terminate) {
-            segs.push(`.stepToRef(${str(cursor)})`);
+            segs.push(`.stepToRef(${tsLiteral(cursor)})`);
             return segs;
         }
         ctx.emitted.add(cursor);
@@ -2250,7 +2232,7 @@ function region(cursor, stop, scope, ipdom, ctx, refInto) {
             return segs;
         }
         if (node.type === T.terminate) {
-            segs.push(`.terminate(${str(node.id)}, undefined${optsArg(node, ctx)})`);
+            segs.push(`.terminate(${tsLiteral(node.id)}, undefined${optsArg(node, ctx)})`);
             return segs;
         }
         if (node.type === T.merge) {
@@ -2266,10 +2248,10 @@ function region(cursor, stop, scope, ipdom, ctx, refInto) {
             const elseSegs = region(portTarget(ctx.graph, node.id, 'false'), r, scope, ipdom, ctx, refInto);
             const labels = armLabels(node);
             if (labels.trueLabel)
-                thenSegs.unshift(`.label(${str(labels.trueLabel)})`);
+                thenSegs.unshift(`.label(${tsLiteral(labels.trueLabel)})`);
             if (labels.falseLabel)
-                elseSegs.unshift(`.label(${str(labels.falseLabel)})`);
-            segs.push(`.branch(${str(node.id)}, ${cond},\n${reindent(armCb('t', thenSegs), '  ')},\n${reindent(armCb('e', elseSegs), '  ')}${verArg(node)})`);
+                elseSegs.unshift(`.label(${tsLiteral(labels.falseLabel)})`);
+            segs.push(`.branch(${tsLiteral(node.id)}, ${cond},\n${reindent(armCb('t', thenSegs), '  ')},\n${reindent(armCb('e', elseSegs), '  ')}${verArg(node)})`);
             cursor = r === EXIT ? undefined : r;
             continue;
         }
@@ -2313,14 +2295,14 @@ function region(cursor, stop, scope, ipdom, ctx, refInto) {
                 const cond = typeof condRaw === 'string' && condRaw.length
                     ? emitBareExpr(condRaw.startsWith('=js:') ? condRaw.slice(4) : condRaw, ctx.imp, ctx.inputNames)
                     : `${ctx.imp.use('lit')}(true)`;
-                segs.push(`.doWhile(${str(node.id)}, ${cond}, ${armCb('b', bodySegs)}${opts})`);
+                segs.push(`.doWhile(${tsLiteral(node.id)}, ${cond}, ${armCb('b', bodySegs)}${opts})`);
             }
             else {
                 const collRaw = unwrapSource(inputs.collection);
                 const collection = collRaw !== undefined
                     ? emitBareExpr(collRaw.startsWith('=js:') ? collRaw.slice(4) : collRaw, ctx.imp, ctx.inputNames)
                     : `${ctx.imp.use('lit')}([])`;
-                segs.push(`.loop(${str(node.id)}, ${collection}, ${armCb('b', bodySegs)}${opts})`);
+                segs.push(`.loop(${tsLiteral(node.id)}, ${collection}, ${armCb('b', bodySegs)}${opts})`);
             }
             // A container can carry an error handler too — `core.logic.loop` declares
             // the handle, and `.onError()` after `.loop(...)` authors it. Without this
@@ -2334,7 +2316,7 @@ function region(cursor, stop, scope, ipdom, ctx, refInto) {
             continue;
         }
         if (node.type === T.subflow) {
-            segs.push(`.step(${str(node.id)}, ${emitSubflow(node, ctx)}${optsArg(node, ctx)})`);
+            segs.push(`.step(${tsLiteral(node.id)}, ${emitSubflow(node, ctx)}${optsArg(node, ctx)})`);
             cursor = scopeSucc(ctx.graph, node.id, scope)[0];
             continue;
         }
@@ -2352,14 +2334,14 @@ function region(cursor, stop, scope, ipdom, ctx, refInto) {
             const r = ipdom.get(node.id) ?? stop;
             const armSrcs = exitPorts.map(({ value, port }) => {
                 const armSegs = region(portTarget(ctx.graph, node.id, port), r, scope, ipdom, ctx, refInto);
-                return `{ value: ${str(value)}, body: ${armCb('b', armSegs)} }`;
+                return `{ value: ${tsLiteral(value)}, body: ${armCb('b', armSegs)} }`;
             });
             const armList = `[\n${armSrcs.map((a) => reindent(a, '  ')).join(',\n')},\n]`;
-            segs.push(`.stepSwitch(${str(node.id)}, ${spec}, ${armList}${optsArg(node, ctx)})`);
+            segs.push(`.stepSwitch(${tsLiteral(node.id)}, ${spec}, ${armList}${optsArg(node, ctx)})`);
             cursor = r === EXIT ? undefined : r;
             continue;
         }
-        segs.push(`.step(${str(node.id)}, ${spec}${optsArg(node, ctx)})`);
+        segs.push(`.step(${tsLiteral(node.id)}, ${spec}${optsArg(node, ctx)})`);
         // An error handler on this step (source port `error` + `errorHandlingEnabled`).
         const succ = scopeSucc(ctx.graph, node.id, scope);
         const handler = errorHandlerSeg(node.id, succ, scope, ipdom, ctx);
@@ -2373,7 +2355,7 @@ function region(cursor, stop, scope, ipdom, ctx, refInto) {
             const branchSegs = region(be.targetNodeId, EXIT, scope, ipdom, ctx, mainReach);
             if (branchSegs.length === 0)
                 branchSegs.push('.return({})');
-            segs.push(`.stepToList(${str(be.sourcePort)}, ${armCb('p', branchSegs)})`);
+            segs.push(`.stepToList(${tsLiteral(be.sourcePort)}, ${armCb('p', branchSegs)})`);
         }
         // A per-outcome human task routes each NON-primary outcome from its own
         // `outcome-<slug>` exit; the primary one continues the main path, so it is
@@ -2388,7 +2370,7 @@ function region(cursor, stop, scope, ipdom, ctx, refInto) {
                 const outSegs = region(oe.targetNodeId, EXIT, scope, ipdom, ctx, mainReach);
                 if (outSegs.length === 0)
                     outSegs.push('.return({})');
-                segs.push(`.stepToList(${str(oe.sourcePort)}, ${armCb('p', outSegs)})`);
+                segs.push(`.stepToList(${tsLiteral(oe.sourcePort)}, ${armCb('p', outSegs)})`);
             }
         }
         // A body edge into the enclosing container's break handle: the path exits
@@ -2410,7 +2392,7 @@ function region(cursor, stop, scope, ipdom, ctx, refInto) {
         const join = ipdom.get(node.id);
         if (join && join !== EXIT && ctx.graph.byId.get(join)?.type === T.merge) {
             const arms = succ.map((t, i) => armCb(`a${i}`, region(t, join, scope, ipdom, ctx, refInto)));
-            segs.push(`.parallel(${str(join)}, [\n${arms.map((a) => reindent(a, '  ')).join(',\n')},\n]${verArg(ctx.graph.byId.get(join))})`);
+            segs.push(`.parallel(${tsLiteral(join)}, [\n${arms.map((a) => reindent(a, '  ')).join(',\n')},\n]${verArg(ctx.graph.byId.get(join))})`);
             cursor = portTarget(ctx.graph, join, 'output');
             continue;
         }
@@ -2534,12 +2516,12 @@ function emitSwitch(node, ipdom, scope, ctx, stop, refInto) {
         if (m) {
             valueLiteral = m[2].trim();
             try {
-                value = literal(JSON.parse(valueLiteral));
+                value = tsLiteral(JSON.parse(valueLiteral));
             }
             catch {
                 // A non-JSON literal (e.g. single-quoted) — strip matching quotes if any.
                 const q = valueLiteral.match(/^'(.*)'$/);
-                value = q ? str(q[1]) : str(valueLiteral);
+                value = q ? tsLiteral(q[1]) : tsLiteral(valueLiteral);
             }
         }
         else {
@@ -2547,7 +2529,7 @@ function emitSwitch(node, ipdom, scope, ctx, stop, refInto) {
         }
         const armSegs = region(portTarget(ctx.graph, node.id, `case-${c.id}`), r, scope, ipdom, ctx, refInto);
         const defaultLabel = `Case ${valueLiteral}`;
-        const labelPart = c.label && c.label !== defaultLabel ? `, label: ${str(c.label)}` : '';
+        const labelPart = c.label && c.label !== defaultLabel ? `, label: ${tsLiteral(c.label)}` : '';
         caseSrcs.push(`{ value: ${value}${labelPart}, body: ${armCb('b', armSegs)} }`);
     }
     const on = emitBareExpr(disc ?? '', ctx.imp, ctx.inputNames);
@@ -2564,7 +2546,7 @@ function emitSwitch(node, ipdom, scope, ctx, stop, refInto) {
         ? `\n/* TODO: this switch's case expressions are not a uniform \`<discriminant> === <value>\`; the recovered on/value are best-effort and need review. */`
         : '';
     const ver = verArg(node);
-    return `.switch(${str(node.id)}, ${on}, ${caseList}${defArm}${ver && !defArm ? ', undefined' : ''}${ver})${warn}`;
+    return `.switch(${tsLiteral(node.id)}, ${on}, ${caseList}${defArm}${ver && !defArm ? ', undefined' : ''}${ver})${warn}`;
 }
 /** The manifest-less annotation node type — the only annotation `.flow` has. */
 const STICKY_NOTE_TYPE = 'stickyNote';
@@ -2588,14 +2570,14 @@ function stickyNotesSeg(nodes, flow) {
         const ui = { ...(n.ui ?? {}), ...(hoisted[n.id] ?? {}) };
         const pos = ui.position ?? { x: 0, y: 0 };
         const fields = [
-            `id: ${str(n.id)}`,
-            `content: ${str(typeof i.content === 'string' ? i.content : '')}`,
+            `id: ${tsLiteral(n.id)}`,
+            `content: ${tsLiteral(typeof i.content === 'string' ? i.content : '')}`,
         ];
         if (typeof i.color === 'string' && i.color !== 'yellow')
-            fields.push(`color: ${str(i.color)}`);
-        fields.push(`x: ${numLit(pos.x)}`, `y: ${numLit(pos.y)}`);
+            fields.push(`color: ${tsLiteral(i.color)}`);
+        fields.push(`x: ${tsNumber(pos.x)}`, `y: ${tsNumber(pos.y)}`);
         if (ui.size && typeof ui.size.width === 'number' && typeof ui.size.height === 'number') {
-            fields.push(`width: ${numLit(ui.size.width)}`, `height: ${numLit(ui.size.height)}`);
+            fields.push(`width: ${tsNumber(ui.size.width)}`, `height: ${tsNumber(ui.size.height)}`);
         }
         return `  { ${fields.join(', ')} },`;
     });
@@ -2645,9 +2627,9 @@ function layoutSeg(flow, nodes, edges) {
         const pos = ui.position;
         if (!pos || typeof pos.x !== 'number' || typeof pos.y !== 'number')
             continue;
-        const fields = [`position: { x: ${numLit(pos.x)}, y: ${numLit(pos.y)} }`];
+        const fields = [`position: { x: ${tsNumber(pos.x)}, y: ${tsNumber(pos.y)} }`];
         if (ui.size && typeof ui.size.width === 'number' && typeof ui.size.height === 'number') {
-            fields.push(`size: { width: ${numLit(ui.size.width)}, height: ${numLit(ui.size.height)} }`);
+            fields.push(`size: { width: ${tsNumber(ui.size.width)}, height: ${tsNumber(ui.size.height)} }`);
         }
         if (typeof ui.collapsed === 'boolean')
             fields.push(`collapsed: ${boolLit(ui.collapsed)}`);
@@ -2671,7 +2653,7 @@ function layoutSeg(flow, nodes, edges) {
                 continue;
             const rendered = pts
                 .filter((p) => p && typeof p.x === 'number' && typeof p.y === 'number')
-                .map((p) => `{ x: ${numLit(p.x)}, y: ${numLit(p.y)}${typeof p.id === 'string' ? `, id: ${str(p.id)}` : ''} }`);
+                .map((p) => `{ x: ${tsNumber(p.x)}, y: ${tsNumber(p.y)}${typeof p.id === 'string' ? `, id: ${tsLiteral(p.id)}` : ''} }`);
             if (rendered.length)
                 parts.push(`${which}: [${rendered.join(', ')}]`);
         }
@@ -2680,7 +2662,7 @@ function layoutSeg(flow, nodes, edges) {
         const pair = `${e.sourceNodeId}->${e.targetNodeId}`;
         if ((pairCount.get(pair) ?? 0) !== 1)
             continue; // ambiguous — see the note above
-        edgeEntries.push(`${str(pair)}: { ${parts.join(', ')} }`);
+        edgeEntries.push(`${tsLiteral(pair)}: { ${parts.join(', ')} }`);
     }
     if (!nodeEntries.length && !edgeEntries.length)
         return undefined;
@@ -2725,7 +2707,7 @@ function emitChildFlow(name, child, ctx) {
         emitted: new Set(),
         o: ctx.o,
     };
-    const parts = [`${ctx.imp.use('flow')}(${str(name)})`];
+    const parts = [`${ctx.imp.use('flow')}(${tsLiteral(name)})`];
     // Variables.
     const shape = (dir) => `{ ${globals.filter((g) => g.direction === dir).map((g) => `${key(g.name ?? g.id)}: ${declExpr(g, dir !== 'inout', ctx.imp)}`).join(', ')} }`;
     if (globals.some((g) => g.direction === 'in'))
@@ -2733,8 +2715,8 @@ function emitChildFlow(name, child, ctx) {
     if (globals.some((g) => g.direction === 'out'))
         parts.push(`.output(${shape('out')})`);
     for (const g of globals.filter((g) => g.direction === 'inout')) {
-        const def = g.defaultValue !== undefined ? `, ${literal(g.defaultValue)}` : '';
-        parts.push(`.var(${str(g.name ?? g.id)}, ${declExpr(g, false, ctx.imp)}${def})`);
+        const def = g.defaultValue !== undefined ? `, ${tsLiteral(g.defaultValue)}` : '';
+        parts.push(`.var(${tsLiteral(g.name ?? g.id)}, ${declExpr(g, false, ctx.imp)}${def})`);
     }
     // Body: the child's trigger is its own manual Start; walk from its successor.
     const trigger = (child.nodes ?? []).find((n) => isTrigger(n.type) && !(child.edges ?? []).some((e) => e.targetNodeId === n.id));
@@ -2788,7 +2770,7 @@ export function decompile(flow, options = {}) {
             (flow.nodes ?? []).find((n) => String(n.type ?? '').startsWith('core.trigger.'))?.id ??
             DEFAULT_TRIGGER_ID;
     const e = new Emit();
-    e.line(0, `export default ${imp.use('flow')}(${str(slugId(flow))})`);
+    e.line(0, `export default ${imp.use('flow')}(${tsLiteral(slugId(flow))})`);
     const d = 1;
     // The file-format version FIRST, mirroring the order the file itself carries
     // it (`id`, `version`, `name`) — and emitted even when it equals this SDK's
@@ -2806,9 +2788,9 @@ export function decompile(flow, options = {}) {
         e.line(d, `// TODO: ${commentText(schema.problem)}`);
     }
     if (flow.name !== undefined && flow.name !== flow.id)
-        e.line(d, `.name(${str(flow.name)})`);
+        e.line(d, `.name(${tsLiteral(flow.name)})`);
     if (typeof flow.description === 'string') {
-        e.line(d, `.description(${str(flow.description)})`);
+        e.line(d, `.description(${tsLiteral(flow.description)})`);
     }
     // Trigger nodes. One root is the default: the isDefaultEntryPoint carrier
     // when the file marks one (a multi-root flow always does), else `start`.
@@ -2831,7 +2813,7 @@ export function decompile(flow, options = {}) {
     const detached = detachedTopLevelNodes(flow.nodes ?? [], graph, triggerNodes, trigger);
     const detachedIds = new Set(detached.map((n) => n.id));
     if (detached.length > 0) {
-        const listing = detached.map((n) => `${str(n.id)} (${n.type})`).join(', ');
+        const listing = detached.map((n) => `${tsLiteral(n.id)} (${n.type})`).join(', ');
         const message = `${detached.length} node(s) are not reachable from any trigger — no edge leads to them: ${listing}. `
             + 'The builder has no detached-node construct, so this source omits them and recompiling drops them. '
             + 'Connect each one with an edge in the .flow first, or edit that node\'s JSON directly.';
@@ -2839,14 +2821,14 @@ export function decompile(flow, options = {}) {
             throw new Error(`decompile: ${message}`);
         warnOnce(message);
         for (const n of detached) {
-            e.line(d, `// TODO: node ${commentText(str(n.id))} (${commentText(n.type)}) is not reachable from any trigger and is NOT in this source; recompiling drops it. Connect it in the .flow or edit its JSON directly.`);
+            e.line(d, `// TODO: node ${commentText(tsLiteral(n.id))} (${commentText(n.type)}) is not reachable from any trigger and is NOT in this source; recompiling drops it. Connect it in the .flow or edit its JSON directly.`);
         }
     }
     // `{ shared }` input copies on the roots (#924). Any other trigger-level
     // update has no builder spelling: say so instead of dropping it.
     const shared = sharedCopies(flow, triggerNodes);
     if (shared.unrecognized.length) {
-        const listing = shared.unrecognized.map((u) => `${str(u.variableId)} on ${str(u.trigger)}`).join(', ');
+        const listing = shared.unrecognized.map((u) => `${tsLiteral(u.variableId)} on ${tsLiteral(u.trigger)}`).join(', ');
         const message = `${shared.unrecognized.length} variable update(s) on a trigger node are not a { shared } input copy: ${listing}. `
             + 'The builder writes a trigger-level update only for { type, shared: \'<var>\' } (the row `<var> ← $vars.<trigger>.output.<input>`), '
             + 'so this source omits them and recompiling drops them.';
@@ -2930,21 +2912,11 @@ function scheduleEvery(t) {
 }
 /** One `.entryPoint(id, trigger, { inputs, version }, prefix)` segment for a non-default root. */
 function entryPointSeg(t, scope, ipdom, ctx) {
-    const factory = t.type === T.triggerScheduled
-        ? `${ctx.imp.use('scheduled')}(${opts([['every', str(scheduleEvery(t))]])})`
-        : t.type === T.triggerForm
-            ? `${ctx.imp.use('formTrigger')}()`
-            : t.type === T.triggerConversation
-                ? `${ctx.imp.use('conversationTrigger')}()`
-                : t.type === T.triggerVoice
-                    ? `${ctx.imp.use('voiceTrigger')}()`
-                    : t.type === T.triggerManual
-                        ? `${ctx.imp.use('manual')}()`
-                        : (() => {
-                            if (ctx.o.bestEffort === false)
-                                throw new Error(`decompile: unsupported entry-point trigger type "${t.type}".`);
-                            return `${ctx.imp.use('manual')}() /* TODO: unsupported trigger type ${commentText(t.type)} */`;
-                        })();
+    const known = triggerFactory(t, ctx.imp, ctx.inputNames);
+    if (known === undefined && ctx.o.bestEffort === false) {
+        throw new Error(`decompile: unsupported entry-point trigger type "${t.type}".`);
+    }
+    const factory = known ?? `${ctx.imp.use('manual')}() /* TODO: unsupported trigger type ${commentText(t.type)} */`;
     const scoped = readFlowGlobals(ctx.flow.variables, runStrict)
         .filter((g) => g.direction === 'in' && g.triggerNodeId === t.id);
     const optParts = [];
@@ -2957,5 +2929,5 @@ function entryPointSeg(t, scope, ipdom, ctx) {
     const prefixSegs = first !== undefined ? region(first, EXIT, scope, ipdom, ctx) : [];
     const optArgText = optParts.length ? `, { ${optParts.join(', ')} }` : (prefixSegs.length ? ', undefined' : '');
     const prefix = prefixSegs.length ? `, ${armCb('b', prefixSegs)}` : '';
-    return `.entryPoint(${str(t.id)}, ${factory}${optArgText}${prefix})`;
+    return `.entryPoint(${tsLiteral(t.id)}, ${factory}${optArgText}${prefix})`;
 }