@gtkx/codegen 1.1.0 → 1.2.1

package/src/analysis/descriptor.ts

@@ -87,6 +87,11 @@ type FundamentalOptions = {
 
 type ListDescriptorName = "list" | "slist" | "ptrArray" | "gArray";
 
+type ArrayLayout = {
+    elementSize?: number | undefined;
+    isBytes: boolean;
+};
+
 type BindArgs = {
     libExpr: string;
     symbolExpr: string;
@@ -156,6 +161,7 @@ const tUint8: string = T.uint8;
 const tUint32: string = T.uint32;
 const tInt32: string = T.int32;
 const tUint64: string = T.uint64;
+const tBiguint64: string = T.biguint64;
 const tGtype: string = T.gtype;
 const tBuffer: string = T.buffer;
 
@@ -229,44 +235,69 @@ const tFlags = (lib: string, typeFnName: string, isSigned: boolean): string =>
 
 const tByteArray = (ownership: Ownership): string => call("byteArray", [sourceStringLiteral(ownership)]);
 
+const tNumericByteArray = (ownership: Ownership): string =>
+    call("array", [
+        tUint8,
+        sourceStringLiteral("gbytearray"),
+        sourceStringLiteral(ownership),
+    ]);
+
 const tList = (name: ListDescriptorName, element: string, ownership: Ownership): string =>
     call(name, [element, sourceStringLiteral(ownership)]);
 
-const tArray = (element: string, ownership?: Ownership, elementSize?: number): string =>
+const arrayLayoutArg = (ownership: Ownership | undefined, layout: ArrayLayout): string | undefined => {
+    if (ownership === undefined) {
+        return undefined;
+    }
+
+    const entries = [
+        layout.elementSize === undefined ? undefined : `elementSize: ${String(layout.elementSize)}`,
+        layout.isBytes ? "isBytes: true" : undefined,
+    ].filter((entry): entry is string => entry !== undefined);
+
+    return entries.length === 0 ? undefined : `{ ${entries.join(", ")} }`;
+};
+
+const tArray = (element: string, ownership: Ownership | undefined, layout: ArrayLayout): string =>
     call("array", [
         element,
         ownership === undefined ? undefined : sourceStringLiteral("array"),
         ownership === undefined ? undefined : sourceStringLiteral(ownership),
-        elementSize === undefined ? undefined : `{ elementSize: ${String(elementSize)} }`,
+        arrayLayoutArg(ownership, layout),
     ]);
 
 const tSizedArray = (
     element: string,
     lengthIndex: number,
-    ownership?: Ownership,
-    elementSize?: number,
+    ownership: Ownership | undefined,
+    layout: ArrayLayout,
 ): string =>
     call("sizedArray", [
         element,
         String(lengthIndex),
         ownership === undefined ? undefined : sourceStringLiteral(ownership),
-        elementSize === undefined ? undefined : String(elementSize),
+        arrayLayoutArg(ownership, layout),
     ]);
 
-const tCursorArray = (element: string, bounds: GirCursorBounds, ownership?: Ownership, elementSize?: number): string =>
+const tCursorArray = (
+    element: string,
+    bounds: GirCursorBounds,
+    ownership: Ownership | undefined,
+    layout: ArrayLayout,
+): string =>
     call("cursorArray", [
         element,
         `{ baseParamIndex: ${String(bounds.baseIndex)}, sizeParamIndex: ${String(bounds.lengthIndex)} }`,
         ownership === undefined ? undefined : sourceStringLiteral(ownership),
-        elementSize === undefined ? undefined : String(elementSize),
+        arrayLayoutArg(ownership, layout),
     ]);
 
-const tFixedArray = (element: string, length: number, ownership?: Ownership, elementSize?: number): string =>
+const tFixedArray = (element: string, length: number, ownership: Ownership | undefined, layout: ArrayLayout): string =>
     call("fixedArray", [
         element,
         String(length),
         ownership === undefined ? undefined : sourceStringLiteral(ownership),
-        elementSize === undefined ? undefined : String(elementSize),
+        arrayLayoutArg(ownership, layout),
     ]);
 
 const tCallback = (spec: CallbackSpecParts): string => {
@@ -296,6 +327,7 @@ export {
     tUint32,
     tInt32,
     tUint64,
+    tBiguint64,
     tGtype,
     tBuffer,
     tScalar,
@@ -310,6 +342,7 @@ export {
     tEnum,
     tFlags,
     tByteArray,
+    tNumericByteArray,
     tList,
     tArray,
     tSizedArray,
@@ -318,6 +351,7 @@ export {
     tCallback,
     tBind,
     tFn,
+    type ArrayLayout,
     type Ownership,
     type ScalarDescriptorName,
     type ListDescriptorName,

package/src/analysis/interface-conflicts.ts

@@ -217,21 +217,19 @@ const prerequisiteConflicts = (library: Library, iface: GirClass, base: Resolved
     return names;
 };
 
-const omittedTypeRef = (typeRef: string, omissions: string[]): string => {
-    if (omissions.length === 0) {
-        return typeRef;
-    }
-
-    const keys = [...new Set(omissions)].map((name) => JSON.stringify(name)).join(" | ");
+const omittedKeys = (omissions: string[]): string =>
+    [...new Set(omissions)].map((name) => JSON.stringify(name)).join(" | ");
 
-    return `Omit<${typeRef}, ${keys}>`;
-};
+const omittedTypeRef = (typeRef: string, omissions: string[]): string =>
+    omissions.length === 0 ? typeRef : `Omit<${typeRef}, ${omittedKeys(omissions)}>`;
 
 export {
+    areCallablesAssignable,
     type ClaimedMembers,
     claimInterfaceMembers,
     inheritedMembers,
     interfaceConflicts,
+    omittedKeys,
     omittedTypeRef,
     prerequisiteConflicts,
 };

package/src/analysis/ts-type.ts

@@ -12,6 +12,7 @@ import {
     type TypeId,
 } from "../gir/type-id.js";
 import { gtypeTsType } from "../store/gi/gtype-binding.js";
+import { isByteSequence } from "./type-shape.js";
 
 type ReferenceName = {
     namespaceName: string;
@@ -21,11 +22,15 @@ type ReferenceName = {
 type TsTypeTarget = {
     containerStyle: "map" | "record";
     callbackType: string;
-    shouldRenderByteArrayAsNumber: boolean;
+    byteArrayType: string;
     renderNamed: (resolved: GirType | undefined, name: ReferenceName) => string;
     renderGtype: () => string;
 };
 
+const BYTE_ARRAY_TYPE = "Uint8Array";
+const BYTE_ARRAY_INPUT_TYPE = "Uint8Array | number[]";
+const NUMBER_ARRAY_TYPE = "number[]";
+
 const willEmitEntity = (type: EntityType): boolean => isEmittableEntity(type.value);
 
 const referenceName = (library: Library, ref: TypeId): ReferenceName | undefined => {
@@ -97,14 +102,14 @@ const renderContainerType = (
 };
 
 const renderSequenceType = (library: Library, target: TsTypeTarget, type: CArrayType | ListType): string => {
-    if (type.kind === "list" && type.flavor === "gbytearray" && target.shouldRenderByteArrayAsNumber) {
-        return "number[]";
-    }
-
     if (type.kind === "carray" && hasUnknownArrayLength(type)) {
         return "number";
     }
 
+    if (isByteSequence(library, type)) {
+        return target.byteArrayType;
+    }
+
     return `${renderBaseType(library, target, type.element)}[]`;
 };
 
@@ -120,20 +125,34 @@ const renderNamedType = (
     return target.renderNamed(resolved, name);
 };
 
-const moduleTarget = (context: ModuleContext): TsTypeTarget => ({
+const getByteArrayType = (library: Library): string =>
+    library.isByteArrayTyped ? BYTE_ARRAY_TYPE : NUMBER_ARRAY_TYPE;
+
+const moduleTarget = (context: ModuleContext, byteArrayType: string): TsTypeTarget => ({
     containerStyle: "map",
     callbackType: "((...args: any[]) => any)",
-    shouldRenderByteArrayAsNumber: true,
+    byteArrayType,
     renderNamed: (_resolved, name) => context.qualify(name.namespaceName, name.typeName),
     renderGtype: () => gtypeTsType(context),
 });
 
-const renderTsType = (context: ModuleContext, ref: TypeId | undefined, isNullable = false): string => {
-    const base = renderBaseType(context.library, moduleTarget(context), ref);
+const renderModuleType = (
+    context: ModuleContext,
+    ref: TypeId | undefined,
+    isNullable: boolean,
+    byteArrayType: string,
+): string => {
+    const base = renderBaseType(context.library, moduleTarget(context, byteArrayType), ref);
 
     return isNullable ? `${base} | null` : base;
 };
 
+const renderTsType = (context: ModuleContext, ref: TypeId | undefined, isNullable = false): string =>
+    renderModuleType(context, ref, isNullable, getByteArrayType(context.library));
+
+const renderParameterTsType = (context: ModuleContext, ref: TypeId | undefined, isNullable = false): string =>
+    renderModuleType(context, ref, isNullable, BYTE_ARRAY_INPUT_TYPE);
+
 const recordTypeTarget = (
     library: Library,
     renderNamedRef: (name: ReferenceName) => string,
@@ -142,7 +161,7 @@ const recordTypeTarget = (
     const target: TsTypeTarget = {
         containerStyle: "record",
         callbackType: "((...args: unknown[]) => unknown)",
-        shouldRenderByteArrayAsNumber: false,
+        byteArrayType: getByteArrayType(library),
         renderNamed: (resolved, name) => {
             if (resolved?.kind === "alias") {
                 return resolved.value.target === undefined
@@ -158,4 +177,4 @@ const recordTypeTarget = (
     return target;
 };
 
-export { renderBaseType, renderTsType, recordTypeTarget, type TsTypeTarget };
+export { renderBaseType, renderParameterTsType, renderTsType, recordTypeTarget, type TsTypeTarget };

package/src/analysis/type-shape.ts

@@ -1,6 +1,6 @@
 import type { Library } from "../gir/library.js";
 import type { PrimitiveCategory } from "../gir/primitives.js";
-import type { CArrayType, TypeId } from "../gir/type-id.js";
+import type { CArrayType, ListType, TypeId } from "../gir/type-id.js";
 import type { GirType } from "../gir/type.js";
 
 const resolvedTypeFor = (library: Library, ref: TypeId | undefined): GirType | undefined =>
@@ -21,4 +21,7 @@ const primitiveCategoryFor = (library: Library, ref: TypeId | undefined): Primit
 const isUnboundedArray = (type: CArrayType): boolean =>
     type.isZeroTerminated && type.lengthParameterIndex === undefined && type.fixedSize === undefined;
 
-export { carrayFor, isUnboundedArray, primitiveCategoryFor };
+const isByteSequence = (library: Library, type: CArrayType | ListType): boolean =>
+    type.kind === "list" ? type.flavor === "gbytearray" : primitiveCategoryFor(library, type.element) === "uint8";
+
+export { carrayFor, isByteSequence, isUnboundedArray, primitiveCategoryFor };

package/src/compile.ts

@@ -1,4 +1,4 @@
-import { errorMessage, normalizeError } from "@gtkx/utils";
+import { errorCode, errorMessage, normalizeError } from "@gtkx/utils";
 import { existsSync, mkdirSync, renameSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -14,10 +14,19 @@ type SourceModule = ProjectFile & {
     source: string;
 };
 
-type CompileProjectParams = {
+type ProjectContext = {
     projectDir: string;
     files: ProjectFile[];
+    label: string;
+};
+
+type CompileProjectParams = ProjectContext & {
     compilerOptions: Record<string, unknown>;
+};
+
+type EmitModulesParams = {
+    projectDir: string;
+    files: SourceModule[];
     label: string;
 };
 
@@ -60,9 +69,33 @@ const CHECK_OPTIONS = {
     noEmit: true,
 };
 
+const DECLARATION_EMIT = {
+    declaration: true,
+    isolatedDeclarations: true,
+    removeComments: false,
+};
+
+const MODULE_EMIT = {
+    removeComments: false,
+};
+
+const DECLARATION_OPTIONS = ts.convertCompilerOptionsFromJson(
+    { ...BASE_COMPILER_OPTIONS, ...DECLARATION_EMIT },
+    ".",
+).options;
+
+const MODULE_OPTIONS = ts.convertCompilerOptionsFromJson(
+    { ...BASE_COMPILER_OPTIONS, ...MODULE_EMIT },
+    ".",
+).options;
+
+const TS_EXTENSION_PATTERN = /\.tsx?$/;
+const DECLARATION_EXTENSION = ".d.ts";
+const JAVASCRIPT_EXTENSION = ".js";
 const CHECK_DIR = ".gtkx-check";
 const FAILED_CHECK_DIR = `${CHECK_DIR}.failed`;
 const LEGACY_CHECK_PREFIX = `${CHECK_DIR}-`;
+const ESM_SCOPE_MANIFEST = `${JSON.stringify({ type: "module" }, null, 4)}\n`;
 
 const FORMAT_HOST: ts.FormatDiagnosticsHost = {
     getCanonicalFileName: (fileName) => fileName,
@@ -90,6 +123,16 @@ const linkToolingModules = (projectDir: string): (() => void) => {
     };
 };
 
+const ensureModuleScope = (projectDir: string): void => {
+    try {
+        writeFileSync(join(projectDir, "package.json"), ESM_SCOPE_MANIFEST, { flag: "wx" });
+    } catch (error) {
+        if (errorCode(error) !== "EEXIST") {
+            throw error;
+        }
+    }
+};
+
 const isProjectFile = (rel: string): boolean =>
     !rel.startsWith("..") && !isAbsolute(rel) && !rel.split(/[/\\]/).includes("node_modules");
 
@@ -160,17 +203,17 @@ const originLines = (diagnosed: DiagnosedFile[], files: ProjectFile[]): string[]
         ([origin, generated]) => `Generated from ${origin}: ${[...generated].join(", ")}`,
     );
 
-const diagnosticError = (params: CompileProjectParams, diagnostics: ts.Diagnostic[]): Error => {
+const diagnosticError = (params: ProjectContext, diagnostics: ts.Diagnostic[]): Error => {
     const diagnosed = projectDiagnosticFiles(diagnostics, params.projectDir);
     const { label } = params;
 
     if (diagnosed.length === 0) {
-        return new Error(`Type checking ${label} failed:\n${ts.formatDiagnostics(diagnostics, FORMAT_HOST).trim()}`);
+        return new Error(`Compiling ${label} failed:\n${ts.formatDiagnostics(diagnostics, FORMAT_HOST).trim()}`);
     }
 
     const lines = [...diagnosed.map((entry) => entry.text), ...originLines(diagnosed, params.files)];
 
-    return new Error(`Type checking ${label} found ${String(diagnosed.length)} error(s):\n${lines.join("\n")}`);
+    return new Error(`Compiling ${label} found ${String(diagnosed.length)} error(s):\n${lines.join("\n")}`);
 };
 
 const keepFailedProject = (input: FailedProjectInput): Error => {
@@ -214,7 +257,45 @@ const runProgram = (params: CompileProjectParams): ts.Diagnostic[] => {
     return [...program.emit().diagnostics];
 };
 
+const replaceExtension = (fileName: string, extension: string): string =>
+    `${fileName.replace(TS_EXTENSION_PATTERN, "")}${extension}`;
+
+const transpileOptions = (compilerOptions: ts.CompilerOptions, fileName: string): ts.TranspileOptions => ({
+    compilerOptions,
+    fileName,
+    reportDiagnostics: true,
+});
+
+const emitModule = (module: SourceModule, projectDir: string): ts.Diagnostic[] => {
+    const fileName = join(projectDir, module.fileName);
+    const declaration = ts.transpileDeclaration(module.source, transpileOptions(DECLARATION_OPTIONS, fileName));
+    const javascript = ts.transpileModule(module.source, transpileOptions(MODULE_OPTIONS, fileName));
+    const diagnostics = [...declaration.diagnostics ?? [], ...javascript.diagnostics ?? []];
+
+    if (diagnostics.length > 0) {
+        return diagnostics;
+    }
+
+    writeFileSync(replaceExtension(fileName, DECLARATION_EXTENSION), declaration.outputText);
+    writeFileSync(replaceExtension(fileName, JAVASCRIPT_EXTENSION), javascript.outputText);
+
+    return [];
+};
+
+const emitModules = (params: EmitModulesParams): void => {
+    const diagnostics: ts.Diagnostic[] = [];
+
+    for (const module of params.files) {
+        diagnostics.push(...emitModule(module, params.projectDir));
+    }
+
+    if (diagnostics.length > 0) {
+        throw diagnosticError(params, diagnostics);
+    }
+};
+
 const compileProject = (params: CompileProjectParams): void => {
+    ensureModuleScope(params.projectDir);
     const unlinkToolingModules = linkToolingModules(params.projectDir);
 
     try {
@@ -261,4 +342,4 @@ const checkModules = (params: { modules: SourceModule[]; resolveFrom: string; la
     rmSync(keepAt, { recursive: true, force: true });
 };
 
-export { compileProject, checkModules, keepFailedProject, type ProjectFile, type SourceModule };
+export { checkModules, emitModules, keepFailedProject, type SourceModule };

package/src/docs/api-reference.ts

@@ -24,6 +24,8 @@ type ApiReferenceOptions = {
     props?: ElementProps;
     /** GObject properties the project omits from generated props; without it pages show props that do not exist. */
     omittedProps?: OmittedProps;
+    /** Describes GIR byte sequences as `Uint8Array` rather than `number[]`; defaults to false. */
+    isByteArrayTyped?: boolean;
 };
 
 /** Narrows an `ApiReference.symbols` enumeration. */
@@ -371,7 +373,7 @@ class ApiReference {
         this.libraries = options.libraries;
         this.props = options.props ?? {};
         this.omittedProps = options.omittedProps ?? {};
-        this.library = Library.load(options.libraries, options.girPath);
+        this.library = Library.load(options.libraries, options.girPath, options.isByteArrayTyped === true);
         this.elementContext = { library: this.library, linkFor: (): string | undefined => undefined };
         this.buildIndex();
     }

package/src/docs/pipeline.ts

@@ -5,6 +5,7 @@ import {
     computeDocsFingerprint,
     type DocsFingerprintInput,
     FINGERPRINT_FILENAME,
+    type GiInputs,
     isDocsOutputFresh,
 } from "../fingerprint.js";
 import { Library } from "../gir/library.js";
@@ -37,6 +38,7 @@ type DocsOptions = {
     props?: ElementProps;
     omittedProps?: OmittedProps;
     isForced?: boolean;
+    isByteArrayTyped?: boolean;
 };
 
 type DocsManifest = {
@@ -253,6 +255,13 @@ const outDirRefusal = (outDir: string, reason: string): Error =>
         "empty directory or at one gtkx generated, or remove it yourself first.",
     );
 
+const giInputs = (options: DocsOptions, girFiles: string[]): GiInputs => ({
+    girFiles,
+    libraries: options.libraries,
+    girPath: options.girPath,
+    isByteArrayTyped: options.isByteArrayTyped === true,
+});
+
 const assertOwnedOutDir = (options: DocsOptions, manifest: DocsManifest | undefined): void => {
     const stats = statSync(options.outDir, { throwIfNoEntry: false });
 
@@ -301,7 +310,7 @@ const cachedDocsResult = (
         return undefined;
     }
 
-    if (!isDocsOutputFresh(options.outDir, options.libraries, options.girPath, input)) {
+    if (!isDocsOutputFresh(options.outDir, giInputs(options, []), input)) {
         return undefined;
     }
 
@@ -335,18 +344,15 @@ const writeDocs = (options: DocsOptions): DocsResult => {
     }
 
     assertOwnedOutDir(options, previous);
-    const library = Library.load(options.libraries, options.girPath);
+    const library = Library.load(options.libraries, options.girPath, options.isByteArrayTyped === true);
     const { pages, namespaces } = generatePages(options, input.basePath, library);
     clearOutDir(options, previous);
     mkdirSync(options.outDir, { recursive: true });
     const manifest: DocsManifest = { generator: MANIFEST_GENERATOR, namespaces };
     writeFileSync(manifestPath, JSON.stringify(manifest));
     writePages(options.outDir, pages);
-
-    writeFileSync(
-        join(options.outDir, FINGERPRINT_FILENAME),
-        JSON.stringify(computeDocsFingerprint(library.girFiles, options.libraries, options.girPath, input)),
-    );
+    const fingerprint = computeDocsFingerprint(giInputs(options, library.girFiles), input);
+    writeFileSync(join(options.outDir, FINGERPRINT_FILENAME), JSON.stringify(fingerprint));
 
     return { isRegenerated: true, namespaces };
 };

package/src/docs/symbol-page.ts

@@ -16,7 +16,6 @@ import { PRIMITIVE_TS_TYPE, primitiveCategory } from "../gir/primitives.js";
 import { callableSpec } from "../store/gi/callable-doc.js";
 import {
     dedupeCallables,
-    indexMethodsByName,
     instanceScope,
     matchStaticFinishFunction,
     renderInstanceMethodSignature,
@@ -146,7 +145,6 @@ type MemberOwner = {
 type PropertyAccessorSetup = {
     context: ModuleContext;
     claimedNames: Set<string>;
-    methodByName: Map<string, GirFunction>;
 };
 
 type ResolvedRecordField = NonNullable<ReturnType<typeof resolveRecordFieldEntry>>;
@@ -391,7 +389,6 @@ const propertyAccessorSetup = (
     return {
         context: docsSignatureContext(owner.namespace, library),
         claimedNames,
-        methodByName: indexMethodsByName(dedupeCallables(owner.klass.methods)),
     };
 };
 
@@ -418,7 +415,6 @@ const ownerPropertyEntries = (owner: MemberOwner, setup: PropertyAccessorSetup,
             context: setup.context,
             property,
             claimedNames: setup.claimedNames,
-            methodByName: setup.methodByName,
         });
 
         if (accessor === undefined || seen.has(accessor.jsName)) {
@@ -637,7 +633,7 @@ const fieldsSection = (record: GirRecord, context: ModuleContext, claimedNames:
     const entries: MetaDocEntry[] = [];
 
     for (const slot of slots) {
-        const field = resolveRecordFieldEntry(context, slot, claimedNames);
+        const field = resolveRecordFieldEntry(context, slot, claimedNames, record.fields);
 
         if (field === undefined) {
             continue;

package/src/fingerprint.ts

@@ -7,6 +7,13 @@ import packageManifest from "../package.json" with { type: "json" };
 import { arrayGuard, hasFields, isNumber, isString, optionalGuard } from "./guards.js";
 import { readJsonFile } from "./json.js";
 
+type GiInputs = {
+    girFiles: string[];
+    libraries: string[];
+    girPath: string[];
+    isByteArrayTyped: boolean;
+};
+
 type GiFingerprint = {
     value: string;
     girFiles: string[];
@@ -56,15 +63,17 @@ const overrideFiles = (): string[] => {
         .map((entry: Dirent) => join(entry.parentPath, entry.name));
 };
 
-const hashGi = (girFiles: string[], libraries: string[], girPath: string[]): string => {
+const hashGi = (inputs: GiInputs): string => {
     const hash = createHash("sha256");
     hash.update(CODEGEN_VERSION);
     hash.update("\n");
-    hash.update(sortAlpha(libraries));
+    hash.update(sortAlpha(inputs.libraries));
+    hash.update("\n");
+    hash.update(sortAlpha(inputs.girPath));
     hash.update("\n");
-    hash.update(sortAlpha(girPath));
+    hash.update(String(inputs.isByteArrayTyped));
     hash.update("\n");
-    const hashedFiles = sortStrings([...girFiles, ...overrideFiles()]);
+    const hashedFiles = sortStrings([...inputs.girFiles, ...overrideFiles()]);
 
     for (const file of hashedFiles) {
         hash.update("\n");
@@ -76,15 +85,11 @@ const hashGi = (girFiles: string[], libraries: string[], girPath: string[]): str
     return hash.digest("hex");
 };
 
-const computeGiFingerprint = (
-    girFiles: string[],
-    libraries: string[],
-    girPath: string[],
-): GiFingerprint => ({
-    value: hashGi(girFiles, libraries, girPath),
-    girFiles,
-    libraries,
-    girPath,
+const computeGiFingerprint = (inputs: GiInputs): GiFingerprint => ({
+    value: hashGi(inputs),
+    girFiles: inputs.girFiles,
+    libraries: inputs.libraries,
+    girPath: inputs.girPath,
 });
 
 const readSentinel = (storeDir: string): unknown => readJsonFile(join(storeDir, FINGERPRINT_FILENAME));
@@ -103,30 +108,27 @@ const isDocsFingerprint = (value: unknown): value is DocsFingerprint =>
 const isJsxFingerprint = (value: unknown): value is JsxFingerprint =>
     hasFields<JsxFingerprint>(value, { value: isString, intrinsicElementCount: isNumber });
 
-const recordedGiValue = (sentinel: GiFingerprint, libraries: string[], girPath: string[]): string | undefined => {
-    if (!hasMatchingRecordedInputs(sentinel, libraries, girPath)) {
+const recordedGiValue = (sentinel: GiFingerprint, inputs: GiInputs): string | undefined => {
+    if (!hasMatchingRecordedInputs(sentinel, inputs)) {
         return undefined;
     }
 
     try {
-        return hashGi(sentinel.girFiles, sentinel.libraries, girPath);
+        return hashGi({ ...inputs, girFiles: sentinel.girFiles, libraries: sentinel.libraries });
     } catch {
         return undefined;
     }
 };
 
-const isGiStoreFresh = (
-    giStoreDir: string,
-    libraries: string[],
-    girPath: string[],
-): boolean => {
+const isGiStoreFresh = (giStoreDir: string, inputs: GiInputs): boolean => {
     const sentinel = readSentinel(giStoreDir);
 
-    return isGiFingerprint(sentinel) && recordedGiValue(sentinel, libraries, girPath) === sentinel.value;
+    return isGiFingerprint(sentinel) && recordedGiValue(sentinel, inputs) === sentinel.value;
 };
 
-const hasMatchingRecordedInputs = (sentinel: GiFingerprint, libraries: string[], girPath: string[]): boolean =>
-    sortAlpha(sentinel.libraries) === sortAlpha(libraries) && sortAlpha(sentinel.girPath ?? []) === sortAlpha(girPath);
+const hasMatchingRecordedInputs = (sentinel: GiFingerprint, inputs: GiInputs): boolean =>
+    sortAlpha(sentinel.libraries) === sortAlpha(inputs.libraries) &&
+    sortAlpha(sentinel.girPath ?? []) === sortAlpha(inputs.girPath);
 
 const hashDocs = (giValue: string, input: DocsFingerprintInput): string =>
     createHash("sha256")
@@ -140,30 +142,20 @@ const hashDocs = (giValue: string, input: DocsFingerprintInput): string =>
         )
         .digest("hex");
 
-const computeDocsFingerprint = (
-    girFiles: string[],
-    libraries: string[],
-    girPath: string[],
-    input: DocsFingerprintInput,
-): DocsFingerprint => {
-    const gi = computeGiFingerprint(girFiles, libraries, girPath);
+const computeDocsFingerprint = (inputs: GiInputs, input: DocsFingerprintInput): DocsFingerprint => {
+    const gi = computeGiFingerprint(inputs);
 
     return { value: hashDocs(gi.value, input), gi };
 };
 
-const isDocsOutputFresh = (
-    outDir: string,
-    libraries: string[],
-    girPath: string[],
-    input: DocsFingerprintInput,
-): boolean => {
+const isDocsOutputFresh = (outDir: string, inputs: GiInputs, input: DocsFingerprintInput): boolean => {
     const sentinel = readSentinel(outDir);
 
     if (!isDocsFingerprint(sentinel)) {
         return false;
     }
 
-    const giValue = recordedGiValue(sentinel.gi, libraries, girPath);
+    const giValue = recordedGiValue(sentinel.gi, inputs);
 
     return giValue !== undefined && hashDocs(giValue, input) === sentinel.value;
 };
@@ -217,6 +209,7 @@ export {
     computeJsxFingerprint,
     jsxStoreFreshness,
     type DocsFingerprintInput,
+    type GiInputs,
     type GiFingerprint,
     type JsxFingerprintInput,
 };