@gtkx/codegen 1.2.2 → 1.3.0

package/src/analysis/descriptor-render.ts

@@ -65,6 +65,7 @@ type ArgIndexOptions = {
 };
 
 type CursorArgIndexOptions = ArgIndexOptions & { cursor: GirCursorBounds };
+type CArrayExpressionOptions = ArgIndexOptions & { isCallerAllocated: boolean };
 
 type RenderDescriptorOptions = Partial<ArgIndexOptions> & {
     isCallerAllocated?: boolean;
@@ -77,6 +78,11 @@ type RecordPlacement = {
     isInline?: boolean;
 };
 
+type RecordLayout = {
+    isCallerAllocated: boolean;
+    isInline: boolean;
+};
+
 type FundamentalDescriptor = {
     lib: string;
     refFunc: string;
@@ -84,6 +90,7 @@ type FundamentalDescriptor = {
     typeName: string | undefined;
     ownership: Ownership;
     wrapperClass?: string | undefined;
+    isCallerAllocated?: boolean | undefined;
     isInline?: boolean | undefined;
 };
 
@@ -103,6 +110,7 @@ type FundamentalRecordOptions = {
     unrefFunc: string;
     ownership: Ownership;
     wrapperClass: string | undefined;
+    isCallerAllocated: boolean;
     isInline: boolean;
 };
 
@@ -189,7 +197,7 @@ const renderDescriptor = (
             return tVoid;
         }
         case "callback": {
-            return tUint64;
+            return tBiguint64;
         }
         case "class":
         case "interface":
@@ -199,7 +207,10 @@ const renderDescriptor = (
             return expressionForResolved(context, type, transfer, options);
         }
         case "carray": {
-            return arrayExpression(context, type, transfer, indexOptions);
+            return arrayExpression(context, type, transfer, {
+                ...indexOptions,
+                isCallerAllocated: options.isCallerAllocated === true,
+            });
         }
         case "list": {
             return listExpression(context, type, transfer, indexOptions);
@@ -333,7 +344,11 @@ const findUserDataIndex = (parameters: GirParameter[]): number | undefined => {
     return declared?.closureIndex ?? userDataIndexByName(parameters);
 };
 
-const callbackOptionsArg = (owningParameter: GirParameter, userDataIndex: number | undefined): string[] => {
+const callbackOptionsArg = (
+    owningParameter: GirParameter,
+    userDataIndex: number | undefined,
+    canThrow: boolean,
+): string[] => {
     const options: string[] = [];
 
     if (owningParameter.destroyIndex !== undefined) {
@@ -348,6 +363,10 @@ const callbackOptionsArg = (owningParameter: GirParameter, userDataIndex: number
         options.push(`userDataIndex: ${String(userDataIndex)}`);
     }
 
+    if (canThrow) {
+        options.push("canThrow: true");
+    }
+
     if (owningParameter.scope !== undefined) {
         options.push(`scope: ${sourceStringLiteral(owningParameter.scope)}`);
     }
@@ -376,7 +395,7 @@ const renderCallbackType = (
     return tCallback({
         argTypes,
         returns: renderDescriptor(context, returnValue.type, returnValue.transferOwnership),
-        options: callbackOptionsArg(owningParameter, findUserDataIndex(callback.parameters)),
+        options: callbackOptionsArg(owningParameter, findUserDataIndex(callback.parameters), callback.throws),
     });
 };
 
@@ -401,12 +420,13 @@ const primitiveExpression = (category: PrimitiveCategory, ownership: Ownership):
 };
 
 const renderFundamental = (descriptor: FundamentalDescriptor): string => {
-    const { lib, refFunc, unrefFunc, typeName, ownership, wrapperClass, isInline } = descriptor;
+    const { lib, refFunc, unrefFunc, typeName, ownership, wrapperClass, isCallerAllocated, isInline } = descriptor;
 
     return tFundamental(lib, refFunc, unrefFunc, {
         ownership,
         typeName,
         wrapperClass,
+        isCallerAllocated,
         isInline,
     });
 };
@@ -529,6 +549,11 @@ const renderSelfDescriptor = (context: ModuleContext, instance: GirParameter): s
     return tObject("borrowed");
 };
 
+const recordLayout = (placement: RecordPlacement): RecordLayout => ({
+    isCallerAllocated: placement.isCallerAllocated ?? false,
+    isInline: placement.isInline ?? false,
+});
+
 const recordRefPair = (record: ResolvedRecord): { refFunc: string | undefined; unrefFunc: string | undefined } => ({
     refFunc: record.glibRefFunc ?? record.copyFunc,
     unrefFunc: record.glibUnrefFunc ?? record.freeFunc,
@@ -563,7 +588,7 @@ const structExpression = (
 };
 
 const fundamentalRecordExpression = (options: FundamentalRecordOptions): string => {
-    const { resolved, lib, refFunc, unrefFunc, ownership, wrapperClass, isInline } = options;
+    const { resolved, lib, refFunc, unrefFunc, ownership, wrapperClass, isCallerAllocated, isInline } = options;
 
     return renderFundamental({
         lib,
@@ -572,6 +597,7 @@ const fundamentalRecordExpression = (options: FundamentalRecordOptions): string
         typeName: resolved.value.glibTypeName,
         ownership,
         wrapperClass,
+        isCallerAllocated,
         isInline,
     });
 };
@@ -606,11 +632,7 @@ const plainRecordExpression = (
     placement: RecordPlacement,
 ): string => {
     const record = resolved.value;
-
-    const layout = {
-        isCallerAllocated: placement.isCallerAllocated ?? false,
-        isInline: placement.isInline ?? false,
-    };
+    const layout = recordLayout(placement);
 
     if (record.glibGetType === undefined) {
         return structExpression(context, resolved, ownership, layout);
@@ -619,6 +641,17 @@ const plainRecordExpression = (
     return boxedRecordExpression({ context, resolved, ownership, ...layout, typeFnName: record.glibGetType });
 };
 
+const isPlainStruct = (resolved: Extract<EntityType, { kind: "record" }>): boolean => {
+    const record = resolved.value;
+    const { refFunc, unrefFunc } = recordRefPair(record);
+
+    if (refFunc !== undefined && unrefFunc !== undefined && resolved.namespace.sharedLibrary !== undefined) {
+        return false;
+    }
+
+    return record.glibGetType === undefined;
+};
+
 const recordExpression = (
     context: ModuleContext,
     resolved: Extract<EntityType, { kind: "record" }>,
@@ -641,7 +674,7 @@ const recordExpression = (
             unrefFunc,
             ownership,
             wrapperClass,
-            isInline: placement.isInline ?? false,
+            ...recordLayout(placement),
         });
     }
 
@@ -650,16 +683,20 @@ const recordExpression = (
 
 const rawEnumDescriptor = (isSigned: boolean): string => (isSigned ? tInt32 : tUint32);
 
+const flagsMask = (resolved: Extract<EntityType, { kind: "enum" }>): number =>
+    resolved.value.members.reduce((mask, member) => (mask | Number(member.value)) >>> 0, 0);
+
 const enumExpression = (resolved: Extract<EntityType, { kind: "enum" }>): string => {
     const getter = resolved.value.glibGetType;
     const isSigned = resolved.value.members.some((member) => member.value.startsWith("-"));
     const lib = resolved.namespace.sharedLibrary;
+    const isBitfield = resolved.value.kind === "bitfield";
 
     if (getter === undefined || getter === "" || lib === undefined) {
-        return rawEnumDescriptor(isSigned);
+        return isBitfield ? tFlags("", "", isSigned, flagsMask(resolved)) : rawEnumDescriptor(isSigned);
     }
 
-    return resolved.value.kind === "bitfield" ? tFlags(lib, getter, isSigned) : tEnum(lib, getter, isSigned);
+    return isBitfield ? tFlags(lib, getter, isSigned) : tEnum(lib, getter, isSigned);
 };
 
 const expressionForResolved = (
@@ -700,6 +737,7 @@ const elementExpression = (
         ...options,
         cursor: undefined,
         hasOutIndirection: false,
+        isCallerAllocated: false,
     });
 
 const cursorArrayExpression = (
@@ -724,11 +762,14 @@ const arrayLayout = (context: ModuleContext, ref: CArrayType, options: ArgIndexO
         context.library.isByteArrayTyped && !hasUnknownArrayLength(ref) && isByteSequence(context.library, ref),
 });
 
+const fixedArrayLayout = (layout: ArrayLayout, isCallerAllocated: boolean): ArrayLayout =>
+    isCallerAllocated ? { ...layout, isCallerAllocated: true } : layout;
+
 const arrayExpression = (
     context: ModuleContext,
     ref: CArrayType,
     transfer: ParameterTransfer,
-    options: ArgIndexOptions,
+    options: CArrayExpressionOptions,
 ): string => {
     const { cursor } = options;
     const layout = arrayLayout(context, ref, options);
@@ -749,7 +790,7 @@ const arrayExpression = (
     }
 
     if (ref.fixedSize !== undefined) {
-        return tFixedArray(element, ref.fixedSize, ownership, layout);
+        return tFixedArray(element, ref.fixedSize, ownership, fixedArrayLayout(layout, options.isCallerAllocated));
     }
 
     return tArray(element, ownership, layout);
@@ -789,6 +830,8 @@ const aliasExpression = (
 };
 
 export {
+    isPlainStruct,
+    transferOwnership,
     isInlineCallbackRef,
     isSkippedPrimaryReturn,
     isVoidPrimaryReturn,

package/src/analysis/descriptor.ts

@@ -82,6 +82,7 @@ type FundamentalOptions = {
     ownership: Ownership;
     typeName: string | undefined;
     wrapperClass: string | undefined;
+    isCallerAllocated?: boolean | undefined;
     isInline?: boolean | undefined;
 };
 
@@ -90,6 +91,7 @@ type ListDescriptorName = "list" | "slist" | "ptrArray" | "gArray";
 type ArrayLayout = {
     elementSize?: number | undefined;
     isBytes: boolean;
+    isCallerAllocated?: boolean | undefined;
 };
 
 type BindArgs = {
@@ -103,6 +105,7 @@ type FnSpecParts = {
     args: string;
     returns: string;
     isReturnSkipped: boolean;
+    isReturnUnpacked: boolean;
     canThrow: boolean;
 };
 
@@ -113,6 +116,7 @@ type CallbackSpecParts = {
 };
 
 const SKIPPED_RETURN_ENTRY = "isReturnSkipped: true";
+const UNPACKED_RETURN_ENTRY = "isReturnUnpacked: true";
 
 const T: DescriptorNames = {
     bind: "t.bind",
@@ -218,6 +222,7 @@ const tFundamental = (lib: string, refFunc: string, unrefFunc: string, options:
             `ownership: ${sourceStringLiteral(options.ownership)}`,
             options.typeName === undefined ? undefined : `typeName: ${sourceStringLiteral(options.typeName)}`,
             options.wrapperClass === undefined ? undefined : `wrapperClass: ${options.wrapperClass}`,
+            options.isCallerAllocated === true ? "isCallerAllocated: true" : undefined,
             options.isInline === true ? "isInline: true" : undefined,
         ]),
     ]);
@@ -230,8 +235,13 @@ const tHashTable = (key: string, value: string, ownership: Ownership): string =>
 const tEnum = (lib: string, typeFnName: string, isSigned: boolean): string =>
     call("enum", [sourceStringLiteral(lib), sourceStringLiteral(typeFnName), String(isSigned)]);
 
-const tFlags = (lib: string, typeFnName: string, isSigned: boolean): string =>
-    call("flags", [sourceStringLiteral(lib), sourceStringLiteral(typeFnName), String(isSigned)]);
+const tFlags = (lib: string, typeFnName: string, isSigned: boolean, mask?: number): string =>
+    call("flags", [
+        sourceStringLiteral(lib),
+        sourceStringLiteral(typeFnName),
+        String(isSigned),
+        mask === undefined ? undefined : `0x${mask.toString(16)}`,
+    ]);
 
 const tByteArray = (ownership: Ownership): string => call("byteArray", [sourceStringLiteral(ownership)]);
 
@@ -253,6 +263,7 @@ const arrayLayoutArg = (ownership: Ownership | undefined, layout: ArrayLayout):
     const entries = [
         layout.elementSize === undefined ? undefined : `elementSize: ${String(layout.elementSize)}`,
         layout.isBytes ? "isBytes: true" : undefined,
+        layout.isCallerAllocated === true ? "isCallerAllocated: true" : undefined,
     ].filter((entry): entry is string => entry !== undefined);
 
     return entries.length === 0 ? undefined : `{ ${entries.join(", ")} }`;
@@ -311,12 +322,13 @@ const tBind = (args: BindArgs): string =>
 
 const tFn = (lib: string, cIdentifier: string, spec: FnSpecParts): string => {
     const skipEntry = spec.isReturnSkipped ? `, ${SKIPPED_RETURN_ENTRY}` : "";
+    const unpackEntry = spec.isReturnUnpacked ? `, ${UNPACKED_RETURN_ENTRY}` : "";
     const throwsEntry = spec.canThrow ? ", canThrow: true" : "";
 
     return call("fn", [
         sourceStringLiteral(lib),
         sourceStringLiteral(cIdentifier),
-        `{ args: ${spec.args}, returns: ${spec.returns}${skipEntry}${throwsEntry} }`,
+        `{ args: ${spec.args}, returns: ${spec.returns}${skipEntry}${unpackEntry}${throwsEntry} }`,
     ]);
 };
 

package/src/analysis/param-capability.ts

@@ -1,11 +1,20 @@
-import type { GirCallable, GirParameter } from "../gir/parameter.js";
+import type { GirCallable, GirParameter, ParameterTransfer } from "../gir/parameter.js";
 import type { CArrayType, TypeId } from "../gir/type-id.js";
 import type { GirType } from "../gir/type.js";
 import type { ModuleContext } from "../writer/context.js";
 import { isCallerAllocatedOut, isInoutParameter } from "../gir/parameter.js";
-import { isCollectibleCallerOut, isHandlePassedInPlace, underlyingType } from "../store/gi/param-marshal.js";
+import {
+    isCollectibleCallerOut,
+    isFixedArrayCallerOut,
+    isHandlePassedInPlace,
+    isRecordInout,
+    underlyingType,
+} from "../store/gi/param-marshal.js";
 import { recordInlineSize } from "../store/gi/record-layout.js";
-import { isScalarRef } from "./descriptor-render.js";
+import { isPlainStruct, isScalarRef, transferOwnership } from "./descriptor-render.js";
+import { closureAndDestroyIndices } from "./param-structure.js";
+
+type UnmarshalableSubject = GirCallable & { instance?: GirParameter | undefined };
 
 const POINTER_DEPTH = 1;
 
@@ -119,6 +128,10 @@ const isUnmarshalableCallerOut = (context: ModuleContext, parameter: GirParamete
         return true;
     }
 
+    if (isFixedArrayCallerOut(context, parameter)) {
+        return false;
+    }
+
     return !isCollectibleCallerOut(context, parameter) && !parameter.optional;
 };
 
@@ -143,12 +156,59 @@ const isTypeErasedCallback = (context: ModuleContext, parameter: GirParameter):
     return type?.kind === "callback" && type.value.parameters.length === 0;
 };
 
+const isCallbackParam = (context: ModuleContext, parameter: GirParameter): boolean => {
+    const type = parameter.type === undefined ? undefined : underlyingType(context, parameter.type);
+
+    return type?.kind === "callback";
+};
+
+const hasDetachedClosure = (parameter: GirParameter, index: number): boolean => {
+    const userDataIndex = parameter.closureIndex;
+
+    if (userDataIndex !== undefined && userDataIndex !== index + 1) {
+        return true;
+    }
+
+    const notifyIndex = parameter.destroyIndex;
+
+    return notifyIndex !== undefined && notifyIndex !== index + (userDataIndex === undefined ? 1 : 2);
+};
+
+const hasDetachedCallback = (context: ModuleContext, parameters: GirParameter[]): boolean => {
+    const claimed = closureAndDestroyIndices({ parameters });
+
+    return parameters.some(
+        (parameter, index) =>
+            !claimed.has(index) && isCallbackParam(context, parameter) && hasDetachedClosure(parameter, index),
+    );
+};
+
+const isRefusedTransfer = (
+    context: ModuleContext,
+    ref: TypeId | undefined,
+    transfer: ParameterTransfer,
+): boolean => {
+    if (ref === undefined || transferOwnership(transfer) !== "full") {
+        return false;
+    }
+
+    const type = underlyingType(context, ref);
+
+    return type?.kind === "record" && isPlainStruct(type);
+};
+
+const isLentInPlace = (context: ModuleContext, parameter: GirParameter): boolean =>
+    isCallerAllocatedOut(parameter) || isRecordInout(context, parameter);
+
+const isRefusedParamTransfer = (context: ModuleContext, parameter: GirParameter): boolean =>
+    !isLentInPlace(context, parameter) && isRefusedTransfer(context, parameter.type, parameter.transferOwnership);
+
 const isUnmarshalableCallParam = (context: ModuleContext, parameter: GirParameter): boolean => {
     if (parameter.isVarargs) {
         return false;
     }
 
-    if (isTypeErasedCallback(context, parameter)) {
+    if (isTypeErasedCallback(context, parameter) || isRefusedParamTransfer(context, parameter)) {
         return true;
     }
 
@@ -163,7 +223,10 @@ const isUnmarshalableCallParam = (context: ModuleContext, parameter: GirParamete
     return hasIndirectionMismatch(context, parameter);
 };
 
-const hasUnmarshalableParam = (context: ModuleContext, callable: GirCallable): boolean =>
+const hasUnmarshalableParam = (context: ModuleContext, callable: UnmarshalableSubject): boolean =>
+    (callable.instance !== undefined && isRefusedParamTransfer(context, callable.instance)) ||
+    isRefusedTransfer(context, callable.returnValue.type, callable.returnValue.transferOwnership) ||
+    hasDetachedCallback(context, callable.parameters) ||
     callable.parameters.some((parameter) => isUnmarshalableCallParam(context, parameter));
 
 export { hasUnmarshalableParam };

package/src/analysis/param-structure.ts

@@ -61,7 +61,7 @@ const inputParameters = (library: Library, fn: GirFunction): InputParameter[] =>
     return result;
 };
 
-const closureAndDestroyIndices = (fn: GirFunction): Set<number> => {
+const closureAndDestroyIndices = (fn: Pick<GirCallable, "parameters">): Set<number> => {
     const indices: Set<number> = new Set();
 
     for (const parameter of fn.parameters) {

package/src/analysis/ts-type.ts

@@ -11,7 +11,8 @@ import {
     type ListType,
     type TypeId,
 } from "../gir/type-id.js";
-import { gtypeTsType } from "../store/gi/gtype-binding.js";
+import { gtypeParamTsType, gtypeTsType } from "../store/gi/gtype-binding.js";
+import { isValueTypeName } from "../store/gi/param-marshal.js";
 import { isByteSequence } from "./type-shape.js";
 
 type ReferenceName = {
@@ -27,6 +28,12 @@ type TsTypeTarget = {
     renderGtype: () => string;
 };
 
+type ModuleTypeOptions = {
+    byteArrayType: string;
+    isValueWidened: boolean;
+    isGtypeWidened: boolean;
+};
+
 const BYTE_ARRAY_TYPE = "Uint8Array";
 const BYTE_ARRAY_INPUT_TYPE = "Uint8Array | number[]";
 const NUMBER_ARRAY_TYPE = "number[]";
@@ -101,6 +108,8 @@ const renderContainerType = (
     return renderSequenceType(library, target, type);
 };
 
+const parenthesizeUnion = (rendered: string): string => (rendered.includes(" | ") ? `(${rendered})` : rendered);
+
 const renderSequenceType = (library: Library, target: TsTypeTarget, type: CArrayType | ListType): string => {
     if (type.kind === "carray" && hasUnknownArrayLength(type)) {
         return "number";
@@ -110,7 +119,7 @@ const renderSequenceType = (library: Library, target: TsTypeTarget, type: CArray
         return target.byteArrayType;
     }
 
-    return `${renderBaseType(library, target, type.element)}[]`;
+    return `${parenthesizeUnion(renderBaseType(library, target, type.element))}[]`;
 };
 
 const renderNamedType = (
@@ -128,30 +137,55 @@ const renderNamedType = (
 const getByteArrayType = (library: Library): string =>
     library.isByteArrayTyped ? BYTE_ARRAY_TYPE : NUMBER_ARRAY_TYPE;
 
-const moduleTarget = (context: ModuleContext, byteArrayType: string): TsTypeTarget => ({
+const renderNamedModuleType = (context: ModuleContext, name: ReferenceName, isValueWidened: boolean): string => {
+    const qualified = context.qualify(name.namespaceName, name.typeName);
+
+    if (!isValueWidened || !isValueTypeName(name)) {
+        return qualified;
+    }
+
+    context.addRuntimeTypeImport("JsValue");
+
+    return `${qualified} | JsValue`;
+};
+
+const moduleTarget = (context: ModuleContext, options: ModuleTypeOptions): TsTypeTarget => ({
     containerStyle: "map",
     callbackType: "((...args: any[]) => any)",
-    byteArrayType,
-    renderNamed: (_resolved, name) => context.qualify(name.namespaceName, name.typeName),
-    renderGtype: () => gtypeTsType(context),
+    byteArrayType: options.byteArrayType,
+    renderNamed: (_resolved, name) => renderNamedModuleType(context, name, options.isValueWidened),
+    renderGtype: () => (options.isGtypeWidened ? gtypeParamTsType(context) : gtypeTsType(context)),
 });
 
 const renderModuleType = (
     context: ModuleContext,
     ref: TypeId | undefined,
     isNullable: boolean,
-    byteArrayType: string,
+    options: ModuleTypeOptions,
 ): string => {
-    const base = renderBaseType(context.library, moduleTarget(context, byteArrayType), ref);
+    const base = renderBaseType(context.library, moduleTarget(context, options), ref);
 
     return isNullable ? `${base} | null` : base;
 };
 
 const renderTsType = (context: ModuleContext, ref: TypeId | undefined, isNullable = false): string =>
-    renderModuleType(context, ref, isNullable, getByteArrayType(context.library));
+    renderModuleType(context, ref, isNullable, {
+        byteArrayType: getByteArrayType(context.library),
+        isValueWidened: false,
+        isGtypeWidened: false,
+    });
 
-const renderParameterTsType = (context: ModuleContext, ref: TypeId | undefined, isNullable = false): string =>
-    renderModuleType(context, ref, isNullable, BYTE_ARRAY_INPUT_TYPE);
+const renderParameterTsType = (
+    context: ModuleContext,
+    ref: TypeId | undefined,
+    isNullable = false,
+    isValueWidened = true,
+): string =>
+    renderModuleType(context, ref, isNullable, {
+        byteArrayType: BYTE_ARRAY_INPUT_TYPE,
+        isValueWidened,
+        isGtypeWidened: true,
+    });
 
 const recordTypeTarget = (
     library: Library,

package/src/compile.ts

@@ -76,7 +76,7 @@ const DECLARATION_EMIT = {
 };
 
 const MODULE_EMIT = {
-    removeComments: false,
+    removeComments: true,
 };
 
 const DECLARATION_OPTIONS = ts.convertCompilerOptionsFromJson(

package/src/docs/api-reference.ts

@@ -3,6 +3,7 @@ import type { GirClass } from "../gir/class.js";
 import type { GirFunction } from "../gir/function.js";
 import type { GirRecord } from "../gir/record.js";
 import { isEmittableEntity } from "../gir/emittable.js";
+import { externalPackageFor } from "../gir/external-namespaces.js";
 import { Library } from "../gir/library.js";
 import { type GirNamespace, namespaceDirectory } from "../gir/namespace.js";
 import { dedupeCallables, isEmittableCallable } from "../store/gi/callables.js";
@@ -26,6 +27,12 @@ type ApiReferenceOptions = {
     omittedProps?: OmittedProps;
     /** Describes GIR byte sequences as `Uint8Array` rather than `number[]`; defaults to false. */
     isByteArrayTyped?: boolean;
+    /** Describes what a `GObject.Value` a binding hands back holds, rather than the value itself; off by default. */
+    isValueUnwrapped?: boolean;
+    /** Describes promisified results of a throwing finish without their leading success boolean; off by default. */
+    isFinishTrimmed?: boolean;
+    /** Describes a handle-passing inout parameter as mutated in place rather than returned; off by default. */
+    isInoutInPlace?: boolean;
 };
 
 /** Narrows an `ApiReference.symbols` enumeration. */
@@ -373,7 +380,14 @@ class ApiReference {
         this.libraries = options.libraries;
         this.props = options.props ?? {};
         this.omittedProps = options.omittedProps ?? {};
-        this.library = Library.load(options.libraries, options.girPath, options.isByteArrayTyped === true);
+
+        this.library = Library.load(options.libraries, options.girPath, {
+            isByteArrayTyped: options.isByteArrayTyped === true,
+            isValueUnwrapped: options.isValueUnwrapped === true,
+            isFinishTrimmed: options.isFinishTrimmed === true,
+            isInoutInPlace: options.isInoutInPlace === true,
+        });
+
         this.elementContext = { library: this.library, linkFor: (): string | undefined => undefined };
         this.buildIndex();
     }
@@ -399,6 +413,10 @@ class ApiReference {
 
     private buildIndex(): void {
         for (const namespace of this.library.namespaces.values()) {
+            if (externalPackageFor(namespace.name) !== undefined) {
+                continue;
+            }
+
             this.indexNamespace(namespace);
         }
 
@@ -475,7 +493,7 @@ class ApiReference {
         const lower = name.toLowerCase();
 
         for (const namespace of this.library.namespaces.values()) {
-            if (namespace.name.toLowerCase() === lower) {
+            if (namespace.name.toLowerCase() === lower && externalPackageFor(namespace.name) === undefined) {
                 return namespace;
             }
         }

package/src/docs/pipeline.ts

@@ -39,6 +39,9 @@ type DocsOptions = {
     omittedProps?: OmittedProps;
     isForced?: boolean;
     isByteArrayTyped?: boolean;
+    isValueUnwrapped?: boolean;
+    isFinishTrimmed?: boolean;
+    isInoutInPlace?: boolean;
 };
 
 type DocsManifest = {
@@ -259,7 +262,11 @@ const giInputs = (options: DocsOptions, girFiles: string[]): GiInputs => ({
     girFiles,
     libraries: options.libraries,
     girPath: options.girPath,
+    storeVersion: undefined,
     isByteArrayTyped: options.isByteArrayTyped === true,
+    isValueUnwrapped: options.isValueUnwrapped === true,
+    isFinishTrimmed: options.isFinishTrimmed === true,
+    isInoutInPlace: options.isInoutInPlace === true,
 });
 
 const assertOwnedOutDir = (options: DocsOptions, manifest: DocsManifest | undefined): void => {
@@ -344,7 +351,14 @@ const writeDocs = (options: DocsOptions): DocsResult => {
     }
 
     assertOwnedOutDir(options, previous);
-    const library = Library.load(options.libraries, options.girPath, options.isByteArrayTyped === true);
+
+    const library = Library.load(options.libraries, options.girPath, {
+        isByteArrayTyped: options.isByteArrayTyped === true,
+        isValueUnwrapped: options.isValueUnwrapped === true,
+        isFinishTrimmed: options.isFinishTrimmed === true,
+        isInoutInPlace: options.isInoutInPlace === true,
+    });
+
     const { pages, namespaces } = generatePages(options, input.basePath, library);
     clearOutDir(options, previous);
     mkdirSync(options.outDir, { recursive: true });