@gtkx/codegen 1.0.0-rc.3 → 1.0.0

package/src/gir/parameter.ts

@@ -1,4 +1,5 @@
 import type { ParseContext, TypeId } from "./type-id.js";
+import { documentedFromNode, type GirAnnotations } from "./annotations.js";
 import {
     attr,
     getChild,
@@ -12,37 +13,75 @@ import {
 } from "./parse.js";
 import { typeRefFromNode } from "./type-ref.js";
 
+/** Which way a parameter's value travels: into the call, back out of it, or both. */
 type ParameterDirection = "in" | "out" | "inout";
+/** How much of a value the receiver takes ownership of: none, the whole value, or only its container. */
 type ParameterTransfer = "none" | "full" | "container";
+/**
+ * How long a callback parameter stays valid: for the duration of the call, until its destroy notify runs,
+ * until the asynchronous operation invokes it, or forever.
+ */
 type CallbackScope = "call" | "notified" | "async" | "forever";
 
+/** A parameter of a {@link GirCallable}, with the annotations that decide how it is marshalled. */
 type GirParameter = {
+    /** The name GIR gives the parameter. */
     name: string;
+    /** What the parameter holds, absent when the GIR node declares no type. */
     type: TypeId | undefined;
+    /** The C spelling of the parameter's type, taken from its `type` or `array` child. */
+    cType: string | undefined;
+    /** Documentation prose from GIR, emitted as the parameter's `@param` text. */
+    doc: string | undefined;
+    /** Decides whether the parameter is an argument, part of the returned tuple, or both. */
     direction: ParameterDirection;
+    /** Ownership the marshalling descriptor is generated with, deciding whether the receiver frees the value. */
     transferOwnership: ParameterTransfer;
+    /** Whether the value may be null. */
     nullable: boolean;
+    /** Whether the caller may leave the parameter out entirely. */
     optional: boolean;
+    /** Whether the caller supplies the storage an out parameter writes into. */
     callerAllocates: boolean;
+    /** How long a callback parameter stays valid, absent when GIR carries no scope annotation. */
     scope: CallbackScope | undefined;
+    /** Position of the parameter carrying the callback's user data. */
     closureIndex: number | undefined;
+    /** Position of the parameter carrying the callback's destroy notify. */
     destroyIndex: number | undefined;
+    /** Whether the parameter is the `...` varargs marker. */
     isVarargs: boolean;
 };
 
+/** What a {@link GirCallable} hands back, with the annotations that decide how it is marshalled. */
 type GirReturnValue = {
+    /** What the callable returns, absent when the GIR node declares no type. */
     type: TypeId | undefined;
+    /** Documentation prose from GIR, emitted as the callable's `@returns` text. */
+    doc: string | undefined;
+    /** How much ownership the caller takes of the returned value. */
     transferOwnership: ParameterTransfer;
+    /** Whether the returned value may be null. */
     nullable: boolean;
+    /** Whether GIR marks the value as skipped, keeping it out of the generated signature. */
     skip: boolean;
 };
 
+/** Anything GIR describes with parameters and a return value: functions, methods, signals, and callbacks. */
 type GirCallable = {
+    /** The name GIR gives the callable. */
     name: string;
+    /** The callable's documentation text, absent when GIR carries none. */
     doc: string | undefined;
+    /** Release and deprecation annotations GIR carries on the callable. */
+    annotations: GirAnnotations;
+    /** The parameters the callable takes, in declaration order. */
     parameters: GirParameter[];
+    /** What the callable hands back. */
     returnValue: GirReturnValue;
+    /** Whether the callable reports failure through a trailing `GError`. */
     throws: boolean;
+    /** Whether GIR exposes the callable to bindings. */
     introspectable: boolean;
 };
 
@@ -53,10 +92,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";
 
@@ -66,9 +101,14 @@ const hasNullableAttr = (node: RawNode): boolean =>
 const hasOptionalAttr = (node: RawNode): boolean =>
     isAttrTrue(node, "optional") || (!isInDirection(node) && isAttrTrue(node, "allow-none"));
 
+const parameterCType = (node: RawNode): string | undefined =>
+    attr(getChild(node, "type"), "c:type") ?? attr(getChild(node, "array"), "c:type");
+
 const parameterFromNode = (node: RawNode, context: ParseContext): GirParameter => ({
     name: nameAttr(node),
     type: typeRefFromNode(node, context),
+    cType: parameterCType(node),
+    doc: getDoc(node),
     direction: parseEnumAttr(attr(node, "direction"), DIRECTIONS, "in", "direction"),
     transferOwnership: transferOwnership(node),
     nullable: hasNullableAttr(node),
@@ -90,11 +130,12 @@ const isInoutParameter = (parameter: GirParameter): boolean => parameter.directi
 
 const returnValueFromNode = (node: RawNode | undefined, context: ParseContext): GirReturnValue => {
     if (node === undefined) {
-        return { type: undefined, transferOwnership: "none", nullable: false, skip: false };
+        return { type: undefined, doc: undefined, transferOwnership: "none", nullable: false, skip: false };
     }
 
     return {
         type: typeRefFromNode(node, context),
+        doc: getDoc(node),
         transferOwnership: transferOwnership(node),
         nullable: hasNullableAttr(node),
         skip: isAttrTrue(node, "skip"),
@@ -106,8 +147,7 @@ const parseCallable = (node: RawNode, context: ParseContext): GirCallable => {
     const parameterNodes = getChildren(parametersNode, "parameter");
 
     return {
-        name: nameAttr(node),
-        doc: getDoc(node),
+        ...documentedFromNode(node),
         parameters: parameterNodes.map((parameter) => parameterFromNode(parameter, context)),
         returnValue: returnValueFromNode(getChild(node, "return-value"), context),
         throws: isAttrTrue(node, "throws"),

package/src/gir/parse.ts

@@ -1,6 +1,7 @@
 import { readFileSync } from "node:fs";
 import { createXmlParser } from "../xml.js";
 
+/** An element of the parsed GIR XML: attributes under `@_`-prefixed keys, children under their tag names. */
 type RawNode = Record<string, unknown>;
 
 const MULTI_TAGS: Set<string> = new Set([
@@ -16,6 +17,7 @@ const MULTI_TAGS: Set<string> = new Set([
     "alias",
     "union",
     "method",
+    "virtual-method",
     "constructor",
     "property",
     "field",
@@ -141,12 +143,12 @@ const docTextFromObject = (value: object): string | undefined => {
     return typeof text === "string" ? normalizeDoc(text) : undefined;
 };
 
-const getDoc = (node: RawNode | undefined): string | undefined => {
+const docElementText = (node: RawNode | undefined, tag: string): string | undefined => {
     if (node === undefined) {
         return undefined;
     }
 
-    const value = firstDocValue(node.doc);
+    const value = firstDocValue(node[tag]);
 
     if (typeof value === "string") {
         return normalizeDoc(value);
@@ -159,6 +161,9 @@ const getDoc = (node: RawNode | undefined): string | undefined => {
     return docTextFromObject(value);
 };
 
+const getDoc = (node: RawNode | undefined): string | undefined => docElementText(node, "doc");
+const getDocDeprecated = (node: RawNode | undefined): string | undefined => docElementText(node, "doc-deprecated");
+
 export {
     GIR_CONSTRUCTOR_TAG,
     parseGirFile,
@@ -170,5 +175,6 @@ export {
     getChildren,
     getChild,
     getDoc,
+    getDocDeprecated,
     type RawNode,
 };

package/src/gir/primitives.ts

@@ -1,3 +1,4 @@
+/** A fundamental C type GIR can name, collapsed to the marshalling category GTKX treats it as. */
 type PrimitiveCategory =
     | "void" |
     "boolean" |

package/src/gir/property.ts

@@ -1,20 +1,36 @@
 import type { ParseContext, TypeId } from "./type-id.js";
+import { documentedFromNode, type GirAnnotations } from "./annotations.js";
 import { type ParameterTransfer, transferOwnership } from "./parameter.js";
-import { attr, getDoc, isAttrTrue, nameAttr, type RawNode } from "./parse.js";
+import { attr, isAttrTrue, type RawNode } from "./parse.js";
 import { typeRefFromNode } from "./type-ref.js";
 
+/** A GObject property declared on a class or interface, with the annotations its accessors are generated from. */
 type GirProperty = {
+    /** Canonical property name, dashed the way GObject registers it. */
     name: string;
+    /** Documentation prose from GIR, emitted as the accessor's JSDoc. */
     doc: string | undefined;
+    /** Release and deprecation annotations GIR carries on the property. */
+    annotations: GirAnnotations;
+    /** The property's value type, absent when GIR declares none. */
     type: TypeId | undefined;
+    /** Whether GObject exposes the value for reading, which admits a generated getter. */
     readable: boolean;
+    /** Whether GObject accepts a value for the property, which admits a generated setter. */
     writable: boolean;
+    /** Whether GObject sets the property during construction, using its default when none is supplied. */
     construct: boolean;
+    /** Whether the property can only be set at construction. */
     constructOnly: boolean;
+    /** Whether GIR exposes the property to bindings. */
     introspectable: boolean;
+    /** How ownership of the value transfers, which decides the descriptor the accessors marshal through. */
     transferOwnership: ParameterTransfer;
+    /** Method GIR names as reading the property, which the generated getter delegates to. */
     getter: string | undefined;
+    /** Method GIR names as writing the property, which the generated setter delegates to. */
     setter: string | undefined;
+    /** The property's default, as GIR spells it. */
     defaultValue: string | undefined;
 };
 
@@ -22,8 +38,7 @@ const isConstructableProperty = (property: GirProperty): boolean =>
     property.writable || property.construct || property.constructOnly;
 
 const propertyFromNode = (node: RawNode, context: ParseContext): GirProperty => ({
-    name: nameAttr(node),
-    doc: getDoc(node),
+    ...documentedFromNode(node),
     type: typeRefFromNode(node, context),
     readable: isAttrTrue(node, "readable", true),
     writable: isAttrTrue(node, "writable"),

package/src/gir/record.ts

@@ -1,26 +1,48 @@
 import type { ParseContext } from "./type-id.js";
+import { documentedFromNode, type GirAnnotations } from "./annotations.js";
 import { collectFields, type GirField } from "./field.js";
 import { functionFromNode, type GirFunction } from "./function.js";
-import { attr, getChildren, getDoc, GIR_CONSTRUCTOR_TAG, isAttrTrue, type RawNode } from "./parse.js";
+import { attr, getChildren, GIR_CONSTRUCTOR_TAG, isAttrTrue, type RawNode } from "./parse.js";
 
+/** A C struct or union declared by a GIR namespace: a plain record, a boxed type, or a GObject vtable. */
 type GirRecord = {
+    /** Whether the record is the class or interface struct holding another type's virtual methods. */
     isVtable: boolean;
+    /** Name within the declaring namespace, such as `"TextIter"`. */
     name: string;
+    /** Raw gtk-doc text from the GIR, undefined when the record is undocumented. */
     doc: string | undefined;
+    /** Release and deprecation annotations GIR carries on the record. */
+    annotations: GirAnnotations;
+    /** C struct name, such as `"GtkTextIter"`. */
     cType: string | undefined;
+    /** GLib type name the record is registered under, present when it is a boxed type. */
     glibTypeName: string | undefined;
+    /** Name of the function registering the record's GType, such as `"gtk_text_iter_get_type"`. */
     glibGetType: string | undefined;
+    /** Name of the function taking a reference, for reference-counted records. */
     glibRefFunc: string | undefined;
+    /** Name of the function dropping a reference, for reference-counted records. */
     glibUnrefFunc: string | undefined;
+    /** Name of the function duplicating an instance, used when the record has no ref function. */
     copyFunc: string | undefined;
+    /** Name of the function releasing an instance, used when the record has no unref function. */
     freeFunc: string | undefined;
+    /** Whether the struct is only ever handled behind a pointer, so its layout stays hidden. */
     disguised: boolean;
+    /** Whether the struct's fields are private, so instances cannot be allocated or read directly. */
     opaque: boolean;
+    /** Whether the record is exposed to language bindings. */
     introspectable: boolean;
+    /** Struct members: the named fields first, then the anonymous inline unions, then the inline records. */
     fields: GirField[];
+    /** Functions taking an instance of the record as their first argument. */
     methods: GirFunction[];
+    /** Functions returning a new instance of the record. */
     constructors: GirFunction[];
+    /** Functions scoped to the record but taking no instance. */
     functions: GirFunction[];
+    /** Whether the record is a union, so its fields overlap instead of following one another. */
     isUnion: boolean;
 };
 
@@ -31,8 +53,8 @@ const recordFromNode = (
     context: ParseContext,
 ): GirRecord => ({
     isVtable,
+    ...documentedFromNode(node),
     name: attr(node, "name") ?? attr(node, "glib:name") ?? "",
-    doc: getDoc(node),
     cType: attr(node, "c:type"),
     glibTypeName: attr(node, "glib:type-name"),
     glibGetType: attr(node, "glib:get-type"),

package/src/gir/size.ts

@@ -11,6 +11,11 @@ type FieldSlot = {
     bitWidth: number | undefined;
 };
 
+type FieldSlots = {
+    slots: FieldSlot[];
+    size: number;
+};
+
 type FieldLayoutInput = {
     layout: FieldLayout;
     bits: number | undefined;
@@ -39,7 +44,7 @@ const roundUp = (value: number, multiple: number): number => {
     return remainder === 0 ? value : value + (multiple - remainder);
 };
 
-const computeUnionSlots = (fields: FieldLayoutInput[]): { slots: FieldSlot[]; size: number } => {
+const computeUnionSlots = (fields: FieldLayoutInput[]): FieldSlots => {
     let maxSize = 0;
     let maxAlign = 1;
 
@@ -59,9 +64,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[];
@@ -98,7 +100,7 @@ const processStructField = (state: StructLayoutState, slots: FieldSlot[], field:
     pushBitfield({ state, slots, field, align, bits: field.bits });
 };
 
-const computeStructSlots = (fields: FieldLayoutInput[]): { slots: FieldSlot[]; size: number } => {
+const computeStructSlots = (fields: FieldLayoutInput[]): FieldSlots => {
     const slots: FieldSlot[] = [];
     const state: StructLayoutState = { bitCursor: 0, maxAlign: 1 };
 
@@ -109,7 +111,7 @@ const computeStructSlots = (fields: FieldLayoutInput[]): { slots: FieldSlot[]; s
     return { slots, size: roundUp(roundUp(state.bitCursor, 8) / 8, state.maxAlign) };
 };
 
-const computeFieldSlots = (fields: FieldLayoutInput[], isUnion = false): { slots: FieldSlot[]; size: number } =>
+const computeFieldSlots = (fields: FieldLayoutInput[], isUnion = false): FieldSlots =>
     isUnion ? computeUnionSlots(fields) : computeStructSlots(fields);
 
 export { layoutOfPrimitive, computeFieldSlots, type FieldLayout, type FieldSlot, type FieldLayoutInput };

package/src/gir/type-id.ts

@@ -1,43 +1,89 @@
 import type { RawNode } from "./parse.js";
 import type { PrimitiveCategory } from "./primitives.js";
 
-type TypeId = { nsId: number; id: number };
+/** A reference to a parsed type: the type table holding it, and its slot in that table. */
+type TypeId = {
+    /** Id of the table holding the type: a namespace's, or the internal one primitives and varargs intern into. */
+    nsId: number;
+    /** Slot the type occupies in that table. */
+    id: number;
+};
+
+/** Which GLib container a {@link ListType} is. */
 type ListFlavor = (typeof LIST_FLAVOR_BY_NAME)[keyof typeof LIST_FLAVOR_BY_NAME];
-type PrimitiveType = { kind: "primitive"; category: PrimitiveCategory };
-type VarargsType = { kind: "varargs" };
 
+/** A type that marshals directly as a value, such as `gint` or `utf8`. */
+type PrimitiveType = {
+    /** Discriminates {@link StructuralType}. */
+    kind: "primitive";
+    /** The scalar the type marshals as. */
+    category: PrimitiveCategory;
+};
+
+/** The trailing `...` argument list of a variadic C function. */
+type VarargsType = {
+    /** Discriminates {@link StructuralType}. */
+    kind: "varargs";
+};
+
+/** A C array, along with whatever the GIR says about how its length is determined. */
 type CArrayType = {
+    /** Discriminates {@link StructuralType}. */
     kind: "carray";
+    /** Type of the array's elements, paired with `elementCType` to build the element descriptor. */
     element: TypeId;
+    /** C declaration of an element, which tells an inline struct apart from a pointer to one. */
     elementCType: string | undefined;
+    /** C declaration of the array itself. */
+    arrayCType: string | undefined;
+    /** Index of the parameter, or of the sibling record field, carrying the length. */
     lengthParameterIndex: number | undefined;
+    /** Element count when the array has a fixed size. */
     fixedSize: number | undefined;
-    zeroTerminated: boolean;
+    /** Whether the array ends at a null element. */
+    isZeroTerminated: boolean;
 };
 
+/** A GLib list or array container over a single element type. */
 type ListType = {
+    /** Discriminates {@link StructuralType}. */
     kind: "list";
+    /** Which container the type is. */
     flavor: ListFlavor;
+    /** Type the container's elements marshal as, which the list descriptor wraps. */
     element: TypeId;
 };
 
+/** A `GLib.HashTable`. */
 type HashTableType = {
+    /** Discriminates {@link StructuralType}. */
     kind: "hashtable";
+    /** Type the keys marshal as, rendered as the key half of a `Record` or `Map`. */
     key: TypeId;
+    /** Type the values marshal as, rendered as the value half of a `Record` or `Map`. */
     value: TypeId;
 };
 
+/** A type the GIR describes by its structure rather than by a name it declares. */
 type StructuralType = PrimitiveType | VarargsType | CArrayType | ListType | HashTableType;
 
+/** The hooks the GIR parsers use to reference and register types while walking one namespace. */
 type ParseContext = {
+    /** Id of the namespace being parsed. */
     nsId: number;
+    /** Resolves a GIR type name, optionally namespace-qualified, reserving a slot when it is not parsed yet. */
     findType(name: string): TypeId;
+    /** Interns a primitive type and returns its id. */
     addPrimitive(category: PrimitiveCategory): TypeId;
+    /** Interns the varargs type and returns its id. */
     addVarargs(): TypeId;
+    /** Registers an unnamed container type in the namespace and returns its id. */
     addContainer(type: CArrayType | ListType | HashTableType): TypeId;
+    /** Parses an inline `<callback>` node, registers it as an unnamed type, and returns its id. */
     addAnonymousCallback(node: RawNode): TypeId;
 };
 
+/** GIR type names of the GLib containers, mapped to the {@link ListFlavor} each one parses to. */
 const LIST_FLAVOR_BY_NAME = {
     "GLib.List": "glist",
     "GLib.SList": "gslist",
@@ -46,10 +92,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

@@ -88,9 +88,10 @@ const arrayTypeRefFromNode = (arrayNode: RawNode, context: ParseContext): TypeId
         kind: "carray",
         element,
         elementCType: elementNode === undefined ? undefined : attr(elementNode, "c:type"),
+        arrayCType: attr(arrayNode, "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/gir/type.ts

@@ -5,14 +5,58 @@ import type { GirAlias, GirNamespace } from "./namespace.js";
 import type { GirRecord } from "./record.js";
 import type { StructuralType } from "./type-id.js";
 
+/** A named entity a GIR namespace declares, discriminated by `kind` and carrying the parsed node. */
 type EntityType =
-    | { kind: "class"; namespace: GirNamespace; value: GirClass } |
-    { kind: "interface"; namespace: GirNamespace; value: GirClass } |
-    { kind: "record"; namespace: GirNamespace; value: GirRecord } |
-    { kind: "enum"; namespace: GirNamespace; value: GirEnum } |
-    { kind: "callback"; namespace: GirNamespace; value: GirCallback } |
-    { kind: "alias"; namespace: GirNamespace; value: GirAlias };
+    | {
+        /** Discriminates {@link EntityType}. */
+        kind: "class";
+        /** Namespace declaring the class. */
+        namespace: GirNamespace;
+        /** Parsed class, carrying its GType metadata and the members it declares. */
+        value: GirClass;
+    } |
+    {
+        /** Discriminates {@link EntityType}. */
+        kind: "interface";
+        /** Namespace declaring the interface. */
+        namespace: GirNamespace;
+        /** Parsed interface, modeled the same way as a class. */
+        value: GirClass;
+    } |
+    {
+        /** Discriminates {@link EntityType}. */
+        kind: "record";
+        /** Namespace declaring the record. */
+        namespace: GirNamespace;
+        /** Parsed record, either a struct or a union. */
+        value: GirRecord;
+    } |
+    {
+        /** Discriminates {@link EntityType}. */
+        kind: "enum";
+        /** Namespace declaring the enumeration. */
+        namespace: GirNamespace;
+        /** Parsed enumeration or bitfield. */
+        value: GirEnum;
+    } |
+    {
+        /** Discriminates {@link EntityType}. */
+        kind: "callback";
+        /** Namespace declaring the callback. */
+        namespace: GirNamespace;
+        /** Parsed callback signature. */
+        value: GirCallback;
+    } |
+    {
+        /** Discriminates {@link EntityType}. */
+        kind: "alias";
+        /** Namespace declaring the alias. */
+        namespace: GirNamespace;
+        /** Parsed alias, holding the type it stands for. */
+        value: GirAlias;
+    };
 
+/** What a GIR type reference resolves to: a structural type, or an entity a namespace declares. */
 type GirType = StructuralType | EntityType;
 
 export { type EntityType, type GirType };

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";