@kernlang/core 3.5.9-canary.218.1.77aa9b0c → 4.0.0

package/dist/core-contracts/index.d.ts

@@ -0,0 +1,1032 @@
+export { BOOLEAN_CONTRACT } from './boolean.js';
+export { FUNCTION_CONTRACT } from './function.js';
+export { LIST_CONTRACT } from './list.js';
+export { NULL_CONTRACT, UNDEFINED_CONTRACT } from './nullish.js';
+export { NUMBER_CONTRACT } from './number.js';
+export { RECORD_CONTRACT } from './record.js';
+export type { CoreFixture, CoreFixtureError, CoreFixtureValue, CoreGraphEdge, CoreLowerings, CoreOperation, CoreOperationKind, CoreOperationReturns, CoreTypeContract, CoreTypeContractRegistry, CoreTypeKind, CoreTypeName, } from './schema.js';
+export { CORE_FIXTURE_FUNCTION, CORE_FIXTURE_UNDEFINED, CORE_TYPE_NAMES, contractToGraphEdges, isCoreFixtureFunction, isCoreFixtureUndefined, } from './schema.js';
+export { CoreContractEvaluationError, coreFixtureValueType, evaluateCoreContractOperation, } from './semantics.js';
+export { STRING_CONTRACT } from './string.js';
+export declare const CORE_TYPE_CONTRACTS: {
+    readonly schemaVersion: 1;
+    readonly types: {
+        readonly String: {
+            readonly name: "String";
+            readonly kind: "primitive";
+            readonly strict: true;
+            readonly operations: readonly [{
+                readonly id: "String.length";
+                readonly kind: "property";
+                readonly args: readonly ["String"];
+                readonly returns: "Number";
+                readonly lowers: {
+                    readonly kern: "String.length($0)";
+                    readonly ts: "__kernStringLength($0)";
+                    readonly python: "__kern_string_length($0)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly [""];
+                    readonly returns: 0;
+                }, {
+                    readonly args: readonly ["kern"];
+                    readonly returns: 4;
+                }, {
+                    readonly args: readonly ["𐐷"];
+                    readonly returns: 1;
+                }, {
+                    readonly args: readonly ["é"];
+                    readonly returns: 2;
+                }];
+                readonly review: {
+                    readonly summary: "KERN string length counts Unicode code points with no normalization.";
+                    readonly graph: readonly ["String", "Number", "portable", "unicode-code-point"];
+                };
+            }, {
+                readonly id: "String.index";
+                readonly kind: "method";
+                readonly args: readonly ["String", "Number"];
+                readonly returns: readonly ["String", "Undefined"];
+                readonly lowers: {
+                    readonly kern: "String.index($0, $1)";
+                    readonly ts: "__kernStringIndex($0, $1)";
+                    readonly python: "__kern_string_index($0, $1)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly ["abc", 1];
+                    readonly returns: "b";
+                }, {
+                    readonly args: readonly ["a𐐷b", 1];
+                    readonly returns: "𐐷";
+                }, {
+                    readonly args: readonly ["abc", 4];
+                    readonly returns: {
+                        readonly __kernFixture: "Undefined";
+                    };
+                }, {
+                    readonly args: readonly ["abc", -1];
+                    readonly returns: {
+                        readonly __kernFixture: "Undefined";
+                    };
+                }, {
+                    readonly args: readonly ["abc", 1.2];
+                    readonly returns: {
+                        readonly __kernFixture: "Undefined";
+                    };
+                }, {
+                    readonly args: readonly ["abc", "1"];
+                    readonly throws: {
+                        readonly code: "strict-type";
+                        readonly message: "String.index expects String, Number.";
+                    };
+                }];
+                readonly review: {
+                    readonly summary: "Strict string indexing over Unicode code-point offsets; negative, fractional, and out-of-range misses return Undefined.";
+                    readonly graph: readonly ["String", "Undefined", "strict", "portable", "unicode-code-point"];
+                };
+            }, {
+                readonly id: "String.includes";
+                readonly kind: "method";
+                readonly args: readonly ["String", "String"];
+                readonly returns: "Boolean";
+                readonly lowers: {
+                    readonly kern: "String.includes($0, $1)";
+                    readonly ts: "__kernStringIncludes($0, $1)";
+                    readonly python: "__kern_string_includes($0, $1)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly ["abc", "b"];
+                    readonly returns: true;
+                }, {
+                    readonly args: readonly ["abc", "x"];
+                    readonly returns: false;
+                }];
+                readonly review: {
+                    readonly summary: "Strict string containment.";
+                    readonly graph: readonly ["String", "Boolean", "portable"];
+                };
+            }, {
+                readonly id: "String.startsWith";
+                readonly kind: "method";
+                readonly args: readonly ["String", "String"];
+                readonly returns: "Boolean";
+                readonly lowers: {
+                    readonly kern: "String.startsWith($0, $1)";
+                    readonly ts: "__kernStringStartsWith($0, $1)";
+                    readonly python: "__kern_string_starts_with($0, $1)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly ["kern", "ke"];
+                    readonly returns: true;
+                }, {
+                    readonly args: readonly ["kern", "rn"];
+                    readonly returns: false;
+                }];
+                readonly review: {
+                    readonly summary: "Strict string prefix test.";
+                    readonly graph: readonly ["String", "Boolean", "portable"];
+                };
+            }, {
+                readonly id: "String.endsWith";
+                readonly kind: "method";
+                readonly args: readonly ["String", "String"];
+                readonly returns: "Boolean";
+                readonly lowers: {
+                    readonly kern: "String.endsWith($0, $1)";
+                    readonly ts: "__kernStringEndsWith($0, $1)";
+                    readonly python: "__kern_string_ends_with($0, $1)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly ["kern", "rn"];
+                    readonly returns: true;
+                }, {
+                    readonly args: readonly ["kern", "ke"];
+                    readonly returns: false;
+                }];
+                readonly review: {
+                    readonly summary: "Strict string suffix test.";
+                    readonly graph: readonly ["String", "Boolean", "portable"];
+                };
+            }, {
+                readonly id: "String.slice";
+                readonly kind: "method";
+                readonly args: readonly ["String", "Number", "Number"];
+                readonly returns: "String";
+                readonly lowers: {
+                    readonly kern: "String.slice($0, $1, $2)";
+                    readonly ts: "__kernStringSlice($0, $1, $2)";
+                    readonly python: "__kern_string_slice($0, $1, $2)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly ["abcdef", 1, 4];
+                    readonly returns: "bcd";
+                }, {
+                    readonly args: readonly ["abcdef", 1.9, 4.2];
+                    readonly returns: "bcd";
+                }, {
+                    readonly args: readonly ["abc", 0, 2];
+                    readonly returns: "ab";
+                }, {
+                    readonly args: readonly ["abcdef", -3, -1];
+                    readonly returns: "de";
+                }, {
+                    readonly args: readonly ["abcdef", -20, 2];
+                    readonly returns: "ab";
+                }, {
+                    readonly args: readonly ["abcdef", 4, 2];
+                    readonly returns: "";
+                }, {
+                    readonly args: readonly ["a𐐷b", 1, 2];
+                    readonly returns: "𐐷";
+                }, {
+                    readonly args: readonly ["éx", 0, 2];
+                    readonly returns: "é";
+                }, {
+                    readonly args: readonly ["abc", "0", 2];
+                    readonly throws: {
+                        readonly code: "strict-type";
+                        readonly message: "String.slice expects String, Number, Number.";
+                    };
+                }, {
+                    readonly args: readonly ["abc", 1];
+                    readonly throws: {
+                        readonly code: "strict-type";
+                        readonly message: "String.slice expects String, Number, Number.";
+                    };
+                }];
+                readonly review: {
+                    readonly summary: "Strict string slice over Unicode code-point offsets with explicit start and end offsets; negative offsets count from the end.";
+                    readonly graph: readonly ["String", "Number", "strict", "portable", "unicode-code-point"];
+                };
+            }, {
+                readonly id: "String.trim";
+                readonly kind: "method";
+                readonly args: readonly ["String"];
+                readonly returns: "String";
+                readonly lowers: {
+                    readonly kern: "String.trim($0)";
+                    readonly ts: "__kernStringTrim($0)";
+                    readonly python: "__kern_string_trim($0)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly ["  kern  "];
+                    readonly returns: "kern";
+                }, {
+                    readonly args: readonly ["\ncore\t"];
+                    readonly returns: "core";
+                }];
+                readonly review: {
+                    readonly summary: "Portable surrounding whitespace trim.";
+                    readonly graph: readonly ["String", "portable"];
+                };
+            }, {
+                readonly id: "String.lower";
+                readonly kind: "method";
+                readonly args: readonly ["String"];
+                readonly returns: "String";
+                readonly lowers: {
+                    readonly kern: "String.lower($0)";
+                    readonly ts: "__kernStringLower($0)";
+                    readonly python: "__kern_string_lower($0)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly ["KERN"];
+                    readonly returns: "kern";
+                }, {
+                    readonly args: readonly ["Core"];
+                    readonly returns: "core";
+                }];
+                readonly review: {
+                    readonly summary: "Portable lowercase conversion.";
+                    readonly graph: readonly ["String", "portable"];
+                };
+            }, {
+                readonly id: "String.upper";
+                readonly kind: "method";
+                readonly args: readonly ["String"];
+                readonly returns: "String";
+                readonly lowers: {
+                    readonly kern: "String.upper($0)";
+                    readonly ts: "__kernStringUpper($0)";
+                    readonly python: "__kern_string_upper($0)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly ["kern"];
+                    readonly returns: "KERN";
+                }, {
+                    readonly args: readonly ["Core"];
+                    readonly returns: "CORE";
+                }];
+                readonly review: {
+                    readonly summary: "Portable uppercase conversion.";
+                    readonly graph: readonly ["String", "portable"];
+                };
+            }, {
+                readonly id: "String.concat";
+                readonly kind: "method";
+                readonly args: readonly ["String", "String"];
+                readonly returns: "String";
+                readonly lowers: {
+                    readonly kern: "String.concat($0, $1)";
+                    readonly ts: "__kernStringConcat($0, $1)";
+                    readonly python: "__kern_string_concat($0, $1)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly ["kern", "lang"];
+                    readonly returns: "kernlang";
+                }, {
+                    readonly args: readonly ["count:", 2];
+                    readonly throws: {
+                        readonly code: "strict-type";
+                        readonly message: "String.concat expects String, String.";
+                    };
+                }];
+                readonly review: {
+                    readonly summary: "Strict string concatenation; both operands must be String.";
+                    readonly graph: readonly ["String", "strict", "portable"];
+                };
+            }, {
+                readonly id: "String.equals";
+                readonly kind: "method";
+                readonly args: readonly ["String", "String"];
+                readonly returns: "Boolean";
+                readonly lowers: {
+                    readonly kern: "String.equals($0, $1)";
+                    readonly ts: "__kernStringEquals($0, $1)";
+                    readonly python: "__kern_string_equals($0, $1)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly ["kern", "kern"];
+                    readonly returns: true;
+                }, {
+                    readonly args: readonly ["kern", "core"];
+                    readonly returns: false;
+                }, {
+                    readonly args: readonly ["kern", true];
+                    readonly throws: {
+                        readonly code: "strict-type";
+                        readonly message: "String.equals expects String, String.";
+                    };
+                }];
+                readonly review: {
+                    readonly summary: "Strict string equality; cross-type equality is a type error in schema v1.";
+                    readonly graph: readonly ["String", "Boolean", "strict", "portable"];
+                };
+            }, {
+                readonly id: "String.lessThan";
+                readonly kind: "operator";
+                readonly args: readonly ["String", "String"];
+                readonly returns: "Boolean";
+                readonly lowers: {
+                    readonly kern: "String.lessThan($0, $1)";
+                    readonly ts: "__kernStringLessThan($0, $1)";
+                    readonly python: "__kern_string_less_than($0, $1)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly ["abc", "abd"];
+                    readonly returns: true;
+                }, {
+                    readonly args: readonly ["abc", "abc"];
+                    readonly returns: false;
+                }, {
+                    readonly args: readonly ["abc", true];
+                    readonly throws: {
+                        readonly code: "strict-type";
+                        readonly message: "String.lessThan expects String, String.";
+                    };
+                }];
+                readonly review: {
+                    readonly summary: "Strict string less-than comparison using KERN portable code-point ordering.";
+                    readonly graph: readonly ["String", "Boolean", "strict", "portable", "unicode-code-point-order"];
+                };
+            }, {
+                readonly id: "String.lessThanOrEqual";
+                readonly kind: "operator";
+                readonly args: readonly ["String", "String"];
+                readonly returns: "Boolean";
+                readonly lowers: {
+                    readonly kern: "String.lessThanOrEqual($0, $1)";
+                    readonly ts: "__kernStringLessThanOrEqual($0, $1)";
+                    readonly python: "__kern_string_less_than_or_equal($0, $1)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly ["abc", "abc"];
+                    readonly returns: true;
+                }, {
+                    readonly args: readonly ["abd", "abc"];
+                    readonly returns: false;
+                }];
+                readonly review: {
+                    readonly summary: "Strict string less-than-or-equal comparison using KERN portable code-point ordering.";
+                    readonly graph: readonly ["String", "Boolean", "strict", "portable", "unicode-code-point-order"];
+                };
+            }, {
+                readonly id: "String.greaterThan";
+                readonly kind: "operator";
+                readonly args: readonly ["String", "String"];
+                readonly returns: "Boolean";
+                readonly lowers: {
+                    readonly kern: "String.greaterThan($0, $1)";
+                    readonly ts: "__kernStringGreaterThan($0, $1)";
+                    readonly python: "__kern_string_greater_than($0, $1)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly ["abd", "abc"];
+                    readonly returns: true;
+                }, {
+                    readonly args: readonly ["abc", "abc"];
+                    readonly returns: false;
+                }];
+                readonly review: {
+                    readonly summary: "Strict string greater-than comparison using KERN portable code-point ordering.";
+                    readonly graph: readonly ["String", "Boolean", "strict", "portable", "unicode-code-point-order"];
+                };
+            }, {
+                readonly id: "String.greaterThanOrEqual";
+                readonly kind: "operator";
+                readonly args: readonly ["String", "String"];
+                readonly returns: "Boolean";
+                readonly lowers: {
+                    readonly kern: "String.greaterThanOrEqual($0, $1)";
+                    readonly ts: "__kernStringGreaterThanOrEqual($0, $1)";
+                    readonly python: "__kern_string_greater_than_or_equal($0, $1)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly ["abc", "abc"];
+                    readonly returns: true;
+                }, {
+                    readonly args: readonly ["abc", "abd"];
+                    readonly returns: false;
+                }];
+                readonly review: {
+                    readonly summary: "Strict string greater-than-or-equal comparison using KERN portable code-point ordering.";
+                    readonly graph: readonly ["String", "Boolean", "strict", "portable", "unicode-code-point-order"];
+                };
+            }, {
+                readonly id: "String.toString";
+                readonly kind: "coercion";
+                readonly args: readonly ["String"];
+                readonly returns: "String";
+                readonly lowers: {
+                    readonly kern: "String.toString($0)";
+                    readonly ts: "__kernStringToString($0)";
+                    readonly python: "__kern_string_to_string($0)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly ["kern"];
+                    readonly returns: "kern";
+                }, {
+                    readonly args: readonly [""];
+                    readonly returns: "";
+                }];
+                readonly review: {
+                    readonly summary: "String identity coercion.";
+                    readonly graph: readonly ["String", "portable"];
+                };
+            }];
+        };
+        readonly Boolean: {
+            readonly name: "Boolean";
+            readonly kind: "primitive";
+            readonly strict: true;
+            readonly operations: readonly [{
+                readonly id: "Boolean.not";
+                readonly kind: "method";
+                readonly args: readonly ["Boolean"];
+                readonly returns: "Boolean";
+                readonly lowers: {
+                    readonly kern: "Boolean.not($0)";
+                    readonly ts: "__kernBooleanNot($0)";
+                    readonly python: "__kern_boolean_not($0)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly [true];
+                    readonly returns: false;
+                }, {
+                    readonly args: readonly [false];
+                    readonly returns: true;
+                }];
+                readonly review: {
+                    readonly summary: "Strict boolean negation.";
+                    readonly graph: readonly ["Boolean", "portable"];
+                };
+            }, {
+                readonly id: "Boolean.and";
+                readonly kind: "method";
+                readonly args: readonly ["Boolean", "Boolean"];
+                readonly returns: "Boolean";
+                readonly lowers: {
+                    readonly kern: "Boolean.and($0, $1)";
+                    readonly ts: "__kernBooleanAnd($0, $1)";
+                    readonly python: "__kern_boolean_and($0, $1)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly [true, true];
+                    readonly returns: true;
+                }, {
+                    readonly args: readonly [true, false];
+                    readonly returns: false;
+                }, {
+                    readonly args: readonly [false, true];
+                    readonly returns: false;
+                }, {
+                    readonly args: readonly [true, "true"];
+                    readonly throws: {
+                        readonly code: "strict-type";
+                        readonly message: "Boolean.and expects Boolean, Boolean.";
+                    };
+                }, {
+                    readonly args: readonly [true, 1];
+                    readonly throws: {
+                        readonly code: "strict-type";
+                        readonly message: "Boolean.and expects Boolean, Boolean.";
+                    };
+                }];
+                readonly review: {
+                    readonly summary: "Strict boolean conjunction; both operands must be Boolean.";
+                    readonly graph: readonly ["Boolean", "strict", "portable"];
+                };
+            }, {
+                readonly id: "Boolean.or";
+                readonly kind: "method";
+                readonly args: readonly ["Boolean", "Boolean"];
+                readonly returns: "Boolean";
+                readonly lowers: {
+                    readonly kern: "Boolean.or($0, $1)";
+                    readonly ts: "__kernBooleanOr($0, $1)";
+                    readonly python: "__kern_boolean_or($0, $1)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly [false, false];
+                    readonly returns: false;
+                }, {
+                    readonly args: readonly [true, false];
+                    readonly returns: true;
+                }, {
+                    readonly args: readonly [false, true];
+                    readonly returns: true;
+                }, {
+                    readonly args: readonly [false, "false"];
+                    readonly throws: {
+                        readonly code: "strict-type";
+                        readonly message: "Boolean.or expects Boolean, Boolean.";
+                    };
+                }];
+                readonly review: {
+                    readonly summary: "Strict boolean disjunction; both operands must be Boolean.";
+                    readonly graph: readonly ["Boolean", "strict", "portable"];
+                };
+            }, {
+                readonly id: "Boolean.equals";
+                readonly kind: "method";
+                readonly args: readonly ["Boolean", "Boolean"];
+                readonly returns: "Boolean";
+                readonly lowers: {
+                    readonly kern: "Boolean.equals($0, $1)";
+                    readonly ts: "__kernBooleanEquals($0, $1)";
+                    readonly python: "__kern_boolean_equals($0, $1)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly [true, true];
+                    readonly returns: true;
+                }, {
+                    readonly args: readonly [true, false];
+                    readonly returns: false;
+                }, {
+                    readonly args: readonly [true, "true"];
+                    readonly throws: {
+                        readonly code: "strict-type";
+                        readonly message: "Boolean.equals expects Boolean, Boolean.";
+                    };
+                }, {
+                    readonly args: readonly [true, 1];
+                    readonly throws: {
+                        readonly code: "strict-type";
+                        readonly message: "Boolean.equals expects Boolean, Boolean.";
+                    };
+                }];
+                readonly review: {
+                    readonly summary: "Strict boolean equality; cross-type equality is a type error in schema v1.";
+                    readonly graph: readonly ["Boolean", "strict", "portable"];
+                };
+            }, {
+                readonly id: "Boolean.toString";
+                readonly kind: "coercion";
+                readonly args: readonly ["Boolean"];
+                readonly returns: "String";
+                readonly lowers: {
+                    readonly kern: "Boolean.toString($0)";
+                    readonly ts: "__kernBooleanToString($0)";
+                    readonly python: "__kern_boolean_to_string($0)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly [true];
+                    readonly returns: "true";
+                }, {
+                    readonly args: readonly [false];
+                    readonly returns: "false";
+                }];
+                readonly review: {
+                    readonly summary: "Portable Boolean to String coercion using KERN lowercase boolean spelling.";
+                    readonly graph: readonly ["Boolean", "String", "portable"];
+                };
+            }];
+        };
+        readonly Number: {
+            readonly name: "Number";
+            readonly kind: "primitive";
+            readonly strict: true;
+            readonly operations: readonly [{
+                readonly id: "Number.negate";
+                readonly kind: "method";
+                readonly args: readonly ["Number"];
+                readonly returns: "Number";
+                readonly lowers: {
+                    readonly kern: "Number.negate($0)";
+                    readonly ts: "__kernNumberNegate($0)";
+                    readonly python: "__kern_number_negate($0)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly [3];
+                    readonly returns: -3;
+                }, {
+                    readonly args: readonly [-3];
+                    readonly returns: 3;
+                }, {
+                    readonly args: readonly ["3"];
+                    readonly throws: {
+                        readonly code: "strict-type";
+                        readonly message: "Number.negate expects Number.";
+                    };
+                }];
+                readonly review: {
+                    readonly summary: "Strict numeric negation over finite KERN Numbers.";
+                    readonly graph: readonly ["Number", "strict", "portable"];
+                };
+            }, {
+                readonly id: "Number.add";
+                readonly kind: "method";
+                readonly args: readonly ["Number", "Number"];
+                readonly returns: "Number";
+                readonly lowers: {
+                    readonly kern: "Number.add($0, $1)";
+                    readonly ts: "__kernNumberAdd($0, $1)";
+                    readonly python: "__kern_number_add($0, $1)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly [2, 3];
+                    readonly returns: 5;
+                }, {
+                    readonly args: readonly [-2, 3];
+                    readonly returns: 1;
+                }, {
+                    readonly args: readonly [2, "3"];
+                    readonly throws: {
+                        readonly code: "strict-type";
+                        readonly message: "Number.add expects Number, Number.";
+                    };
+                }];
+                readonly review: {
+                    readonly summary: "Strict numeric addition over finite KERN Numbers.";
+                    readonly graph: readonly ["Number", "strict", "portable"];
+                };
+            }, {
+                readonly id: "Number.subtract";
+                readonly kind: "method";
+                readonly args: readonly ["Number", "Number"];
+                readonly returns: "Number";
+                readonly lowers: {
+                    readonly kern: "Number.subtract($0, $1)";
+                    readonly ts: "__kernNumberSubtract($0, $1)";
+                    readonly python: "__kern_number_subtract($0, $1)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly [5, 3];
+                    readonly returns: 2;
+                }, {
+                    readonly args: readonly [3, 5];
+                    readonly returns: -2;
+                }, {
+                    readonly args: readonly [5, false];
+                    readonly throws: {
+                        readonly code: "strict-type";
+                        readonly message: "Number.subtract expects Number, Number.";
+                    };
+                }];
+                readonly review: {
+                    readonly summary: "Strict numeric subtraction over finite KERN Numbers.";
+                    readonly graph: readonly ["Number", "strict", "portable"];
+                };
+            }, {
+                readonly id: "Number.multiply";
+                readonly kind: "method";
+                readonly args: readonly ["Number", "Number"];
+                readonly returns: "Number";
+                readonly lowers: {
+                    readonly kern: "Number.multiply($0, $1)";
+                    readonly ts: "__kernNumberMultiply($0, $1)";
+                    readonly python: "__kern_number_multiply($0, $1)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly [3, 4];
+                    readonly returns: 12;
+                }, {
+                    readonly args: readonly [-3, 4];
+                    readonly returns: -12;
+                }, {
+                    readonly args: readonly [3, null];
+                    readonly throws: {
+                        readonly code: "strict-type";
+                        readonly message: "Number.multiply expects Number, Number.";
+                    };
+                }];
+                readonly review: {
+                    readonly summary: "Strict numeric multiplication over finite KERN Numbers.";
+                    readonly graph: readonly ["Number", "strict", "portable"];
+                };
+            }, {
+                readonly id: "Number.divide";
+                readonly kind: "method";
+                readonly args: readonly ["Number", "Number"];
+                readonly returns: "Number";
+                readonly lowers: {
+                    readonly kern: "Number.divide($0, $1)";
+                    readonly ts: "__kernNumberDivide($0, $1)";
+                    readonly python: "__kern_number_divide($0, $1)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly [6, 2];
+                    readonly returns: 3;
+                }, {
+                    readonly args: readonly [5, 2];
+                    readonly returns: 2.5;
+                }, {
+                    readonly args: readonly [1, 0];
+                    readonly throws: {
+                        readonly code: "division-by-zero";
+                        readonly message: "Number.divide division by zero.";
+                    };
+                }, {
+                    readonly args: readonly [6, "2"];
+                    readonly throws: {
+                        readonly code: "strict-type";
+                        readonly message: "Number.divide expects Number, Number.";
+                    };
+                }];
+                readonly review: {
+                    readonly summary: "Strict numeric division over finite KERN Numbers; zero divisor is a contract error.";
+                    readonly graph: readonly ["Number", "strict", "portable"];
+                };
+            }, {
+                readonly id: "Number.remainder";
+                readonly kind: "method";
+                readonly args: readonly ["Number", "Number"];
+                readonly returns: "Number";
+                readonly lowers: {
+                    readonly kern: "Number.remainder($0, $1)";
+                    readonly ts: "__kernNumberRemainder($0, $1)";
+                    readonly python: "__kern_number_remainder($0, $1)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly [5, 2];
+                    readonly returns: 1;
+                }, {
+                    readonly args: readonly [-5, 2];
+                    readonly returns: -1;
+                }, {
+                    readonly args: readonly [5, -2];
+                    readonly returns: 1;
+                }, {
+                    readonly args: readonly [1, 0];
+                    readonly throws: {
+                        readonly code: "division-by-zero";
+                        readonly message: "Number.remainder division by zero.";
+                    };
+                }, {
+                    readonly args: readonly [5, "2"];
+                    readonly throws: {
+                        readonly code: "strict-type";
+                        readonly message: "Number.remainder expects Number, Number.";
+                    };
+                }];
+                readonly review: {
+                    readonly summary: "Strict numeric remainder using KERN dividend-sign semantics; zero divisor is a contract error.";
+                    readonly graph: readonly ["Number", "strict", "portable"];
+                };
+            }, {
+                readonly id: "Number.lessThan";
+                readonly kind: "method";
+                readonly args: readonly ["Number", "Number"];
+                readonly returns: "Boolean";
+                readonly lowers: {
+                    readonly kern: "Number.lessThan($0, $1)";
+                    readonly ts: "__kernNumberLessThan($0, $1)";
+                    readonly python: "__kern_number_less_than($0, $1)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly [2, 3];
+                    readonly returns: true;
+                }, {
+                    readonly args: readonly [3, 2];
+                    readonly returns: false;
+                }, {
+                    readonly args: readonly [2, "3"];
+                    readonly throws: {
+                        readonly code: "strict-type";
+                        readonly message: "Number.lessThan expects Number, Number.";
+                    };
+                }];
+                readonly review: {
+                    readonly summary: "Strict numeric less-than comparison.";
+                    readonly graph: readonly ["Number", "Boolean", "strict", "portable"];
+                };
+            }, {
+                readonly id: "Number.lessThanOrEqual";
+                readonly kind: "method";
+                readonly args: readonly ["Number", "Number"];
+                readonly returns: "Boolean";
+                readonly lowers: {
+                    readonly kern: "Number.lessThanOrEqual($0, $1)";
+                    readonly ts: "__kernNumberLessThanOrEqual($0, $1)";
+                    readonly python: "__kern_number_less_than_or_equal($0, $1)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly [2, 2];
+                    readonly returns: true;
+                }, {
+                    readonly args: readonly [3, 2];
+                    readonly returns: false;
+                }, {
+                    readonly args: readonly [2, null];
+                    readonly throws: {
+                        readonly code: "strict-type";
+                        readonly message: "Number.lessThanOrEqual expects Number, Number.";
+                    };
+                }];
+                readonly review: {
+                    readonly summary: "Strict numeric less-than-or-equal comparison.";
+                    readonly graph: readonly ["Number", "Boolean", "strict", "portable"];
+                };
+            }, {
+                readonly id: "Number.greaterThan";
+                readonly kind: "method";
+                readonly args: readonly ["Number", "Number"];
+                readonly returns: "Boolean";
+                readonly lowers: {
+                    readonly kern: "Number.greaterThan($0, $1)";
+                    readonly ts: "__kernNumberGreaterThan($0, $1)";
+                    readonly python: "__kern_number_greater_than($0, $1)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly [3, 2];
+                    readonly returns: true;
+                }, {
+                    readonly args: readonly [2, 3];
+                    readonly returns: false;
+                }, {
+                    readonly args: readonly [3, true];
+                    readonly throws: {
+                        readonly code: "strict-type";
+                        readonly message: "Number.greaterThan expects Number, Number.";
+                    };
+                }];
+                readonly review: {
+                    readonly summary: "Strict numeric greater-than comparison.";
+                    readonly graph: readonly ["Number", "Boolean", "strict", "portable"];
+                };
+            }, {
+                readonly id: "Number.greaterThanOrEqual";
+                readonly kind: "method";
+                readonly args: readonly ["Number", "Number"];
+                readonly returns: "Boolean";
+                readonly lowers: {
+                    readonly kern: "Number.greaterThanOrEqual($0, $1)";
+                    readonly ts: "__kernNumberGreaterThanOrEqual($0, $1)";
+                    readonly python: "__kern_number_greater_than_or_equal($0, $1)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly [3, 3];
+                    readonly returns: true;
+                }, {
+                    readonly args: readonly [2, 3];
+                    readonly returns: false;
+                }, {
+                    readonly args: readonly [3, "3"];
+                    readonly throws: {
+                        readonly code: "strict-type";
+                        readonly message: "Number.greaterThanOrEqual expects Number, Number.";
+                    };
+                }];
+                readonly review: {
+                    readonly summary: "Strict numeric greater-than-or-equal comparison.";
+                    readonly graph: readonly ["Number", "Boolean", "strict", "portable"];
+                };
+            }];
+        };
+        readonly List: {
+            readonly name: "List";
+            readonly kind: "collection";
+            readonly strict: true;
+            readonly operations: readonly [{
+                readonly id: "List.length";
+                readonly kind: "property";
+                readonly args: readonly ["List"];
+                readonly returns: "Number";
+                readonly lowers: {
+                    readonly kern: "List.length($0)";
+                    readonly ts: "__kernListLength($0)";
+                    readonly python: "__kern_list_length($0)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly [readonly []];
+                    readonly returns: 0;
+                }, {
+                    readonly args: readonly [readonly [1, 2, 3]];
+                    readonly returns: 3;
+                }, {
+                    readonly args: readonly ["not-list"];
+                    readonly throws: {
+                        readonly code: "strict-type";
+                        readonly message: "List.length expects List.";
+                    };
+                }];
+                readonly review: {
+                    readonly summary: "Strict list cardinality.";
+                    readonly graph: readonly ["List", "Number", "strict", "portable"];
+                };
+            }, {
+                readonly id: "List.index";
+                readonly kind: "method";
+                readonly args: readonly ["List", "Number"];
+                readonly returns: readonly ["String", "Boolean", "Number", "List", "Record", "Function", "Null", "Undefined"];
+                readonly lowers: {
+                    readonly kern: "List.index($0, $1)";
+                    readonly ts: "__kernListIndex($0, $1)";
+                    readonly python: "__kern_list_index($0, $1)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly [readonly [10, 20, 30], 0];
+                    readonly returns: 10;
+                }, {
+                    readonly args: readonly [readonly [10, 20, 30], 2];
+                    readonly returns: 30;
+                }, {
+                    readonly args: readonly [readonly [10, 20, 30], 3];
+                    readonly returns: {
+                        readonly __kernFixture: "Undefined";
+                    };
+                }, {
+                    readonly args: readonly [readonly [10, 20, 30], -1];
+                    readonly returns: {
+                        readonly __kernFixture: "Undefined";
+                    };
+                }, {
+                    readonly args: readonly [readonly [10, 20, 30], 1.5];
+                    readonly returns: {
+                        readonly __kernFixture: "Undefined";
+                    };
+                }, {
+                    readonly args: readonly [readonly [10, {
+                        readonly __kernFixture: "Undefined";
+                    }, 30], 1];
+                    readonly returns: {
+                        readonly __kernFixture: "Undefined";
+                    };
+                }, {
+                    readonly args: readonly [readonly [], 0];
+                    readonly returns: {
+                        readonly __kernFixture: "Undefined";
+                    };
+                }, {
+                    readonly args: readonly [readonly [10], "0"];
+                    readonly throws: {
+                        readonly code: "strict-type";
+                        readonly message: "List.index expects List, Number.";
+                    };
+                }];
+                readonly review: {
+                    readonly summary: "Strict list index by numeric offset; misses return Undefined.";
+                    readonly graph: readonly ["List", "Number", "Undefined", "strict", "portable"];
+                };
+            }];
+        };
+        readonly Record: {
+            readonly name: "Record";
+            readonly kind: "record";
+            readonly strict: true;
+            readonly operations: readonly [{
+                readonly id: "Record.get";
+                readonly kind: "method";
+                readonly args: readonly ["Record", "String"];
+                readonly returns: readonly ["String", "Boolean", "Number", "List", "Record", "Function", "Null", "Undefined"];
+                readonly lowers: {
+                    readonly kern: "Record.get($0, $1)";
+                    readonly ts: "__kernRecordGet($0, $1)";
+                    readonly python: "__kern_record_get($0, $1)";
+                };
+                readonly fixtures: readonly [{
+                    readonly args: readonly [{
+                        readonly x: 1;
+                    }, "x"];
+                    readonly returns: 1;
+                }, {
+                    readonly args: readonly [{
+                        readonly x: 1;
+                    }, "y"];
+                    readonly returns: {
+                        readonly __kernFixture: "Undefined";
+                    };
+                }, {
+                    readonly args: readonly [{
+                        readonly x: {
+                            readonly __kernFixture: "Undefined";
+                        };
+                    }, "x"];
+                    readonly returns: {
+                        readonly __kernFixture: "Undefined";
+                    };
+                }, {
+                    readonly args: readonly [{}, "toString"];
+                    readonly returns: {
+                        readonly __kernFixture: "Undefined";
+                    };
+                }, {
+                    readonly args: readonly [{}, ""];
+                    readonly returns: {
+                        readonly __kernFixture: "Undefined";
+                    };
+                }, {
+                    readonly args: readonly [{
+                        readonly x: 1;
+                    }, 0];
+                    readonly throws: {
+                        readonly code: "strict-type";
+                        readonly message: "Record.get expects Record, String.";
+                    };
+                }];
+                readonly review: {
+                    readonly summary: "Strict own-key record lookup; missing keys return Undefined.";
+                    readonly graph: readonly ["Record", "String", "Undefined", "strict", "portable"];
+                };
+            }];
+        };
+        readonly Function: {
+            readonly name: "Function";
+            readonly kind: "callable";
+            readonly strict: true;
+            readonly operations: readonly [];
+        };
+        readonly Null: {
+            readonly name: "Null";
+            readonly kind: "nullish";
+            readonly strict: true;
+            readonly operations: readonly [];
+        };
+        readonly Undefined: {
+            readonly name: "Undefined";
+            readonly kind: "nullish";
+            readonly strict: true;
+            readonly operations: readonly [];
+        };
+    };
+};