@uipath/maestro-builder-sdk 6.4.0 → 6.5.0

package/dist/registry/codecs/pyjson.d.ts

@@ -0,0 +1,62 @@
+/**
+ * A JSON writer with the exact output of Python's `json.dumps`.
+ *
+ * The connector library the Azure pipeline publishes, the overlay `prepare`
+ * writes into a project, and the string literals inside every generated
+ * descriptor module were all produced by `json.dumps`. Its defaults differ from
+ * `JSON.stringify` in ways that change bytes, and the library's sha256 is
+ * published precisely so an unchanged refresh is a no-op:
+ *
+ *   - `ensure_ascii=True` escapes every character outside `0x20..0x7e` as a
+ *     lowercase `\uXXXX`, astral characters as two surrogate escapes. 1,651 of
+ *     the 16,082 files in a current library carry such escapes.
+ *   - with `indent`, the item separator is `,` + newline and the key separator
+ *     is `: `; without, they are `, ` and `: ` — not `JSON.stringify`'s `,`/`:`.
+ *   - `sort_keys` orders by code point, not by UTF-16 code unit.
+ *   - a float prints as Python's `repr`: `1e-05`, `1e+16`, `2.5`, never `1e-5`.
+ *
+ * Everything the registry writes goes through this module, so the byte question
+ * is answered in one place and proven by one test: parse every library file,
+ * format it again, require the same bytes.
+ */
+export interface PyJsonOptions {
+    /** Spaces per level, as `json.dumps(indent=n)`. `undefined` means compact. */
+    indent?: number;
+    /** `json.dumps(sort_keys=True)`: keys ordered by code point at every level. */
+    sortKeys?: boolean;
+    /** `json.dumps(ensure_ascii=…)`; Python's default is `true`. */
+    ensureAscii?: boolean;
+    /**
+     * `json.dumps(separators=(item, key))`. Defaults follow Python: `(", ", ": ")`
+     * when compact, `(",", ": ")` when indented.
+     */
+    separators?: readonly [string, string];
+    /**
+     * Plain objects whose keys look like integers are refused, because
+     * `JSON.parse` and object literals both hoist such keys to the front in
+     * numeric order, so their insertion order is already lost. Pass a `Map` to
+     * carry an explicit order, or set this to accept the hoisted order knowingly.
+     */
+    allowIntegerKeys?: boolean;
+}
+/** Python `str` comparison: by Unicode code point, not UTF-16 code unit. */
+export declare function compareCodePoints(a: string, b: string): number;
+/** `repr(float)` for a JavaScript number that is not an integer. */
+export declare function pyFloatRepr(x: number): string;
+/** `json.dumps(str)`: the quoted, escaped form of one string. */
+export declare function pyJsonString(s: string, ensureAscii?: boolean): string;
+/**
+ * `json.dumps(value, **options)`.
+ *
+ * `undefined` values inside arrays become `null` (as `JSON.stringify` does);
+ * `undefined` object properties are omitted, matching the usual TypeScript
+ * habit of optional fields. Python has no `undefined`, so neither choice can
+ * disagree with it — but a `Map` may hold `undefined` deliberately and is
+ * written as `null` there, so prefer omitting keys over storing `undefined`.
+ */
+export declare function pyJsonStringify(value: unknown, options?: PyJsonOptions): string;
+/**
+ * `json.dump(value, file, indent=2)` followed by `file.write("\n")` — the
+ * shape every library entry, sidecar and index is written in.
+ */
+export declare function pyJsonDocument(value: unknown, options?: PyJsonOptions): string;

package/dist/registry/codecs/pyjson.js

@@ -0,0 +1,208 @@
+/**
+ * A JSON writer with the exact output of Python's `json.dumps`.
+ *
+ * The connector library the Azure pipeline publishes, the overlay `prepare`
+ * writes into a project, and the string literals inside every generated
+ * descriptor module were all produced by `json.dumps`. Its defaults differ from
+ * `JSON.stringify` in ways that change bytes, and the library's sha256 is
+ * published precisely so an unchanged refresh is a no-op:
+ *
+ *   - `ensure_ascii=True` escapes every character outside `0x20..0x7e` as a
+ *     lowercase `\uXXXX`, astral characters as two surrogate escapes. 1,651 of
+ *     the 16,082 files in a current library carry such escapes.
+ *   - with `indent`, the item separator is `,` + newline and the key separator
+ *     is `: `; without, they are `, ` and `: ` — not `JSON.stringify`'s `,`/`:`.
+ *   - `sort_keys` orders by code point, not by UTF-16 code unit.
+ *   - a float prints as Python's `repr`: `1e-05`, `1e+16`, `2.5`, never `1e-5`.
+ *
+ * Everything the registry writes goes through this module, so the byte question
+ * is answered in one place and proven by one test: parse every library file,
+ * format it again, require the same bytes.
+ */
+const INTEGER_LIKE = /^(?:0|[1-9][0-9]*)$/;
+/** Python `str` comparison: by Unicode code point, not UTF-16 code unit. */
+export function compareCodePoints(a, b) {
+    const ai = a[Symbol.iterator]();
+    const bi = b[Symbol.iterator]();
+    for (;;) {
+        const x = ai.next();
+        const y = bi.next();
+        if (x.done && y.done)
+            return 0;
+        if (x.done)
+            return -1;
+        if (y.done)
+            return 1;
+        const cx = x.value.codePointAt(0);
+        const cy = y.value.codePointAt(0);
+        if (cx !== cy)
+            return cx < cy ? -1 : 1;
+    }
+}
+/** `repr(float)` for a JavaScript number that is not an integer. */
+export function pyFloatRepr(x) {
+    if (Number.isNaN(x))
+        return "NaN";
+    if (x === Infinity)
+        return "Infinity";
+    if (x === -Infinity)
+        return "-Infinity";
+    if (x === 0)
+        return Object.is(x, -0) ? "-0.0" : "0.0";
+    const negative = x < 0;
+    // `toExponential()` with no argument yields the shortest digit string that
+    // round-trips, which is the same digit string Python's `repr` starts from.
+    const match = /^(\d)(?:\.(\d+))?e([+-]\d+)$/.exec(Math.abs(x).toExponential());
+    if (!match)
+        return String(x);
+    const digits = (match[1] + (match[2] ?? "")).replace(/0+$/, "") || "0";
+    const decimalPoint = parseInt(match[3], 10) + 1; // value = 0.<digits> × 10^decimalPoint
+    let body;
+    if (decimalPoint <= -4 || decimalPoint > 16) {
+        const mantissa = digits.length > 1 ? `${digits[0]}.${digits.slice(1)}` : digits;
+        const exponent = decimalPoint - 1;
+        body = `${mantissa}e${exponent < 0 ? "-" : "+"}${String(Math.abs(exponent)).padStart(2, "0")}`;
+    }
+    else if (decimalPoint <= 0) {
+        body = `0.${"0".repeat(-decimalPoint)}${digits}`;
+    }
+    else if (decimalPoint >= digits.length) {
+        body = `${digits}${"0".repeat(decimalPoint - digits.length)}.0`;
+    }
+    else {
+        body = `${digits.slice(0, decimalPoint)}.${digits.slice(decimalPoint)}`;
+    }
+    return negative ? `-${body}` : body;
+}
+function formatNumber(n) {
+    if (Number.isInteger(n) && !Object.is(n, -0)) {
+        // Python prints every digit of an int; JS switches to exponent form at 1e21.
+        return Math.abs(n) < 1e21 ? String(n) : BigInt(n).toString();
+    }
+    return pyFloatRepr(n);
+}
+const SHORT_ESCAPES = {
+    '"': '\\"',
+    "\\": "\\\\",
+    "\n": "\\n",
+    "\r": "\\r",
+    "\t": "\\t",
+    "\b": "\\b",
+    "\f": "\\f",
+};
+function hex4(unit) {
+    return `\\u${unit.toString(16).padStart(4, "0")}`;
+}
+/** `json.dumps(str)`: the quoted, escaped form of one string. */
+export function pyJsonString(s, ensureAscii = true) {
+    // Indexing a number or an object by position finds nothing and the loop
+    // below would answer `""` — an unquoted nothing in the middle of a generated
+    // module — where `json.dumps(5)` writes `5`. Callers with a non-string want
+    // `pyJsonStringify`; this one is for strings only, and says so.
+    if (typeof s !== "string") {
+        throw new TypeError(`pyJsonString: expected a string, got ${s === null ? "null" : typeof s}`);
+    }
+    let out = '"';
+    for (let i = 0; i < s.length; i++) {
+        const ch = s[i];
+        const short = SHORT_ESCAPES[ch];
+        if (short !== undefined) {
+            out += short;
+            continue;
+        }
+        const unit = s.charCodeAt(i);
+        if (unit < 0x20) {
+            out += hex4(unit);
+        }
+        else if (ensureAscii && unit > 0x7e) {
+            // Astral characters are two UTF-16 units and Python escapes them as the
+            // two surrogates, so escaping unit by unit is exactly right.
+            out += hex4(unit);
+        }
+        else {
+            out += ch;
+        }
+    }
+    return out + '"';
+}
+function entriesOf(value, options) {
+    let entries;
+    if (value instanceof Map) {
+        entries = [];
+        for (const [key, v] of value) {
+            if (typeof key !== "string") {
+                throw new TypeError(`pyjson: Map keys must be strings, got ${typeof key}`);
+            }
+            entries.push([key, v]);
+        }
+    }
+    else {
+        entries = Object.entries(value);
+        if (!options.allowIntegerKeys) {
+            const hoisted = entries.find(([key]) => INTEGER_LIKE.test(key));
+            if (hoisted) {
+                throw new TypeError(`pyjson: object key "${hoisted[0]}" looks like an integer, so JavaScript has ` +
+                    "already moved it to the front; carry the object as a Map to keep its order, " +
+                    "or pass allowIntegerKeys to accept the hoisted order.");
+            }
+        }
+    }
+    if (options.sortKeys) {
+        entries = [...entries].sort((a, b) => compareCodePoints(a[0], b[0]));
+    }
+    return entries;
+}
+/**
+ * `json.dumps(value, **options)`.
+ *
+ * `undefined` values inside arrays become `null` (as `JSON.stringify` does);
+ * `undefined` object properties are omitted, matching the usual TypeScript
+ * habit of optional fields. Python has no `undefined`, so neither choice can
+ * disagree with it — but a `Map` may hold `undefined` deliberately and is
+ * written as `null` there, so prefer omitting keys over storing `undefined`.
+ */
+export function pyJsonStringify(value, options = {}) {
+    const indent = options.indent;
+    const ensureAscii = options.ensureAscii ?? true;
+    const [itemSeparator, keySeparator] = options.separators ?? (indent === undefined ? [", ", ": "] : [",", ": "]);
+    const write = (v, depth) => {
+        if (v === null || v === undefined)
+            return "null";
+        switch (typeof v) {
+            case "string":
+                return pyJsonString(v, ensureAscii);
+            case "number":
+                return formatNumber(v);
+            case "boolean":
+                return v ? "true" : "false";
+            case "bigint":
+                return v.toString();
+            case "object":
+                break;
+            default:
+                throw new TypeError(`pyjson: cannot serialize a ${typeof v}`);
+        }
+        const inner = indent === undefined ? "" : `\n${" ".repeat(indent * (depth + 1))}`;
+        const closing = indent === undefined ? "" : `\n${" ".repeat(indent * depth)}`;
+        if (Array.isArray(v)) {
+            if (v.length === 0)
+                return "[]";
+            return `[${inner}${v.map((item) => write(item, depth + 1)).join(itemSeparator + inner)}${closing}]`;
+        }
+        const entries = entriesOf(v, options).filter(([, item]) => item !== undefined || v instanceof Map);
+        if (entries.length === 0)
+            return "{}";
+        const body = entries
+            .map(([key, item]) => `${pyJsonString(key, ensureAscii)}${keySeparator}${write(item, depth + 1)}`)
+            .join(itemSeparator + inner);
+        return `{${inner}${body}${closing}}`;
+    };
+    return write(value, 0);
+}
+/**
+ * `json.dump(value, file, indent=2)` followed by `file.write("\n")` — the
+ * shape every library entry, sidecar and index is written in.
+ */
+export function pyJsonDocument(value, options = {}) {
+    return `${pyJsonStringify(value, { indent: 2, ...options })}\n`;
+}

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

@@ -0,0 +1,18 @@
+/**
+ * Orderings that must match Python's `sorted()`.
+ *
+ * Python compares strings by code point and tuples element by element;
+ * `Array.prototype.sort` with no comparator compares UTF-16 code units of the
+ * stringified value. The two agree on ASCII and disagree above U+FFFF, which is
+ * why every sort that decides output bytes goes through one of these.
+ */
+export { compareCodePoints } from "../codecs/pyjson.js";
+/** A stable sort by one string key, code-point ordered. */
+export declare function sortedByCodePoint<T>(items: readonly T[], key: (item: T) => string): T[];
+/**
+ * `sorted(items, key=lambda x: (k1(x), k2(x), …))`: compare the first key, then
+ * the next, each by code point. Stable, like Python's.
+ */
+export declare function sortedByKeys<T>(items: readonly T[], ...keys: Array<(item: T) => string>): T[];
+/** `sorted(strings)`. */
+export declare function sortedStrings(items: Iterable<string>): string[];

package/dist/registry/compat/compare.js

@@ -0,0 +1,32 @@
+/**
+ * Orderings that must match Python's `sorted()`.
+ *
+ * Python compares strings by code point and tuples element by element;
+ * `Array.prototype.sort` with no comparator compares UTF-16 code units of the
+ * stringified value. The two agree on ASCII and disagree above U+FFFF, which is
+ * why every sort that decides output bytes goes through one of these.
+ */
+export { compareCodePoints } from "../codecs/pyjson.js";
+import { compareCodePoints } from "../codecs/pyjson.js";
+/** A stable sort by one string key, code-point ordered. */
+export function sortedByCodePoint(items, key) {
+    return [...items].sort((a, b) => compareCodePoints(key(a), key(b)));
+}
+/**
+ * `sorted(items, key=lambda x: (k1(x), k2(x), …))`: compare the first key, then
+ * the next, each by code point. Stable, like Python's.
+ */
+export function sortedByKeys(items, ...keys) {
+    return [...items].sort((a, b) => {
+        for (const key of keys) {
+            const c = compareCodePoints(key(a), key(b));
+            if (c !== 0)
+                return c;
+        }
+        return 0;
+    });
+}
+/** `sorted(strings)`. */
+export function sortedStrings(items) {
+    return [...items].sort(compareCodePoints);
+}

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

@@ -0,0 +1,4 @@
+/** Replace the platform separator with `/`. */
+export declare function toPosix(p: string): string;
+/** `os.path.relpath(target, base)` spelled with `/`. */
+export declare function relativePosix(base: string, target: string): string;

package/dist/registry/compat/paths.js

@@ -0,0 +1,17 @@
+/**
+ * Path spelling for values that land inside files.
+ *
+ * `index.json` rows carry `path`, and the overlay index carries
+ * `descriptors/<key>/…`. Both are read as `/`-separated by every consumer, so
+ * they are forced to POSIX here regardless of the host, where Python's
+ * `os.path.relpath` would have used the OS separator.
+ */
+import { relative, sep } from "node:path";
+/** Replace the platform separator with `/`. */
+export function toPosix(p) {
+    return sep === "/" ? p : p.split(sep).join("/");
+}
+/** `os.path.relpath(target, base)` spelled with `/`. */
+export function relativePosix(base, target) {
+    return toPosix(relative(base, target));
+}

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

@@ -0,0 +1,50 @@
+/** `str.strip()` with no argument. */
+export declare function pyStrip(s: string): string;
+/** `str.rstrip()` with no argument. */
+export declare function pyRstrip(s: string): string;
+/** `str.strip(chars)`: strip any of the given characters from both ends. */
+export declare function pyStripChars(s: string, chars: string): string;
+/**
+ * `str(value)` for the JSON-shaped values the generators coerce: `True`,
+ * `None`, `1.0`, never `true`, `null`, `1`.
+ */
+export declare function pyStr(value: unknown): string;
+/**
+ * `str.title()`: each character after a non-cased one (or at the start) is
+ * titlecased, every other one lowercased — so digits and apostrophes start a
+ * new word (`"a1b"` → `"A1B"`, `"o'brien"` → `"O'Brien"`), unlike a
+ * split-on-space capitaliser, and a capital sigma ending a word becomes `ς`
+ * (`"ΟΔΟΣ"` → `"Οδος"`).
+ *
+ * Checked against CPython 3.13 (Unicode 15.1) over all 1,112,064 code points,
+ * each as `chr(cp)` — which exercises the titlecase branch — and again as
+ * `"A" + chr(cp)`, `"AΣ" + chr(cp)` and `chr(cp) + "Σ"`, which exercise the
+ * lowercase branch and the final-sigma rule in both directions. Every
+ * disagreement was a code point Node's ICU 16 cases and Unicode 15.1 does not:
+ * U+019B, U+0264, U+1C89, U+1C8A, U+A7CB–A7CD, U+A7DA–A7DC and the Garay block
+ * (U+10D50–10D65, U+10D70–10D85) — 54 code points in total. So this matches
+ * `str.title()` exactly on the repertoire the two share, and an engine newer
+ * than the Python it is compared with will case a handful of letters Python
+ * leaves alone.
+ *
+ * None of the 54 appears in the committed library's slugs, labels or field
+ * names, which is where it matters — but that is an observation about how the
+ * registry names things today, not a rule anything enforces, so a future
+ * connector could in principle carry one. The curated cases that guard the
+ * behaviour are in `registry-compat.test.ts`, via the fixture Python wrote.
+ */
+export declare function pyTitle(s: string): string;
+/** `s[:1].isupper()`: the first code point is an uppercase letter. */
+export declare function startsWithUpper(s: string): boolean;
+/** `s[:1].upper() + s[1:]`, slicing by code point. */
+export declare function upperFirst(s: string): string;
+/** `s[:1].lower() + s[1:]`, slicing by code point. */
+export declare function lowerFirst(s: string): string;
+/** `s.rsplit(sep, 1)[-1]`. */
+export declare function afterLast(s: string, sep: string): string;
+/** `s.rsplit(sep, 1)[0]` when `sep` occurs, else `s`. */
+export declare function beforeLast(s: string, sep: string): string;
+/** `s.split(sep, 1)` as a pair; the second element is `undefined` when absent. */
+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;

package/dist/registry/compat/pystr.js

@@ -0,0 +1,221 @@
+/**
+ * The few string operations that must behave like Python's, because their
+ * result reaches a file the Python generators used to write.
+ *
+ * Everything else in the registry is ordinary TypeScript. This module exists
+ * so the places where JavaScript and Python disagree — `strip()`'s whitespace
+ * set, `str()` of a bool, `title()` after a digit, slicing by code point — are
+ * spelled once and tested against a table Python itself produced
+ * (`typescript/tests/fixtures/registry/pycompat.json`).
+ */
+import { pyFloatRepr } from "../codecs/pyjson.js";
+/**
+ * Characters `str.isspace()` is true for. Not the same set as JavaScript's
+ * `\s`: Python includes the C1 separators `\x1c`–`\x1f` and `\x85`, and
+ * excludes the BOM ``.
+ */
+const PY_SPACE = "\t\n\u000b\u000c\r\u001c\u001d\u001e\u001f \u0085\u00a0\u1680" +
+    "\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a" +
+    "\u2028\u2029\u202f\u205f\u3000";
+function isPySpace(ch) {
+    return PY_SPACE.includes(ch);
+}
+/** `str.strip()` with no argument. */
+export function pyStrip(s) {
+    let start = 0;
+    let end = s.length;
+    while (start < end && isPySpace(s[start]))
+        start++;
+    while (end > start && isPySpace(s[end - 1]))
+        end--;
+    return s.slice(start, end);
+}
+/** `str.rstrip()` with no argument. */
+export function pyRstrip(s) {
+    let end = s.length;
+    while (end > 0 && isPySpace(s[end - 1]))
+        end--;
+    return s.slice(0, end);
+}
+/** `str.strip(chars)`: strip any of the given characters from both ends. */
+export function pyStripChars(s, chars) {
+    let start = 0;
+    let end = s.length;
+    while (start < end && chars.includes(s[start]))
+        start++;
+    while (end > start && chars.includes(s[end - 1]))
+        end--;
+    return s.slice(start, end);
+}
+/**
+ * `str(value)` for the JSON-shaped values the generators coerce: `True`,
+ * `None`, `1.0`, never `true`, `null`, `1`.
+ */
+export function pyStr(value) {
+    if (value === null || value === undefined)
+        return "None";
+    if (typeof value === "boolean")
+        return value ? "True" : "False";
+    if (typeof value === "number") {
+        return Number.isInteger(value) && !Object.is(value, -0) ? String(value) : pyFloatRepr(value);
+    }
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "bigint")
+        return value.toString();
+    // Python would print a repr of a dict or list here; the generators never do
+    // that on purpose, so make it loud rather than plausible.
+    throw new TypeError(`pyStr: refusing to stringify a ${Array.isArray(value) ? "list" : typeof value}`);
+}
+const UPPER = /\p{Lu}/u;
+/**
+ * `str.title()`'s word-boundary test is the Unicode `Cased` property, not "a
+ * letter with a case category": a modifier letter such as `ʰ`, a circled `Ⓐ`
+ * or a Roman numeral `ⅷ` is cased and continues a word, while the apostrophe
+ * `ʼ` in `ʼn`'s titlecase is not and starts one.
+ */
+const CASED = /\p{Cased}/u;
+/** `Case_Ignorable`: what the final-sigma rule looks past on either side. */
+const CASE_IGNORABLE = /\p{Case_Ignorable}/u;
+const TITLECASE_LETTER = /\p{Lt}/u;
+/**
+ * Code points whose titlecase is neither themselves nor their `toUpperCase()`,
+ * from Unicode 15.1 (CPython 3.13). `ß` and the ligatures titlecase to a
+ * capital followed by lowercase, the digraphs to their dedicated titlecase
+ * code point, and the Greek forms with iota subscript to the base capital plus
+ * COMBINING GREEK YPOGEGRAMMENI (U+0345), where uppercasing gives a full
+ * capital iota instead. (`ʼn` → `ʼN` and `ǰ` → `J̌` are NOT here: there the
+ * titlecase equals the uppercase, which `toUpperCase()` already spells.)
+ */
+const TITLECASE_SPECIAL = new Map([
+    ["ß", "Ss"],
+    ["DŽ", "Dž"], ["dž", "Dž"], ["LJ", "Lj"], ["lj", "Lj"], ["NJ", "Nj"], ["nj", "Nj"], ["DZ", "Dz"], ["dz", "Dz"],
+    ["և", "Եւ"],
+    ["ᾲ", "Ὰͅ"], ["ᾳ", "ᾼ"], ["ᾴ", "Άͅ"], ["ᾷ", "ᾼ͂"],
+    ["ῂ", "Ὴͅ"], ["ῃ", "ῌ"], ["ῄ", "Ήͅ"], ["ῇ", "ῌ͂"],
+    ["ῲ", "Ὼͅ"], ["ῳ", "ῼ"], ["ῴ", "Ώͅ"], ["ῷ", "ῼ͂"],
+    ["ff", "Ff"], ["fi", "Fi"], ["fl", "Fl"], ["ffi", "Ffi"], ["ffl", "Ffl"], ["ſt", "St"], ["st", "St"],
+    ["ﬓ", "Մն"], ["ﬔ", "Մե"], ["ﬕ", "Մի"], ["ﬖ", "Վն"], ["ﬗ", "Մխ"],
+]);
+/**
+ * `_PyUnicode_ToTitleFull`: Python's titlecase of one code point, which
+ * JavaScript lacks. UnicodeData gives most code points no titlecase of their
+ * own, in which case it is their uppercase — and `toUpperCase()` already
+ * applies SpecialCasing there — so only the exceptions need spelling: a
+ * titlecase letter is its own titlecase; Georgian Mkhedruli titlecases to
+ * itself although it uppercases to Mtavruli; the Greek small letters with
+ * iota subscript (`ᾀ`…`ᾧ`) titlecase to the titlecase letter eight code points
+ * up; and the table above.
+ */
+function titlecaseChar(ch) {
+    const special = TITLECASE_SPECIAL.get(ch);
+    if (special !== undefined)
+        return special;
+    if (TITLECASE_LETTER.test(ch))
+        return ch;
+    const cp = ch.codePointAt(0);
+    if (cp >= 0x10d0 && cp <= 0x10ff)
+        return ch;
+    if ((cp >= 0x1f80 && cp <= 0x1f87) || (cp >= 0x1f90 && cp <= 0x1f97) || (cp >= 0x1fa0 && cp <= 0x1fa7)) {
+        return String.fromCodePoint(cp + 8);
+    }
+    return ch.toUpperCase();
+}
+/**
+ * Whether the `Σ` at `chars[i]` is in Final_Sigma context: preceded, past any
+ * case-ignorables, by a cased character, and not followed, past any
+ * case-ignorables, by one. CPython applies this inside `title()` and `lower()`;
+ * `toLowerCase()` applies it only when given the whole string, which lowering
+ * one character at a time forfeits.
+ */
+function isFinalSigma(chars, i) {
+    let j = i - 1;
+    while (j >= 0 && CASE_IGNORABLE.test(chars[j]))
+        j--;
+    if (j < 0 || !CASED.test(chars[j]))
+        return false;
+    j = i + 1;
+    while (j < chars.length && CASE_IGNORABLE.test(chars[j]))
+        j++;
+    return j === chars.length || !CASED.test(chars[j]);
+}
+/**
+ * `str.title()`: each character after a non-cased one (or at the start) is
+ * titlecased, every other one lowercased — so digits and apostrophes start a
+ * new word (`"a1b"` → `"A1B"`, `"o'brien"` → `"O'Brien"`), unlike a
+ * split-on-space capitaliser, and a capital sigma ending a word becomes `ς`
+ * (`"ΟΔΟΣ"` → `"Οδος"`).
+ *
+ * Checked against CPython 3.13 (Unicode 15.1) over all 1,112,064 code points,
+ * each as `chr(cp)` — which exercises the titlecase branch — and again as
+ * `"A" + chr(cp)`, `"AΣ" + chr(cp)` and `chr(cp) + "Σ"`, which exercise the
+ * lowercase branch and the final-sigma rule in both directions. Every
+ * disagreement was a code point Node's ICU 16 cases and Unicode 15.1 does not:
+ * U+019B, U+0264, U+1C89, U+1C8A, U+A7CB–A7CD, U+A7DA–A7DC and the Garay block
+ * (U+10D50–10D65, U+10D70–10D85) — 54 code points in total. So this matches
+ * `str.title()` exactly on the repertoire the two share, and an engine newer
+ * than the Python it is compared with will case a handful of letters Python
+ * leaves alone.
+ *
+ * None of the 54 appears in the committed library's slugs, labels or field
+ * names, which is where it matters — but that is an observation about how the
+ * registry names things today, not a rule anything enforces, so a future
+ * connector could in principle carry one. The curated cases that guard the
+ * behaviour are in `registry-compat.test.ts`, via the fixture Python wrote.
+ */
+export function pyTitle(s) {
+    const chars = [...s];
+    let out = "";
+    let previousCased = false;
+    for (let i = 0; i < chars.length; i++) {
+        const ch = chars[i];
+        if (!previousCased)
+            out += titlecaseChar(ch);
+        else if (ch === "Σ")
+            out += isFinalSigma(chars, i) ? "ς" : "σ";
+        else
+            out += ch.toLowerCase();
+        previousCased = CASED.test(ch);
+    }
+    return out;
+}
+/** `s[:1].isupper()`: the first code point is an uppercase letter. */
+export function startsWithUpper(s) {
+    const first = s.codePointAt(0);
+    return first !== undefined && UPPER.test(String.fromCodePoint(first));
+}
+/** `s[:1].upper() + s[1:]`, slicing by code point. */
+export function upperFirst(s) {
+    const first = s.codePointAt(0);
+    if (first === undefined)
+        return s;
+    const head = String.fromCodePoint(first);
+    return head.toUpperCase() + s.slice(head.length);
+}
+/** `s[:1].lower() + s[1:]`, slicing by code point. */
+export function lowerFirst(s) {
+    const first = s.codePointAt(0);
+    if (first === undefined)
+        return s;
+    const head = String.fromCodePoint(first);
+    return head.toLowerCase() + s.slice(head.length);
+}
+/** `s.rsplit(sep, 1)[-1]`. */
+export function afterLast(s, sep) {
+    const at = s.lastIndexOf(sep);
+    return at < 0 ? s : s.slice(at + sep.length);
+}
+/** `s.rsplit(sep, 1)[0]` when `sep` occurs, else `s`. */
+export function beforeLast(s, sep) {
+    const at = s.lastIndexOf(sep);
+    return at < 0 ? s : s.slice(0, at);
+}
+/** `s.split(sep, 1)` as a pair; the second element is `undefined` when absent. */
+export function splitOnce(s, sep) {
+    const at = s.indexOf(sep);
+    return at < 0 ? [s, undefined] : [s.slice(0, at), s.slice(at + sep.length)];
+}
+/** `str.isdigit()` for ASCII digits, which is all the generators ever test. */
+export function isAsciiDigits(s) {
+    return /^[0-9]+$/.test(s);
+}

package/dist/registry/concurrency.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Bounded parallelism with results in input order.
+ *
+ * The library builder used seven thread pools; four of them appended results as
+ * they completed, so the order of expanded entries — and, on a tie, which of two
+ * colliding entries won — depended on scheduling. This helper runs at most
+ * `limit` tasks at once and always returns `results[i]` for `items[i]`, so the
+ * output of a build is a function of its inputs alone.
+ */
+export declare function mapConcurrent<T, R>(items: readonly T[], limit: number, fn: (item: T, index: number) => Promise<R>): Promise<R[]>;

package/dist/registry/concurrency.js

@@ -0,0 +1,34 @@
+/**
+ * Bounded parallelism with results in input order.
+ *
+ * The library builder used seven thread pools; four of them appended results as
+ * they completed, so the order of expanded entries — and, on a tie, which of two
+ * colliding entries won — depended on scheduling. This helper runs at most
+ * `limit` tasks at once and always returns `results[i]` for `items[i]`, so the
+ * output of a build is a function of its inputs alone.
+ */
+export async function mapConcurrent(items, limit, fn) {
+    // `ThreadPoolExecutor(max_workers=0)` raised `ValueError: max_workers must
+    // be greater than 0`, and so does this, even for no work: a limit that is
+    // not a positive number is a caller's mistake, and clamping it to one
+    // worker would turn a pipeline typo into a build that runs serially for
+    // hours instead of failing at once.
+    if (!(Number.isFinite(limit) && limit >= 1)) {
+        throw new RangeError(`mapConcurrent: limit must be a positive number, got ${limit}`);
+    }
+    const results = new Array(items.length);
+    if (items.length === 0)
+        return results;
+    const workers = Math.min(Math.floor(limit), items.length);
+    let next = 0;
+    const run = async () => {
+        for (;;) {
+            const index = next++;
+            if (index >= items.length)
+                return;
+            results[index] = await fn(items[index], index);
+        }
+    };
+    await Promise.all(Array.from({ length: workers }, run));
+    return results;
+}