@uipath/maestro-builder-sdk 6.17.6 → 6.18.1

package/dist/merge.js

@@ -64,9 +64,7 @@
  * merge that stayed silent about it wrote a file it already knew would fail
  * `validate`. Those are reported through {@link MergeOptions.warn}.
  */
-function clone(v) {
-    return JSON.parse(JSON.stringify(v));
-}
+import { jsonClone } from './core/json-file.js';
 function byId(nodes) {
     return new Map((nodes ?? []).map((n) => [n.id, n]));
 }
@@ -88,10 +86,10 @@ function nodeUnchanged(a, b) {
 function withOriginalLayout(edited, orig) {
     if (!orig || orig.ui === undefined)
         return edited;
-    return { ...edited, ui: clone(orig.ui) };
+    return { ...edited, ui: jsonClone(orig.ui) };
 }
 export function mergeFlow(original, edited, options = {}) {
-    const result = clone(original);
+    const result = jsonClone(original);
     const origNodes = byId(original.nodes);
     const baseNodes = byId(options.baseline?.nodes);
     // ── Nodes: the edited graph decides which nodes exist and in what order; the
@@ -102,19 +100,19 @@ export function mergeFlow(original, edited, options = {}) {
         if (options.baseline && orig && nodeUnchanged(e, baseNodes.get(e.id))) {
             // Untouched by the user (equal to the faithful baseline) → keep the
             // original node exactly, placeholder-safe.
-            finalNodes.push(clone(orig));
+            finalNodes.push(jsonClone(orig));
         }
         else {
             // Added or edited → take the edited node, re-attaching original layout.
-            finalNodes.push(withOriginalLayout(clone(e), orig));
+            finalNodes.push(withOriginalLayout(jsonClone(e), orig));
         }
     }
     result.nodes = finalNodes;
     // Nodes present in the original but absent from `edited` were deleted by the
     // user; they are simply not carried over.
     // ── Variables & subflows: the edited flow is authoritative (the user's graph). ──
-    result.variables = clone(edited.variables);
-    result.subflows = clone(edited.subflows ?? {});
+    result.variables = jsonClone(edited.variables);
+    result.subflows = jsonClone(edited.subflows ?? {});
     const subflowScopes = Object.values(result.subflows);
     // ── Edges: the edited graph's edges define the wiring, under the edited
     //    file's own ids. compile draws every edge id — root AND subflows — from
@@ -172,7 +170,7 @@ function withFileUniqueEdgeIds(edges, subflows) {
     return edges.map((e) => {
         const id = typeof e.id === 'string' && !taken.has(e.id) ? e.id : fresh();
         taken.add(id);
-        return { ...clone(e), id };
+        return { ...jsonClone(e), id };
     });
 }
 /** The `nodeType@version` identity of a definition row or of a node's type pin. */
@@ -219,7 +217,7 @@ function mergeDefinitions(orig, edited, nodes, warn) {
             + `Recompile the edited source against an SDK that bundles ${key}, or align the node's typeVersion `
             + `with a definition one of the inputs does carry.`);
     }
-    return [...out.values()].map((d) => clone(d));
+    return [...out.values()].map((d) => jsonClone(d));
 }
 function mergeBindings(orig, edited) {
     const byId2 = new Map();
@@ -229,5 +227,5 @@ function mergeBindings(orig, edited) {
     for (const b of orig ?? [])
         if (b.id)
             byId2.set(b.id, b); // original wins
-    return [...byId2.values()].map((b) => clone(b));
+    return [...byId2.values()].map((b) => jsonClone(b));
 }

package/dist/registry/compat/pystr.d.ts

@@ -48,3 +48,5 @@ export declare function beforeLast(s: string, sep: string): string;
 export declare function splitOnce(s: string, sep: string): [string, string | undefined];
 /** `str.isdigit()` for ASCII digits, which is all the generators ever test. */
 export declare function isAsciiDigits(s: string): boolean;
+/** `repr(str)`: single quotes unless the text has a `'` and no `"`; escapes as CPython does. */
+export declare function pyReprString(s: string): string;

package/dist/registry/compat/pystr.js

@@ -219,3 +219,38 @@ export function splitOnce(s, sep) {
 export function isAsciiDigits(s) {
     return /^[0-9]+$/.test(s);
 }
+/**
+ * `str.isprintable()` is false for these categories (and true for the ASCII
+ * space, which is in Zs). `repr` escapes exactly the non-printable ones.
+ */
+const NOT_PRINTABLE = /[\p{Cc}\p{Cf}\p{Cs}\p{Co}\p{Cn}\p{Zl}\p{Zp}\p{Zs}]/u;
+function hex(codePoint, width) {
+    return codePoint.toString(16).padStart(width, "0");
+}
+/** `repr(str)`: single quotes unless the text has a `'` and no `"`; escapes as CPython does. */
+export function pyReprString(s) {
+    const quote = s.includes("'") && !s.includes('"') ? '"' : "'";
+    let out = quote;
+    for (const ch of s) {
+        if (ch === quote || ch === "\\")
+            out += `\\${ch}`;
+        else if (ch === "\n")
+            out += "\\n";
+        else if (ch === "\r")
+            out += "\\r";
+        else if (ch === "\t")
+            out += "\\t";
+        else if (ch !== " " && NOT_PRINTABLE.test(ch)) {
+            const codePoint = ch.codePointAt(0);
+            out +=
+                codePoint < 0x100
+                    ? `\\x${hex(codePoint, 2)}`
+                    : codePoint < 0x10000
+                        ? `\\u${hex(codePoint, 4)}`
+                        : `\\U${hex(codePoint, 8)}`;
+        }
+        else
+            out += ch;
+    }
+    return out + quote;
+}

package/dist/registry/compat/pyvalue.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Python value semantics the registry ports lean on (`bool()`, `or`), spelled
+ * once; FB005 holds these names to this file.
+ *
+ * The prepare helpers, the library build and the generators each carried a copy,
+ * and they had drifted: `bigint` and `Set` were handled in some only, and `pyOr`
+ * had two signatures. On JSON values (all `JSON.parse` yields) every copy agreed,
+ * so the byte-locked outputs that lean on them are unchanged.
+ */
+/**
+ * `bool(value)`: `None`, `False`, `0`, `""` and empty containers are false;
+ * `NaN` is true, as in Python.
+ */
+export declare function pyTruthy(value: unknown): boolean;
+/** `a or b or …`: the first truthy operand, else the last one. */
+export declare function pyOr<T extends readonly unknown[]>(...values: T): T[number];

package/dist/registry/compat/pyvalue.js

@@ -0,0 +1,35 @@
+/**
+ * Python value semantics the registry ports lean on (`bool()`, `or`), spelled
+ * once; FB005 holds these names to this file.
+ *
+ * The prepare helpers, the library build and the generators each carried a copy,
+ * and they had drifted: `bigint` and `Set` were handled in some only, and `pyOr`
+ * had two signatures. On JSON values (all `JSON.parse` yields) every copy agreed,
+ * so the byte-locked outputs that lean on them are unchanged.
+ */
+/**
+ * `bool(value)`: `None`, `False`, `0`, `""` and empty containers are false;
+ * `NaN` is true, as in Python.
+ */
+export function pyTruthy(value) {
+    if (value === null || value === undefined || value === false || value === "")
+        return false;
+    if (typeof value === "number")
+        return value !== 0; // NaN is truthy in Python
+    if (typeof value === "bigint")
+        return value !== 0n;
+    if (Array.isArray(value))
+        return value.length > 0;
+    if (value instanceof Map || value instanceof Set)
+        return value.size > 0;
+    if (typeof value === "object")
+        return Object.keys(value).length > 0;
+    return true;
+}
+/** `a or b or …`: the first truthy operand, else the last one. */
+export function pyOr(...values) {
+    for (const value of values)
+        if (pyTruthy(value))
+            return value;
+    return values[values.length - 1];
+}

package/dist/registry/generators/markdown/pyvalue.d.ts

@@ -1,8 +1,5 @@
+export { pyTruthy, pyOr } from "../../compat/pyvalue.js";
 export type Dict = Record<string, unknown>;
-/** Python truthiness for JSON-shaped values: empty strings and containers are false, `NaN` is true. */
-export declare function pyTruthy(v: unknown): boolean;
-/** `a or b or …`: the first Python-truthy operand, else the last one. */
-export declare function pyOr<T>(...values: T[]): T;
 /** `isinstance(v, dict)`. */
 export declare function isDict(v: unknown): v is Dict;
 /** `(v or {})` where the Python goes on to call `.get` — a non-dict reads as empty. */

package/dist/registry/generators/markdown/pyvalue.js

@@ -10,36 +10,8 @@
  * default) and a `None` value (printed as `None`).
  */
 import { pyStr, pyStripChars } from "../../compat/pystr.js";
-/** Python truthiness for JSON-shaped values: empty strings and containers are false, `NaN` is true. */
-export function pyTruthy(v) {
-    if (v === null || v === undefined)
-        return false;
-    switch (typeof v) {
-        case "boolean":
-            return v;
-        case "number":
-            return v !== 0;
-        case "bigint":
-            return v !== 0n;
-        case "string":
-            return v.length > 0;
-        case "object":
-            if (Array.isArray(v))
-                return v.length > 0;
-            if (v instanceof Map || v instanceof Set)
-                return v.size > 0;
-            return Object.keys(v).length > 0;
-        default:
-            return true;
-    }
-}
-/** `a or b or …`: the first Python-truthy operand, else the last one. */
-export function pyOr(...values) {
-    for (const v of values)
-        if (pyTruthy(v))
-            return v;
-    return values[values.length - 1];
-}
+import { pyOr } from "../../compat/pyvalue.js";
+export { pyTruthy, pyOr } from "../../compat/pyvalue.js";
 /** `isinstance(v, dict)`. */
 export function isDict(v) {
     return v !== null && typeof v === "object" && !Array.isArray(v);

package/dist/registry/generators/markdown/sections/inputs.js

@@ -13,6 +13,7 @@ import { pyStr, pyStrip } from "../../../compat/pystr.js";
 import { isContainerPart } from "../../fields.js";
 import { authoringField, enumValue, referenceCollection } from "../common.js";
 import { dictOf, listOf, pyOr, pyTruthy } from "../pyvalue.js";
+import { ownEntry } from "../../../../core/own-entry.js";
 /** `operation.parameters[].type` → the wire slot, mirroring `core/library.ts`'s PARAM_LOCATIONS. */
 const PARAM_LOCATIONS = { query: "query", path: "path", multipart: "multipart" };
 /** A parameter's `dataType` → the scalar names `compile`'s literal type-check understands. */
@@ -28,7 +29,7 @@ const SCALARS = {
 export function scalarType(dataType) {
     if (typeof dataType !== "string")
         return "?";
-    return Object.hasOwn(SCALARS, dataType) ? SCALARS[dataType] : dataType;
+    return ownEntry(SCALARS, dataType) ?? dataType;
 }
 /**
  * The op's QUERY, PATH and file MULTIPART parameters as body-shaped fields,
@@ -41,7 +42,7 @@ export function paramFields(j) {
         const p = dictOf(raw);
         const name = p.name;
         const type = p.type;
-        const loc = typeof type === "string" && Object.hasOwn(PARAM_LOCATIONS, type) ? PARAM_LOCATIONS[type] : undefined;
+        const loc = typeof type === "string" ? ownEntry(PARAM_LOCATIONS, type) : undefined;
         if (typeof name !== "string" || !name || !loc)
             continue;
         if (isContainerPart(p))

package/dist/registry/generators/type-tree.d.ts

@@ -1,13 +1,7 @@
 import type { LibraryField } from "../model/library.js";
+export { pyTruthy } from "../compat/pyvalue.js";
 /** Registry field `type` → TypeScript type; anything else is `unknown`. */
 export declare const TYPE_MAP: Readonly<Record<string, string>>;
-/**
- * Python truthiness for a JSON-shaped value. JavaScript agrees on `null`,
- * `false`, `0` and `""` but calls an empty array or object truthy; the Python
- * generator tested `field.get("required")`, `runtime.get("requiresConnection")`
- * and the like with a bare `if`, so the emitted bytes depend on this rule.
- */
-export declare function pyTruthy(value: unknown): boolean;
 /** `TYPE_MAP.get(str(field["type"] or "").lower(), "unknown")`. */
 export declare function tsType(field: {
     type?: unknown;

package/dist/registry/generators/type-tree.js

@@ -12,7 +12,10 @@
  */
 import { sortedStrings } from "../compat/compare.js";
 import { pyStr } from "../compat/pystr.js";
+import { pyTruthy } from "../compat/pyvalue.js";
 import { pascal, singular } from "../naming.js";
+import { ownEntry } from "../../core/own-entry.js";
+export { pyTruthy } from "../compat/pyvalue.js";
 /** Registry field `type` → TypeScript type; anything else is `unknown`. */
 export const TYPE_MAP = {
     string: "string",
@@ -28,34 +31,14 @@ export const TYPE_MAP = {
     json: "unknown",
     file: "string",
 };
-/**
- * Python truthiness for a JSON-shaped value. JavaScript agrees on `null`,
- * `false`, `0` and `""` but calls an empty array or object truthy; the Python
- * generator tested `field.get("required")`, `runtime.get("requiresConnection")`
- * and the like with a bare `if`, so the emitted bytes depend on this rule.
- */
-export function pyTruthy(value) {
-    if (value === null || value === undefined || value === false || value === "")
-        return false;
-    if (typeof value === "number")
-        return value !== 0; // NaN is truthy in Python
-    if (typeof value === "bigint")
-        return value !== 0n;
-    if (Array.isArray(value))
-        return value.length > 0;
-    if (value instanceof Map || value instanceof Set)
-        return value.size > 0;
-    if (typeof value === "object")
-        return Object.keys(value).length > 0;
-    return true;
-}
 /** `str(value or "")`: the coercion the generator applied before comparing a type name. */
 function strOrEmpty(value) {
     return pyTruthy(value) ? pyStr(value) : "";
 }
 /** `TYPE_MAP.get(str(field["type"] or "").lower(), "unknown")`. */
 export function tsType(field) {
-    return TYPE_MAP[strOrEmpty(field.type).toLowerCase()] ?? "unknown";
+    const type = strOrEmpty(field.type).toLowerCase();
+    return ownEntry(TYPE_MAP, type) ?? "unknown";
 }
 /** One node in a tree reconstructed from flattened connector field paths. */
 export class TypeNode {

package/dist/registry/library-build/build.js

@@ -22,7 +22,7 @@ import { enrichAll } from "./enrich.js";
 import { resolveConnectorEvents } from "./events.js";
 import { expandAllGenerics, sortExpandedEntries } from "./generic-expand.js";
 import { orphanCheck, planLibrary, triggerRows } from "./plan.js";
-import { get, item, pyIter, pyOr, pyReprStrList, truthy } from "./py.js";
+import { get, item, pyIter, pyOr, pyReprStrList, pyTruthy } from "./py.js";
 import { writePlan, writeTriggerSideFile } from "./write.js";
 /** The Python's default: beside the output directory. */
 export function defaultTriggersOutput(outputDir) {
@@ -109,7 +109,7 @@ export async function fetchAll(ctx, nodeTypes) {
  * sorted and deduplicated; `key → record`, `null` where the lookup failed.
  */
 export async function fetchConnectorRecordsForKeys(ctx, keys) {
-    const sorted = sortedStrings(new Set([...keys].filter((key) => truthy(key))));
+    const sorted = sortedStrings(new Set([...keys].filter((key) => pyTruthy(key))));
     ctx.reporter.info(`  Looking up ${sorted.length} connector records...`);
     let done = 0;
     const records = await mapConcurrent(sorted, ctx.concurrency, async (key) => {
@@ -129,7 +129,7 @@ export async function fetchConnectorRecordsForKeys(ctx, keys) {
 }
 /** `fetch_connector_records`: one record per unique connector key in `entries`. */
 export function fetchConnectorRecords(ctx, entries) {
-    const keys = entries.map((e) => item(item(e, "connector"), "key")).filter((key) => truthy(key));
+    const keys = entries.map((e) => item(item(e, "connector"), "key")).filter((key) => pyTruthy(key));
     return fetchConnectorRecordsForKeys(ctx, keys);
 }
 /** The whole generator, `main()` minus argument parsing and cache cleanup. */
@@ -213,7 +213,7 @@ export async function buildLibrary(options, ports) {
         const name = cacheFiles.get(nt);
         try {
             const entry = extractCanonical(nodeOf(ctx.caches.registry.read(name)));
-            if (truthy(entry)) {
+            if (pyTruthy(entry)) {
                 entries.push(entry);
                 v1defSources.set(item(entry, "nodeType"), name);
                 // `entry["operation"].get("activityType", "") or "(empty)"`, printed
@@ -247,10 +247,10 @@ export async function buildLibrary(options, ports) {
         for (const e of entries) {
             const key = item(item(e, "connector"), "key");
             mergeConnectorRecord(e, connectorRecords.get(key) ?? null);
-            if (truthy(get(item(e, "connector"), "name")))
+            if (pyTruthy(get(item(e, "connector"), "name")))
                 named += 1;
         }
-        const schemaDynamic = entries.filter((e) => truthy(get(item(e, "runtime"), "requiresConnectionForSchema"))).length;
+        const schemaDynamic = entries.filter((e) => pyTruthy(get(item(e, "runtime"), "requiresConnectionForSchema"))).length;
         info(`  Named ${named}/${entries.length} entries from connector records`);
         info(`  schema-dynamic from connector capabilities: ${schemaDynamic}/${entries.length}`);
     }

package/dist/registry/library-build/canonical.js

@@ -12,7 +12,7 @@
  */
 import { pyStr, pyStrip, lowerFirst, startsWithUpper } from "../compat/pystr.js";
 import { sortedStrings } from "../compat/compare.js";
-import { get, isRecord, pyIter, pyOr, partition, truthy } from "./py.js";
+import { get, isPyDict, pyIter, pyOr, partition, pyTruthy } from "./py.js";
 import { schemaAction } from "./schema-action.js";
 export const SCHEMA_VERSION = "1";
 /** `(connectorKey, objectName)` as a Map key; `null`s stay distinct from `""`. */
@@ -84,7 +84,7 @@ export function applyCuratedOverrides(entries, overrides = CURATED_OP_OVERRIDE)
     for (const e of entries) {
         const key = curatedKey(get(pyOr(get(e, "connector", {}), {}), "key", ""), get(pyOr(get(e, "operation", {}), {}), "objectName", ""));
         const override = overrides.get(key);
-        if (!truthy(override))
+        if (!pyTruthy(override))
             continue;
         const target = e;
         for (const [section, fields] of Object.entries(override)) {
@@ -130,17 +130,17 @@ export function parameterMetadata(connectorMethodInfo) {
             meta.displayName = get(p, "displayName");
         if (get(p, "reference") !== null)
             meta.reference = get(p, "reference");
-        if (isRecord(p) && "enum" in p) {
+        if (isPyDict(p) && "enum" in p) {
             meta.enum = p.enum ?? null;
         }
-        else if (truthy(get(p, "enhancedEnum"))) {
+        else if (pyTruthy(get(p, "enhancedEnum"))) {
             const values = pyIter(get(p, "enhancedEnum"))
-                .filter((e) => isRecord(e) && get(e, "value") !== null)
+                .filter((e) => isPyDict(e) && get(e, "value") !== null)
                 .map((e) => get(e, "value"));
             if (values.length > 0)
                 meta.enum = values;
         }
-        if (truthy(meta))
+        if (pyTruthy(meta))
             out.set(name, meta);
     }
     return out;
@@ -156,7 +156,7 @@ export function nodeOf(payload) {
  */
 export function extractCanonical(nodeData, ctx = {}) {
     const node = nodeData;
-    if (!truthy(node))
+    if (!pyTruthy(node))
         return undefined;
     const nodeType = get(node, "nodeType", "");
     const model = pyOr(get(node, "model", {}), {});
@@ -168,7 +168,7 @@ export function extractCanonical(nodeData, ctx = {}) {
     for (const section of pyIter(pyOr(get(pyOr(get(node, "form", {}), {}), "sections", []), []))) {
         for (const f of pyIter(pyOr(get(section, "fields", []), []))) {
             const cp = get(pyOr(get(f, "componentProps"), {}), "connectorDetail");
-            if (isRecord(cp) && "configuration" in cp) {
+            if (isPyDict(cp) && "configuration" in cp) {
                 connectorDetail = cp;
                 break;
             }
@@ -176,13 +176,13 @@ export function extractCanonical(nodeData, ctx = {}) {
         if (connectorDetail)
             break;
     }
-    if (!truthy(connectorDetail))
+    if (!pyTruthy(connectorDetail))
         return undefined;
-    if (!truthy(get(connectorDetail, "isEnabled", false)))
+    if (!pyTruthy(get(connectorDetail, "isEnabled", false)))
         return undefined;
     if (get(connectorDetail, "targetPlatform") !== "CrossPlatform")
         return undefined;
-    if (truthy(get(connectorDetail, "isExperimental", true)))
+    if (pyTruthy(get(connectorDetail, "isExperimental", true)))
         return undefined;
     const configuration = get(connectorDetail, "configuration", "{}");
     if (typeof configuration !== "string") {
@@ -210,9 +210,9 @@ export function extractCanonical(nodeData, ctx = {}) {
     const paramMeta = parameterMetadata(cmi);
     const declaredFields = pyOr(get(get(node, "inputDefinition", {}), "fields"), []);
     const inputFields = [];
-    if (truthy(declaredFields)) {
+    if (pyTruthy(declaredFields)) {
         for (const declared of pyIter(declaredFields)) {
-            if (!isRecord(declared))
+            if (!isPyDict(declared))
                 throw new TypeError("cannot convert dictionary update sequence element to a dict");
             const merged = { ...declared };
             const meta = paramMeta.get(get(merged, "name")) ?? {};
@@ -236,9 +236,9 @@ export function extractCanonical(nodeData, ctx = {}) {
         }
     }
     let outputFields = get(get(node, "outputDefinition", {}), "fields");
-    if (!truthy(outputFields))
+    if (!pyTruthy(outputFields))
         outputFields = get(get(node, "outputResponseDefinition", {}), "fields");
-    if (!truthy(outputFields))
+    if (!pyTruthy(outputFields))
         outputFields = [];
     const display = pyOr(get(node, "display", {}), {});
     const isTrigger = pyStr(activityType).endsWith("Trigger");
@@ -257,7 +257,7 @@ export function extractCanonical(nodeData, ctx = {}) {
     // the platform stamps (`EMAIL_RECEIVED`), the key every trigger API takes.
     if (isTrigger)
         operation.eventOperation = pyOr(contextValue(context, "operation"), "");
-    if (isTrigger && truthy(get(node, "eventMode")))
+    if (isTrigger && pyTruthy(get(node, "eventMode")))
         operation.eventMode = pyOr(get(node, "eventMode"), "");
     const entry = {
         schemaVersion: ctx.schemaVersion ?? SCHEMA_VERSION,
@@ -292,14 +292,14 @@ export function extractCanonical(nodeData, ctx = {}) {
     // Some operations resolve their real field set from the VALUES of a few
     // parent fields; record what a caller has to do about it.
     const action = schemaAction(cmi, inputFields);
-    if (truthy(action))
+    if (pyTruthy(action))
         operation.schemaAction = action;
     const tableKey = curatedKey(get(config, "connectorKey", ""), get(config, "objectName", ""));
     const dispatchStyle = (ctx.dispatchStyles ?? CURATED_DISPATCH_STYLE).get(tableKey);
-    if (truthy(dispatchStyle))
+    if (pyTruthy(dispatchStyle))
         operation.dispatchStyle = dispatchStyle;
     const paramGrammars = (ctx.paramGrammars ?? CURATED_PARAM_GRAMMARS).get(tableKey);
-    if (truthy(paramGrammars))
+    if (pyTruthy(paramGrammars))
         operation.paramGrammars = paramGrammars;
     return entry;
 }
@@ -316,7 +316,7 @@ export function asBool(value) {
 }
 /** Read the connector tier across CLI response casing variants. */
 export function connectorTier(record) {
-    if (!isRecord(record))
+    if (!isPyDict(record))
         return null;
     let value = get(record, "Tier");
     if (value === null)
@@ -355,11 +355,11 @@ export function filterNodeTypesByTier(nodeTypes, connectorRecords, tier) {
 }
 /** `merge_connector_record`: stamp connector discovery metadata and its derived flag. */
 export function mergeConnectorRecord(entry, record) {
-    if (!truthy(record))
+    if (!pyTruthy(record))
         return entry;
     const connector = entry.connector;
     const name = get(record, "Name");
-    if (truthy(name))
+    if (pyTruthy(name))
         connector.name = name;
     const tier = connectorTier(record);
     if (tier !== null)
@@ -372,7 +372,7 @@ export function mergeConnectorRecord(entry, record) {
         hasCustomFieldDiscovery: asBool(get(record, "HasCustomFieldDiscovery")),
     };
     connector.discovery = discovery;
-    entry.runtime.requiresConnectionForSchema = Object.entries(discovery).some(([key, value]) => key !== "type" && truthy(value));
+    entry.runtime.requiresConnectionForSchema = Object.entries(discovery).some(([key, value]) => key !== "type" && pyTruthy(value));
     return entry;
 }
 // ---------------------------------------------------------------------------
@@ -489,7 +489,7 @@ export function toLowerCamel(s) {
  * uses camelCase, so the on-disk schema stays stable across CLI versions.
  */
 export function normalizeFieldKeys(value) {
-    if (isRecord(value)) {
+    if (isPyDict(value)) {
         const out = {};
         for (const [k, v] of Object.entries(value))
             out[toLowerCamel(k)] = normalizeFieldKeys(v);
@@ -501,7 +501,7 @@ export function normalizeFieldKeys(value) {
 }
 /** `_pick`: the first non-None value among `d[k]` for the given keys, else `null`. */
 export function pick(d, ...keys) {
-    if (!isRecord(d))
+    if (!isPyDict(d))
         return null;
     for (const k of keys) {
         const v = d[k];

package/dist/registry/library-build/context.js

@@ -19,7 +19,7 @@ import { sortedByKeys } from "../compat/compare.js";
 import { isConnectorsMetadata, isResourcesDescribeObject, isResourcesDescribeOperation, isResourcesList as isResourcesListArgv, registryGet as registryGetArgv, } from "../uip/commands.js";
 import { CACHED_FAILURE, isCachedFailure, safeCacheName } from "../uip/response-cache.js";
 import { failureReason, isNodeNotFound } from "../uip/envelope.js";
-import { get, isRecord, pyOr, truthy } from "./py.js";
+import { get, isPyDict, pyOr, pyTruthy } from "./py.js";
 export function createBuildContext(ports, scope = {}) {
     const parentFields = scope.parentFields instanceof Map
         ? new Map(scope.parentFields)
@@ -111,7 +111,7 @@ function cacheNameOf(...parts) {
 }
 /** `payload.get("Result")` on something that is not a dict raises in Python. */
 function envelope(payload) {
-    if (!isRecord(payload))
+    if (!isPyDict(payload))
         throw new TypeError(`'${Array.isArray(payload) ? "list" : typeof payload}' object has no attribute 'get'`);
     return payload;
 }
@@ -174,7 +174,7 @@ export async function isDescribeOperation(ctx, connectorKey, objectName, operati
         const cached = ctx.caches.is.read(name);
         if (isCachedFailure(cached))
             noteFailedFieldDescribe(ctx, connectorKey, objectName, operation, get(cached, "Message"));
-        return isRecord(cached) && cached.Data !== undefined ? cached.Data : undefined;
+        return isPyDict(cached) && cached.Data !== undefined ? cached.Data : undefined;
     }
     const result = await runUip(ctx, isResourcesDescribeOperation(connectorKey, objectName, operation, ctx.connectionId, ctx.parentFields));
     if (refused(result))
@@ -199,7 +199,7 @@ export async function isDescribeObject(ctx, connectorKey, objectName) {
     const name = cacheNameOf(schemaCacheScope(ctx), connectorKey, objectName, "_operations");
     if (ctx.caches.is.has(name)) {
         const cached = ctx.caches.is.read(name);
-        return isRecord(cached) && cached.Data !== undefined ? cached.Data : undefined;
+        return isPyDict(cached) && cached.Data !== undefined ? cached.Data : undefined;
     }
     const result = await runUip(ctx, isResourcesDescribeObject(connectorKey, objectName, ctx.connectionId));
     if (refused(result))
@@ -233,7 +233,7 @@ export async function isResourcesList(ctx, connectorKey, options = {}) {
         return Array.isArray(data) ? data : undefined;
     }
     const result = await runUip(ctx, isResourcesListArgv(connectorKey, {
-        ...(truthy(operation) ? { operation } : {}),
+        ...(pyTruthy(operation) ? { operation } : {}),
         ...(options.refresh ? { refresh: true } : {}),
         connectionId: ctx.connectionId,
     }));