@gtkx/codegen 1.0.0-rc.3 → 1.0.0-rc.4

package/src/docs/pipeline.ts

@@ -28,8 +28,8 @@ type DocsOptions = {
     outDir: string;
     basePath?: string;
     props?: ElementProps;
-    omitProps?: OmittedProps;
-    force?: boolean;
+    omittedProps?: OmittedProps;
+    isForced?: boolean;
 };
 
 type DocsManifest = {
@@ -45,7 +45,7 @@ type Page = { path: string; content: string };
 type NamespacePages = { docs: DocsNamespace; pages: Page[] };
 
 type DocsResult = {
-    regenerated: boolean;
+    isRegenerated: boolean;
     namespaces: DocsNamespace[];
 };
 
@@ -193,7 +193,7 @@ const generatePages = (options: DocsOptions, basePath: string, library: Library)
 };
 
 const cachedDocsResult = (options: DocsOptions, manifestPath: string): DocsResult | undefined => {
-    if (options.force === true || !isGiStoreFresh(options.outDir, options.libraries, options.girPath)) {
+    if (options.isForced === true || !isGiStoreFresh(options.outDir, options.libraries, options.girPath)) {
         return undefined;
     }
 
@@ -203,7 +203,7 @@ const cachedDocsResult = (options: DocsOptions, manifestPath: string): DocsResul
 
     const manifest = JSON.parse(readFileSync(manifestPath, "utf8")) as DocsManifest;
 
-    return { regenerated: false, namespaces: manifest.namespaces };
+    return { isRegenerated: false, namespaces: manifest.namespaces };
 };
 
 const writePages = (outDir: string, pages: Page[]): void => {
@@ -216,7 +216,7 @@ const writePages = (outDir: string, pages: Page[]): void => {
 
 const writeDocs = (options: DocsOptions): DocsResult => {
     setElementProps(options.props ?? {});
-    setOmittedProps(options.omitProps ?? {});
+    setOmittedProps(options.omittedProps ?? {});
     const basePath = options.basePath ?? "/reference";
     const manifestPath = join(options.outDir, MANIFEST_FILENAME);
     const cached = cachedDocsResult(options, manifestPath);
@@ -238,7 +238,7 @@ const writeDocs = (options: DocsOptions): DocsResult => {
         JSON.stringify(computeGiFingerprint(library.girFiles, options.libraries, options.girPath)),
     );
 
-    return { regenerated: true, namespaces };
+    return { isRegenerated: true, namespaces };
 };
 
-export { writeDocs, type DocsElementLink, type DocsNamespace, type DocsOptions, type DocsResult };
+export { writeDocs };

package/src/docs/render.ts

@@ -45,8 +45,8 @@ const renderDocsHandlerResultType = (library: Library, signal: GirCallable): str
         library,
         signal,
         renderType: (ref, nullable) => renderDocsType(library, ref, nullable),
-        includeCallerAllocated: false,
-        optOut: true,
+        shouldIncludeCallerAllocated: false,
+        isOptOut: true,
     });
 
 const renderDocsHandlerParameters = (library: Library, signal: GirCallable): string[] =>
@@ -69,16 +69,16 @@ const stripDocMedia = (markdown: string): string =>
         .replaceAll(/<video[\s\S]*?(?:<\/video>|\/>)/g, "")
         .replaceAll(/<img[^>]*>/g, "");
 
-const demoteLine = (line: string, isInFence: boolean): { text: string; inFence: boolean } => {
+const demoteLine = (line: string, isInFence: boolean): { text: string; isInFence: boolean } => {
     if (FENCE_LINE.test(line)) {
-        return { text: line, inFence: !isInFence };
+        return { text: line, isInFence: !isInFence };
     }
 
     if (isInFence) {
-        return { text: line, inFence: isInFence };
+        return { text: line, isInFence };
     }
 
-    return { text: HEADING_LINE.test(line) ? `#${line}` : line, inFence: isInFence };
+    return { text: HEADING_LINE.test(line) ? `#${line}` : line, isInFence };
 };
 
 const demoteHeadings = (markdown: string): string => {
@@ -87,7 +87,7 @@ const demoteHeadings = (markdown: string): string => {
 
     for (const line of markdown.split("\n")) {
         const result = demoteLine(line, isInFence);
-        isInFence = result.inFence;
+        isInFence = result.isInFence;
         lines.push(result.text);
     }
 

package/src/docs/symbol-page.ts

@@ -49,12 +49,17 @@ import {
     type SignatureEntry,
 } from "./render.js";
 
+/** What every indexed GIR symbol carries, whatever its kind. */
 type GiSymbolBase = {
+    /** GIR namespace declaring the symbol. */
     namespace: GirNamespace;
+    /** Name the bindings export it under: camelCase for functions, PascalCase for classes, the GIR name otherwise. */
     name: string;
+    /** Raw gtk-doc text from the GIR, undefined when the symbol is undocumented. */
     doc: string | undefined;
 };
 
+/** A GIR symbol the reference indexes, discriminated by `kind` and carrying the GIR node its page renders from. */
 type GiSymbolEntry =
     | (GiSymbolBase & { kind: "class" | "interface"; klass: GirClass }) |
     (GiSymbolBase & { kind: "record"; record: GirRecord }) |
@@ -270,7 +275,7 @@ const propertyMeta = (property: GirProperty, accessor: ResolvedAccessor, origin:
         meta.push("construct-only");
     }
 
-    if (!accessor.writable) {
+    if (!accessor.isWritable) {
         meta.push("read-only");
     } else if (!accessor.hasGetter) {
         meta.push("write-only");
@@ -495,7 +500,7 @@ const recordPage = (entry: GiSymbolBase & { kind: "record"; record: GirRecord },
 };
 
 const fieldMeta = (field: ResolvedRecordField): string =>
-    [`\`${field.tsType}\``, ...(field.writable ? [] : ["read-only"])].join(" · ");
+    [`\`${field.tsType}\``, ...(field.isWritable ? [] : ["read-only"])].join(" · ");
 
 const fieldsSection = (record: GirRecord, context: ModuleContext, claimedNames: Set<string>): string[] => {
     const { slots } = computeRecordFieldSlots(context, record.fields, record.isUnion);

package/src/fingerprint.ts

@@ -5,7 +5,6 @@ import { createRequire } from "node:module";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
-/** The freshness sentinel of the `@gtkx/gi` store, derived purely from the GIR inputs. */
 type GiFingerprint = {
     value: string;
     girFiles: string[];
@@ -15,16 +14,14 @@ type GiFingerprint = {
 
 type ModuleExport = { module: string; export: string };
 
-/** The `@gtkx/react` element config that shapes the generated `@gtkx/jsx` store. */
 type JsxFingerprintInput = {
     reactVersion: string;
     components: Record<string, ModuleExport>;
     lazyElements: string[];
     props: Record<string, ModuleExport>;
-    omitProps: Record<string, string[]>;
+    omittedProps: Record<string, string[]>;
 };
 
-/** The freshness sentinel of the `@gtkx/jsx` store, derived from the React element config. */
 type JsxFingerprint = {
     value: string;
     intrinsicElementCount: number;
@@ -37,8 +34,6 @@ const OVERRIDES_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "o
 
 const sortAlpha = (values: string[]): string => sortStrings(values).join(",");
 
-// The overrides are copied verbatim into the store, so editing one changes the output even though no
-// GIR file moved. Without them in the hash a stale override survives every non-forced run.
 const overrideFiles = (): string[] => {
     if (!existsSync(OVERRIDES_ROOT)) {
         return [];
@@ -116,7 +111,7 @@ const hasMatchingRecordedInputs = (sentinel: GiFingerprint, libraries: string[],
 const serializeModuleExports = (map: Record<string, ModuleExport>): [string, string, string][] =>
     sortStrings(Object.keys(map)).map((type) => [type, map[type]?.module ?? "", map[type]?.export ?? ""]);
 
-const serializeOmitProps = (map: Record<string, string[]>): [string, string][] =>
+const serializeOmittedProps = (map: Record<string, string[]>): [string, string][] =>
     sortStrings(Object.keys(map)).map((type) => [type, sortAlpha(map[type] ?? [])]);
 
 const hashJsx = (input: JsxFingerprintInput): string =>
@@ -128,7 +123,7 @@ const hashJsx = (input: JsxFingerprintInput): string =>
                 serializeModuleExports(input.components),
                 sortStrings(input.lazyElements),
                 serializeModuleExports(input.props),
-                serializeOmitProps(input.omitProps),
+                serializeOmittedProps(input.omittedProps),
             ]),
         )
         .digest("hex");
@@ -141,11 +136,11 @@ const computeJsxFingerprint = (input: JsxFingerprintInput, intrinsicElementCount
 const jsxStoreFreshness = (
     jsxStoreDir: string,
     input: JsxFingerprintInput,
-): { fresh: boolean; intrinsicElementCount: number } => {
+): { isFresh: boolean; intrinsicElementCount: number } => {
     const sentinelPath = join(jsxStoreDir, FINGERPRINT_FILENAME);
 
     if (!existsSync(sentinelPath)) {
-        return { fresh: false, intrinsicElementCount: 0 };
+        return { isFresh: false, intrinsicElementCount: 0 };
     }
 
     let sentinel: JsxFingerprint;
@@ -153,12 +148,12 @@ const jsxStoreFreshness = (
     try {
         sentinel = JSON.parse(readFileSync(sentinelPath, "utf8")) as JsxFingerprint;
     } catch {
-        return { fresh: false, intrinsicElementCount: 0 };
+        return { isFresh: false, intrinsicElementCount: 0 };
     }
 
     return sentinel.value === hashJsx(input)
-        ? { fresh: true, intrinsicElementCount: sentinel.intrinsicElementCount }
-        : { fresh: false, intrinsicElementCount: 0 };
+        ? { isFresh: true, intrinsicElementCount: sentinel.intrinsicElementCount }
+        : { isFresh: false, intrinsicElementCount: 0 };
 };
 
 export {

package/src/gi.ts

@@ -1,21 +1,16 @@
 import type { Library } from "./gir/library.js";
+import type { StoreOptions } from "./store/store-fs.js";
 import { computeGiFingerprint } from "./fingerprint.js";
 import { namespaceDirectory } from "./gir/namespace.js";
-import { type GiNamespaceInput, type GiStoreOptions, writeGiStore } from "./store/gi-store.js";
+import { type GiNamespaceInput, writeGiStore } from "./store/gi-store.js";
 import { generateNamespaceModule } from "./store/gi/pipeline.js";
 
 type GiCodegenOptions = {
-    gi: GiStoreOptions;
+    gi: StoreOptions;
     libraries: string[];
     girPath: string[];
 };
 
-/**
- * Generates the `@gtkx/gi` store from the loaded GIR library and links it into the project. This is the
- * react-free half of codegen: it can run before `@gtkx/gi` (or `@gtkx/react`) exists, since it produces them.
- *
- * @returns The number of namespaces written.
- */
 const runGiCodegen = (library: Library, options: GiCodegenOptions): number => {
     const { gi, libraries, girPath } = options;
 
@@ -30,6 +25,4 @@ const runGiCodegen = (library: Library, options: GiCodegenOptions): number => {
     return library.namespaces.size;
 };
 
-export { isGiStoreFresh } from "./fingerprint.js";
-export type { GiStoreOptions } from "./store/gi-store.js";
-export { runGiCodegen, type GiCodegenOptions };
+export { runGiCodegen };

package/src/gir/field.ts

@@ -11,7 +11,6 @@ type GirField = {
     writable: boolean;
     private: boolean;
     bits: number | undefined;
-    /** Members of an anonymous nested `<union>`/`<record>`, which occupies a slot but has no type. */
     inlineMembers: GirField[] | undefined;
     inlineIsUnion: boolean;
 };
@@ -29,9 +28,6 @@ const fieldFromNode = (node: RawNode, context: ParseContext): GirField => ({
     inlineIsUnion: false,
 });
 
-// A record may embed an anonymous `<union>` or `<record>` instead of naming a type for it. The
-// member occupies a real slot and contributes its own size and alignment, but carries no `<type>`,
-// so it has to be admitted as a field whose layout comes from its own children.
 const anonymousMemberFromNode = (node: RawNode, isUnion: boolean, context: ParseContext): GirField => ({
     name: nameAttr(node),
     doc: getDoc(node),

package/src/gir/gir-path.ts

@@ -4,6 +4,13 @@ import { existsSync } from "node:fs";
 
 const SYSTEM_GIR_PATH = "/usr/share/gir-1.0";
 
+/**
+ * The directories to search for `.gir` files, in precedence order: the config's own `girPath`, then
+ * `GTKX_GIR_PATH`, then `/usr/share/gir-1.0`, then the girdir pkg-config reports for
+ * gobject-introspection-1.0. Duplicates are dropped, and the last two are included only when they exist.
+ *
+ * @throws If pkg-config is installed but fails while being queried.
+ */
 const resolveGirPath = (configGirPath: string[] | undefined): string[] => {
     const paths: string[] = [];
 

package/src/gir/libraries.ts

@@ -2,13 +2,22 @@ import { sortStrings } from "@gtkx/utils";
 import { readdirSync } from "node:fs";
 
 type GirNamespace = { name: string; version: string; identifier: string };
+/** A `libraries` config value: an explicit list, `"*"` for everything installed, or absent for the default. */
 type LibrarySelection = typeof LIBRARIES_WILDCARD | string[] | undefined;
 
+/** The `libraries` value that stands for every GIR library installed on the search path. */
 const LIBRARIES_WILDCARD = "*";
 const GIR_LIBRARY_PATTERN = /^[A-Za-z][A-Za-z0-9]*-\d+(?:\.\d+)*$/;
 const DEFAULT_LIBRARIES: string[] = ["Gtk-4.0"];
 const GIR_FILE_SUFFIX = ".gir";
 
+/**
+ * Expands a `libraries` config value into the GIR identifiers to generate from: `"Gtk-4.0"` alone when
+ * nothing is configured, everything installed for `"*"`, and otherwise the given list with `"Gtk-4.0"`
+ * prepended unless it already names a Gtk version.
+ *
+ * @throws If `"*"` matched no `.gir` file anywhere on the GIR path.
+ */
 const resolveLibraries = (libraries: LibrarySelection, girPath: string[]): string[] => {
     if (libraries === undefined) {
         return [...DEFAULT_LIBRARIES];
@@ -74,6 +83,10 @@ const collectDirNamespaces = (highestByName: Map<string, GirNamespace>, dir: str
     }
 };
 
+/**
+ * Every GIR library installed on the search path, as sorted `Name-Version` identifiers. A namespace found
+ * in more than one version contributes only its highest, and unreadable directories are skipped.
+ */
 const discoverGirNamespaces = (girPath: string[]): string[] => {
     const highestByName: Map<string, GirNamespace> = new Map();
 

package/src/gir/parameter.ts

@@ -53,10 +53,6 @@ const SCOPES: Set<CallbackScope> = new Set(["call", "notified", "async", "foreve
 const transferOwnership = (node: RawNode): ParameterTransfer =>
     parseEnumAttr(attr(node, "transfer-ownership"), TRANSFERS, "none", "transfer-ownership");
 
-// `allow-none` is the legacy spelling of two different attributes: on an in-parameter it means the
-// value may be NULL (`nullable`), but on an out-parameter it means the caller may pass a NULL
-// location (`optional`). Folding it into `nullable` for an out-parameter would claim the returned
-// value can be null for the 494 out-parameters across the installed GIRs that only say `allow-none`.
 const isInDirection = (node: RawNode): boolean =>
     parseEnumAttr(attr(node, "direction"), DIRECTIONS, "in", "direction") === "in";
 

package/src/gir/size.ts

@@ -59,9 +59,6 @@ const pushPlainField = (state: StructLayoutState, slots: FieldSlot[], field: Fie
     state.bitCursor = (byteOffset + field.layout.size) * 8;
 };
 
-// SysV AMD64 places a bit-field at the current bit offset whenever it still fits inside a storage
-// unit of its declared type aligned to that type's alignment, so the unit the cursor already sits in
-// may have room even though the cursor is not on a unit boundary.
 const pushBitfield = (input: {
     state: StructLayoutState;
     slots: FieldSlot[];

package/src/gir/type-id.ts

@@ -12,7 +12,7 @@ type CArrayType = {
     elementCType: string | undefined;
     lengthParameterIndex: number | undefined;
     fixedSize: number | undefined;
-    zeroTerminated: boolean;
+    isZeroTerminated: boolean;
 };
 
 type ListType = {
@@ -46,10 +46,8 @@ const LIST_FLAVOR_BY_NAME = {
     "GLib.ByteArray": "gbytearray",
 } as const;
 
-// An array with no length parameter, no fixed size and an explicit `zero-terminated="0"` carries no
-// way to recover its length, so it is a bare pointer rather than something that can be walked.
 const hasUnknownArrayLength = (ref: CArrayType): boolean =>
-    !ref.zeroTerminated && ref.lengthParameterIndex === undefined && ref.fixedSize === undefined;
+    !ref.isZeroTerminated && ref.lengthParameterIndex === undefined && ref.fixedSize === undefined;
 
 export {
     hasUnknownArrayLength,

package/src/gir/type-ref.ts

@@ -90,7 +90,7 @@ const arrayTypeRefFromNode = (arrayNode: RawNode, context: ParseContext): TypeId
         elementCType: elementNode === undefined ? undefined : attr(elementNode, "c:type"),
         lengthParameterIndex: intAttr(arrayNode, "length"),
         fixedSize: intAttr(arrayNode, "fixed-size"),
-        zeroTerminated: isAttrTrue(arrayNode, "zero-terminated", true),
+        isZeroTerminated: isAttrTrue(arrayNode, "zero-terminated", true),
     };
 
     return context.addContainer(carray);

package/src/index.ts

@@ -1,3 +1,4 @@
+/** @public */
 export {
     API_SYMBOL_KINDS,
     type ApiLookupResult,
@@ -7,23 +8,24 @@ export {
     type ApiSearchOptions,
     type ApiSymbol,
     type ApiSymbolKind,
+    type ApiSymbolQuery,
     loadApiReference,
 } from "./docs/api-reference.js";
-export {
-    type DocsElementLink,
-    type DocsNamespace,
-    type DocsOptions,
-    type DocsResult,
-    writeDocs,
-} from "./docs/pipeline.js";
+/** @public */
 export { resolveGirPath } from "./gir/gir-path.js";
-export { discoverGirNamespaces, resolveLibraries } from "./gir/libraries.js";
-export {
-    type BuiltinElement,
-    type BuiltinElements,
-    type ModuleExport,
-    readBuiltinElements,
-} from "./react/element-config.js";
-export { runCodegen } from "./runner.js";
+/** @public */
+export { discoverGirNamespaces, type LibrarySelection, resolveLibraries } from "./gir/libraries.js";
+/** @public */
+export { type BuiltinElements, type ModuleExport, readBuiltinElements } from "./react/element-config.js";
+/** @public */
+export { type CodegenRunnerOptions, type CodegenRunnerResult, runCodegen } from "./runner.js";
+/** @public */
 export type { ElementProps } from "./store/jsx/element-prop-imports.js";
-export { mergeOmitProps, type OmittedProps } from "./store/jsx/omitted-props.js";
+/** @public */
+export { type GeneratedElement, readGeneratedElements } from "./store/jsx/generated-elements.js";
+/** @public */
+export { mergeOmittedProps, type OmittedProps } from "./store/jsx/omitted-props.js";
+/** @public */
+export { type ResolvedStore, resolveStore } from "./store/resolve-store.js";
+/** @public */
+export type { StoreOptions } from "./store/store-fs.js";

package/src/internal.ts

@@ -0,0 +1,2 @@
+export { writeDocs } from "./docs/pipeline.js";
+export { runGlCodegen } from "./runner.js";

package/src/jsx.ts

@@ -1,4 +1,5 @@
 import type { Library } from "./gir/library.js";
+import type { StoreOptions } from "./store/store-fs.js";
 import {
     computeJsxFingerprint,
     FINGERPRINT_FILENAME,
@@ -6,70 +7,69 @@ import {
     jsxStoreFreshness,
 } from "./fingerprint.js";
 import { type ModuleExport, readBuiltinElements } from "./react/element-config.js";
-import { type JsxStoreOptions, writeJsxStore } from "./store/jsx-store.js";
-import { mergeOmitProps, type OmittedProps } from "./store/jsx/omitted-props.js";
+import { writeJsxStore } from "./store/jsx-store.js";
+import { ELEMENTS_FILENAME, renderGeneratedElements } from "./store/jsx/generated-elements.js";
+import { mergeOmittedProps, type OmittedProps } from "./store/jsx/omitted-props.js";
 import { generateJsxFiles } from "./store/jsx/pipeline.js";
 
 type RunJsxCodegenOptions = {
     getLibrary: () => Library;
-    jsx: JsxStoreOptions;
+    jsx: StoreOptions;
     giStoreDir: string;
     reactSubexports: string[];
     userComponents: Record<string, ModuleExport>;
     userLazyElements: string[];
     userProps: Record<string, ModuleExport>;
-    userOmitProps: OmittedProps;
-    giRegenerated: boolean;
-    force: boolean;
+    userOmittedProps: OmittedProps;
+    isGiRegenerated: boolean;
+    isForced: boolean;
 };
 
 type RunJsxCodegenResult = {
-    regenerated: boolean;
+    isRegenerated: boolean;
     intrinsicElementCount: number;
 };
 
-/**
- * Generates the `@gtkx/jsx` store, reading the framework's built-in element config from the freshly
- * linked `@gtkx/react` and layering the project's own element config over it. This is the react-importing
- * half of codegen: it must run only after the gi store has been written and linked.
- */
 const runJsxCodegen = async (options: RunJsxCodegenOptions): Promise<RunJsxCodegenResult> => {
     const builtin = await readBuiltinElements(options.reactSubexports, options.giStoreDir);
     const components = { ...builtin.components, ...options.userComponents };
     const lazyElements = [...builtin.lazyElements, ...options.userLazyElements];
     const props = { ...builtin.props, ...options.userProps };
-    const omitProps = mergeOmitProps(builtin.omitProps, options.userOmitProps);
+    const omittedProps = mergeOmittedProps(builtin.omittedProps, options.userOmittedProps);
 
     const fingerprintInput: JsxFingerprintInput = {
         reactVersion: options.jsx.version,
         components,
         lazyElements,
         props,
-        omitProps,
+        omittedProps,
     };
 
-    if (!options.force && !options.giRegenerated) {
-        const { fresh, intrinsicElementCount } = jsxStoreFreshness(options.jsx.storeDir, fingerprintInput);
+    if (!options.isForced && !options.isGiRegenerated) {
+        const { isFresh, intrinsicElementCount } = jsxStoreFreshness(options.jsx.storeDir, fingerprintInput);
 
-        if (fresh) {
-            return { regenerated: false, intrinsicElementCount };
+        if (isFresh) {
+            return { isRegenerated: false, intrinsicElementCount };
         }
     }
 
-    const { namespaces, metadata, intrinsicElementCount } = generateJsxFiles(options.getLibrary(), {
+    const { namespaces, metadata, intrinsicElementCount, elements } = generateJsxFiles(options.getLibrary(), {
         reactSubexports: options.reactSubexports,
         components,
         lazyElements,
         props,
-        omitProps,
+        omittedProps,
     });
 
-    writeJsxStore(options.jsx, namespaces, metadata, {
-        relativePath: FINGERPRINT_FILENAME,
-        content: `${JSON.stringify(computeJsxFingerprint(fingerprintInput, intrinsicElementCount), null, 2)}\n`,
-    });
+    writeJsxStore(options.jsx, namespaces, metadata, [
+        {
+            relativePath: FINGERPRINT_FILENAME,
+            content: `${JSON.stringify(computeJsxFingerprint(fingerprintInput, intrinsicElementCount), null, 2)}\n`,
+        },
+        { relativePath: ELEMENTS_FILENAME, content: renderGeneratedElements(elements) },
+    ]);
 
-    return { regenerated: true, intrinsicElementCount };
+    return { isRegenerated: true, intrinsicElementCount };
 };
 
-export { runJsxCodegen, type RunJsxCodegenOptions, type RunJsxCodegenResult };
+export { runJsxCodegen };

package/src/khronos/args.ts

@@ -52,7 +52,7 @@ type BuildArgOptions = {
 const OUT_PLAN_KINDS: Set<string> = new Set(["ref-out", "ref-array-out", "ref-fixed-out", "string-out"]);
 
 const scalarAliasOrGroup = (scalar: GlScalar, group: string | undefined): string =>
-    group !== undefined && scalar.groupBearing === true ? group : scalar.tsAlias;
+    group !== undefined && scalar.isGroupBearing === true ? group : scalar.tsAlias;
 
 const paramIndexByName = (command: GlCommand, name: string): number => {
     const index = command.params.findIndex((param) => param.name === name);

package/src/khronos/pipeline.ts

@@ -143,7 +143,7 @@ const mergeGroupAlias = (aliases: Map<string, string>, scalar: GlScalar, group:
         return;
     }
 
-    if (scalar.groupBearing !== true) {
+    if (scalar.isGroupBearing !== true) {
         return;
     }
 

package/src/khronos/plan.ts

@@ -5,13 +5,13 @@ type GlScalar = {
     descriptor: string;
     tsAlias: string;
     viewType?: string;
-    groupBearing?: boolean;
+    isGroupBearing?: boolean;
 };
 
 type ParsedCType = {
     base: string;
     pointers: number;
-    constData: boolean;
+    isConstData: boolean;
 };
 
 type ParamPlan =
@@ -61,10 +61,10 @@ type CommandPlan =
 type ParamOutcome = { plan: ParamPlan } | { reason: GlExclusionReason };
 
 const GL_SCALARS: Map<string, GlScalar> = new Map([
-    ["GLenum", { descriptor: tScalar("uint32"), tsAlias: "GLenum", viewType: "Uint32Array", groupBearing: true }],
+    ["GLenum", { descriptor: tScalar("uint32"), tsAlias: "GLenum", viewType: "Uint32Array", isGroupBearing: true }],
     [
         "GLbitfield",
-        { descriptor: tScalar("uint32"), tsAlias: "GLbitfield", viewType: "Uint32Array", groupBearing: true },
+        { descriptor: tScalar("uint32"), tsAlias: "GLbitfield", viewType: "Uint32Array", isGroupBearing: true },
     ],
     ["GLuint", { descriptor: tScalar("uint32"), tsAlias: "GLuint", viewType: "Uint32Array" }],
     ["GLint", { descriptor: tScalar("int32"), tsAlias: "GLint", viewType: "Int32Array" }],
@@ -96,7 +96,7 @@ const parseCType = (cType: string): ParsedCType => {
         .filter((token) => token.length > 0 && token !== "const" && token !== "struct")
         .join(" ");
 
-    return { base, pointers, constData: isConstData };
+    return { base, pointers, isConstData };
 };
 
 const isCompsize = (len: string): boolean => len.includes("COMPSIZE(");
@@ -158,11 +158,11 @@ const charStringOutLen = (command: GlCommand, param: GlParam, parsed: ParsedCTyp
 };
 
 const planCharParam = (command: GlCommand, param: GlParam, parsed: ParsedCType): ParamOutcome => {
-    if (parsed.pointers === 1 && parsed.constData) {
+    if (parsed.pointers === 1 && parsed.isConstData) {
         return { plan: { kind: "string-in" } };
     }
 
-    if (parsed.pointers === 2 && parsed.constData) {
+    if (parsed.pointers === 2 && parsed.isConstData) {
         return { plan: { kind: "string-array-in" } };
     }
 
@@ -191,7 +191,7 @@ const planScalarParam = (
         return { plan: { kind: "scalar", scalar } };
     }
 
-    if (parsed.pointers === 1 && parsed.constData) {
+    if (parsed.pointers === 1 && parsed.isConstData) {
         return { plan: { kind: "array-in", scalar } };
     }