@constructive-io/graphql-codegen 4.14.0 → 4.14.1

package/core/codegen/cli/table-command-generator.d.ts

@@ -1,19 +1,5 @@
 import type { CleanTable, TypeRegistry } from '../../../types/schema';
 import type { GeneratedFile } from './executor-generator';
-/**
- * Get the set of field names that have defaults in the create input type.
- * Looks up the CreateXInput -> inner input type (e.g. DatabaseInput) in the
- * TypeRegistry and checks each field's defaultValue from introspection.
- */
-/**
- * Resolve the inner input type from a CreateXInput or UpdateXInput type.
- * The CreateXInput has an inner field (e.g. "database" of type DatabaseInput)
- * that contains the actual field definitions.
- */
-export declare function resolveInnerInputType(inputTypeName: string, typeRegistry: TypeRegistry): {
-    name: string;
-    fields: Set<string>;
-} | null;
 export declare function getFieldsWithDefaults(table: CleanTable, typeRegistry?: TypeRegistry): Set<string>;
 export interface TableCommandOptions {
     targetName?: string;

package/core/codegen/cli/table-command-generator.js

@@ -33,7 +33,6 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveInnerInputType = resolveInnerInputType;
 exports.getFieldsWithDefaults = getFieldsWithDefaults;
 exports.generateTableCommand = generateTableCommand;
 const t = __importStar(require("@babel/types"));
@@ -150,8 +149,8 @@ function buildFieldSchemaObject(table) {
         return t.objectProperty(t.identifier(f.name), t.stringLiteral(schemaType));
     }));
 }
-function buildSelectObject(table) {
-    const fields = (0, utils_1.getScalarFields)(table);
+function buildSelectObject(table, typeRegistry) {
+    const fields = (0, utils_1.getSelectableScalarFields)(table, typeRegistry);
     return t.objectExpression(fields.map((f) => t.objectProperty(t.identifier(f.name), t.booleanLiteral(true))));
 }
 function buildJsonLog(expr) {
@@ -202,9 +201,9 @@ function buildSubcommandSwitch(subcommands, handlerPrefix, usageVarName) {
     ]));
     return t.switchStatement(t.identifier('subcommand'), cases);
 }
-function buildListHandler(table, targetName) {
+function buildListHandler(table, targetName, typeRegistry) {
     const { singularName } = (0, utils_1.getTableNames)(table);
-    const selectObj = buildSelectObject(table);
+    const selectObj = buildSelectObject(table, typeRegistry);
     const tryBody = [
         buildGetClientStatement(targetName),
         t.variableDeclaration('const', [
@@ -222,11 +221,11 @@ function buildListHandler(table, targetName) {
         t.tryStatement(t.blockStatement(tryBody), buildErrorCatch('Failed to list records.')),
     ]), false, true);
 }
-function buildGetHandler(table, targetName) {
+function buildGetHandler(table, targetName, typeRegistry) {
     const { singularName } = (0, utils_1.getTableNames)(table);
     const pkFields = (0, utils_1.getPrimaryKeyInfo)(table);
     const pk = pkFields[0];
-    const selectObj = buildSelectObject(table);
+    const selectObj = buildSelectObject(table, typeRegistry);
     const promptQuestion = t.objectExpression([
         t.objectProperty(t.identifier('type'), t.stringLiteral('text')),
         t.objectProperty(t.identifier('name'), t.stringLiteral(pk.name)),
@@ -258,40 +257,12 @@ function buildGetHandler(table, targetName) {
         t.tryStatement(t.blockStatement(tryBody), buildErrorCatch('Record not found.')),
     ]), false, true);
 }
-/**
- * Get the set of field names that have defaults in the create input type.
- * Looks up the CreateXInput -> inner input type (e.g. DatabaseInput) in the
- * TypeRegistry and checks each field's defaultValue from introspection.
- */
-/**
- * Resolve the inner input type from a CreateXInput or UpdateXInput type.
- * The CreateXInput has an inner field (e.g. "database" of type DatabaseInput)
- * that contains the actual field definitions.
- */
-function resolveInnerInputType(inputTypeName, typeRegistry) {
-    const inputType = typeRegistry.get(inputTypeName);
-    if (!inputType?.inputFields)
-        return null;
-    for (const inputField of inputType.inputFields) {
-        const innerTypeName = inputField.type.name
-            || inputField.type.ofType?.name
-            || inputField.type.ofType?.ofType?.name;
-        if (!innerTypeName)
-            continue;
-        const innerType = typeRegistry.get(innerTypeName);
-        if (!innerType?.inputFields)
-            continue;
-        const fields = new Set(innerType.inputFields.map((f) => f.name));
-        return { name: innerTypeName, fields };
-    }
-    return null;
-}
 function getFieldsWithDefaults(table, typeRegistry) {
     const fieldsWithDefaults = new Set();
     if (!typeRegistry)
         return fieldsWithDefaults;
     const createInputTypeName = (0, utils_1.getCreateInputTypeName)(table);
-    const resolved = resolveInnerInputType(createInputTypeName, typeRegistry);
+    const resolved = (0, utils_1.resolveInnerInputType)(createInputTypeName, typeRegistry);
     if (!resolved)
         return fieldsWithDefaults;
     const innerType = typeRegistry.get(resolved.name);
@@ -307,18 +278,6 @@ function getFieldsWithDefaults(table, typeRegistry) {
     }
     return fieldsWithDefaults;
 }
-/**
- * Get the set of field names that actually exist in the create/update input type.
- * Fields not in this set (e.g. computed fields like searchTsvRank, hashUuid)
- * should be excluded from the data object in create/update handlers.
- */
-function getWritableFieldNames(table, typeRegistry) {
-    if (!typeRegistry)
-        return null;
-    const createInputTypeName = (0, utils_1.getCreateInputTypeName)(table);
-    const resolved = resolveInnerInputType(createInputTypeName, typeRegistry);
-    return resolved?.fields ?? null;
-}
 function buildMutationHandler(table, operation, targetName, typeRegistry, ormTypes) {
     const { singularName } = (0, utils_1.getTableNames)(table);
     const pkFields = (0, utils_1.getPrimaryKeyInfo)(table);
@@ -326,7 +285,7 @@ function buildMutationHandler(table, operation, targetName, typeRegistry, ormTyp
     // Get the set of writable field names from the type registry
     // This filters out computed fields (e.g. searchTsvRank, hashUuid) that exist
     // on the entity type but not on the create/update input type.
-    const writableFields = getWritableFieldNames(table, typeRegistry);
+    const writableFields = (0, utils_1.getWritableFieldNames)(table, typeRegistry);
     // Get fields that have defaults from introspection (for create operations)
     const fieldsWithDefaults = getFieldsWithDefaults(table, typeRegistry);
     // For create: include fields that are in the create input type.
@@ -379,7 +338,7 @@ function buildMutationHandler(table, operation, targetName, typeRegistry, ormTyp
         ? t.objectExpression([
             t.objectProperty(t.identifier(pk.name), t.booleanLiteral(true)),
         ])
-        : buildSelectObject(table);
+        : buildSelectObject(table, typeRegistry);
     let ormArgs;
     // Build data properties without individual type assertions.
     // Instead, we build a plain object from cleanedData and cast the entire
@@ -587,9 +546,9 @@ function generateTableCommand(table, options) {
     ]), false, true));
     const tn = options?.targetName;
     const ormTypes = { createInputTypeName, patchTypeName, innerFieldName };
-    statements.push(buildListHandler(table, tn));
+    statements.push(buildListHandler(table, tn, options?.typeRegistry));
     if (hasGet)
-        statements.push(buildGetHandler(table, tn));
+        statements.push(buildGetHandler(table, tn, options?.typeRegistry));
     statements.push(buildMutationHandler(table, 'create', tn, options?.typeRegistry, ormTypes));
     if (hasUpdate)
         statements.push(buildMutationHandler(table, 'update', tn, options?.typeRegistry, ormTypes));

package/core/codegen/utils.d.ts

@@ -1,4 +1,4 @@
-import type { CleanField, CleanFieldType, CleanTable } from '../../types/schema';
+import type { CleanField, CleanFieldType, CleanTable, TypeRegistry } from '../../types/schema';
 /** Lowercase first character */
 export declare function lcFirst(str: string): string;
 /** Uppercase first character */
@@ -148,6 +148,31 @@ export declare function isRelationField(fieldName: string, table: CleanTable): b
  * Get only scalar fields (non-relation fields)
  */
 export declare function getScalarFields(table: CleanTable): CleanField[];
+/**
+ * Resolve the inner input type from a CreateXInput.
+ * PostGraphile create inputs wrap the actual field definitions in an inner type
+ * (e.g. CreateUserInput -> { user: UserInput }) — this resolves that inner type
+ * and returns the set of field names it contains.
+ */
+export declare function resolveInnerInputType(inputTypeName: string, typeRegistry: TypeRegistry): {
+    name: string;
+    fields: Set<string>;
+} | null;
+/**
+ * Get the set of field names that actually exist in the create input type.
+ * Fields not in this set (e.g. computed fields like searchTsvRank, hashUuid)
+ * are plugin-added computed fields that don't correspond to real database columns.
+ * Returns null when no typeRegistry is provided (caller should treat as "no filtering").
+ */
+export declare function getWritableFieldNames(table: CleanTable, typeRegistry?: TypeRegistry): Set<string> | null;
+/**
+ * Get scalar fields that represent actual database columns (not computed/plugin-added).
+ * When a TypeRegistry is provided, filters out fields that don't exist in the
+ * create input type — these are computed fields added by plugins (e.g. search scores,
+ * hash UUIDs) that aren't real columns and shouldn't appear in default selections.
+ * Without a TypeRegistry, falls back to all scalar fields.
+ */
+export declare function getSelectableScalarFields(table: CleanTable, typeRegistry?: TypeRegistry): CleanField[];
 /**
  * Primary key field information
  */

package/core/codegen/utils.js

@@ -33,6 +33,9 @@ exports.fieldTypeToTs = fieldTypeToTs;
 exports.getScalarFilterType = getScalarFilterType;
 exports.isRelationField = isRelationField;
 exports.getScalarFields = getScalarFields;
+exports.resolveInnerInputType = resolveInnerInputType;
+exports.getWritableFieldNames = getWritableFieldNames;
+exports.getSelectableScalarFields = getSelectableScalarFields;
 exports.getPrimaryKeyInfo = getPrimaryKeyInfo;
 exports.getPrimaryKeyFields = getPrimaryKeyFields;
 exports.hasValidPrimaryKey = hasValidPrimaryKey;
@@ -303,6 +306,54 @@ function isRelationField(fieldName, table) {
 function getScalarFields(table) {
     return table.fields.filter((f) => !isRelationField(f.name, table));
 }
+/**
+ * Resolve the inner input type from a CreateXInput.
+ * PostGraphile create inputs wrap the actual field definitions in an inner type
+ * (e.g. CreateUserInput -> { user: UserInput }) — this resolves that inner type
+ * and returns the set of field names it contains.
+ */
+function resolveInnerInputType(inputTypeName, typeRegistry) {
+    const inputType = typeRegistry.get(inputTypeName);
+    if (!inputType?.inputFields)
+        return null;
+    for (const inputField of inputType.inputFields) {
+        const innerTypeName = inputField.type.name
+            || inputField.type.ofType?.name
+            || inputField.type.ofType?.ofType?.name;
+        if (!innerTypeName)
+            continue;
+        const innerType = typeRegistry.get(innerTypeName);
+        if (!innerType?.inputFields)
+            continue;
+        const fields = new Set(innerType.inputFields.map((f) => f.name));
+        return { name: innerTypeName, fields };
+    }
+    return null;
+}
+/**
+ * Get the set of field names that actually exist in the create input type.
+ * Fields not in this set (e.g. computed fields like searchTsvRank, hashUuid)
+ * are plugin-added computed fields that don't correspond to real database columns.
+ * Returns null when no typeRegistry is provided (caller should treat as "no filtering").
+ */
+function getWritableFieldNames(table, typeRegistry) {
+    if (!typeRegistry)
+        return null;
+    const createInputTypeName = getCreateInputTypeName(table);
+    const resolved = resolveInnerInputType(createInputTypeName, typeRegistry);
+    return resolved?.fields ?? null;
+}
+/**
+ * Get scalar fields that represent actual database columns (not computed/plugin-added).
+ * When a TypeRegistry is provided, filters out fields that don't exist in the
+ * create input type — these are computed fields added by plugins (e.g. search scores,
+ * hash UUIDs) that aren't real columns and shouldn't appear in default selections.
+ * Without a TypeRegistry, falls back to all scalar fields.
+ */
+function getSelectableScalarFields(table, typeRegistry) {
+    const writableFields = getWritableFieldNames(table, typeRegistry);
+    return getScalarFields(table).filter((f) => writableFields === null || writableFields.has(f.name));
+}
 /**
  * Get primary key field information from table constraints
  * Returns array to support composite primary keys

package/esm/core/codegen/cli/table-command-generator.d.ts

@@ -1,19 +1,5 @@
 import type { CleanTable, TypeRegistry } from '../../../types/schema';
 import type { GeneratedFile } from './executor-generator';
-/**
- * Get the set of field names that have defaults in the create input type.
- * Looks up the CreateXInput -> inner input type (e.g. DatabaseInput) in the
- * TypeRegistry and checks each field's defaultValue from introspection.
- */
-/**
- * Resolve the inner input type from a CreateXInput or UpdateXInput type.
- * The CreateXInput has an inner field (e.g. "database" of type DatabaseInput)
- * that contains the actual field definitions.
- */
-export declare function resolveInnerInputType(inputTypeName: string, typeRegistry: TypeRegistry): {
-    name: string;
-    fields: Set<string>;
-} | null;
 export declare function getFieldsWithDefaults(table: CleanTable, typeRegistry?: TypeRegistry): Set<string>;
 export interface TableCommandOptions {
     targetName?: string;

package/esm/core/codegen/cli/table-command-generator.js

@@ -1,7 +1,7 @@
 import * as t from '@babel/types';
 import { toKebabCase } from 'komoji';
 import { generateCode } from '../babel-ast';
-import { getGeneratedFileHeader, getPrimaryKeyInfo, getScalarFields, getTableNames, ucFirst, lcFirst, getCreateInputTypeName, getPatchTypeName, } from '../utils';
+import { getGeneratedFileHeader, getPrimaryKeyInfo, getScalarFields, getSelectableScalarFields, getTableNames, getWritableFieldNames, resolveInnerInputType, ucFirst, lcFirst, getCreateInputTypeName, getPatchTypeName, } from '../utils';
 function createImportDeclaration(moduleSpecifier, namedImports, typeOnly = false) {
     const specifiers = namedImports.map((name) => t.importSpecifier(t.identifier(name), t.identifier(name)));
     const decl = t.importDeclaration(specifiers, t.stringLiteral(moduleSpecifier));
@@ -112,8 +112,8 @@ function buildFieldSchemaObject(table) {
         return t.objectProperty(t.identifier(f.name), t.stringLiteral(schemaType));
     }));
 }
-function buildSelectObject(table) {
-    const fields = getScalarFields(table);
+function buildSelectObject(table, typeRegistry) {
+    const fields = getSelectableScalarFields(table, typeRegistry);
     return t.objectExpression(fields.map((f) => t.objectProperty(t.identifier(f.name), t.booleanLiteral(true))));
 }
 function buildJsonLog(expr) {
@@ -164,9 +164,9 @@ function buildSubcommandSwitch(subcommands, handlerPrefix, usageVarName) {
     ]));
     return t.switchStatement(t.identifier('subcommand'), cases);
 }
-function buildListHandler(table, targetName) {
+function buildListHandler(table, targetName, typeRegistry) {
     const { singularName } = getTableNames(table);
-    const selectObj = buildSelectObject(table);
+    const selectObj = buildSelectObject(table, typeRegistry);
     const tryBody = [
         buildGetClientStatement(targetName),
         t.variableDeclaration('const', [
@@ -184,11 +184,11 @@ function buildListHandler(table, targetName) {
         t.tryStatement(t.blockStatement(tryBody), buildErrorCatch('Failed to list records.')),
     ]), false, true);
 }
-function buildGetHandler(table, targetName) {
+function buildGetHandler(table, targetName, typeRegistry) {
     const { singularName } = getTableNames(table);
     const pkFields = getPrimaryKeyInfo(table);
     const pk = pkFields[0];
-    const selectObj = buildSelectObject(table);
+    const selectObj = buildSelectObject(table, typeRegistry);
     const promptQuestion = t.objectExpression([
         t.objectProperty(t.identifier('type'), t.stringLiteral('text')),
         t.objectProperty(t.identifier('name'), t.stringLiteral(pk.name)),
@@ -220,34 +220,6 @@ function buildGetHandler(table, targetName) {
         t.tryStatement(t.blockStatement(tryBody), buildErrorCatch('Record not found.')),
     ]), false, true);
 }
-/**
- * Get the set of field names that have defaults in the create input type.
- * Looks up the CreateXInput -> inner input type (e.g. DatabaseInput) in the
- * TypeRegistry and checks each field's defaultValue from introspection.
- */
-/**
- * Resolve the inner input type from a CreateXInput or UpdateXInput type.
- * The CreateXInput has an inner field (e.g. "database" of type DatabaseInput)
- * that contains the actual field definitions.
- */
-export function resolveInnerInputType(inputTypeName, typeRegistry) {
-    const inputType = typeRegistry.get(inputTypeName);
-    if (!inputType?.inputFields)
-        return null;
-    for (const inputField of inputType.inputFields) {
-        const innerTypeName = inputField.type.name
-            || inputField.type.ofType?.name
-            || inputField.type.ofType?.ofType?.name;
-        if (!innerTypeName)
-            continue;
-        const innerType = typeRegistry.get(innerTypeName);
-        if (!innerType?.inputFields)
-            continue;
-        const fields = new Set(innerType.inputFields.map((f) => f.name));
-        return { name: innerTypeName, fields };
-    }
-    return null;
-}
 export function getFieldsWithDefaults(table, typeRegistry) {
     const fieldsWithDefaults = new Set();
     if (!typeRegistry)
@@ -269,18 +241,6 @@ export function getFieldsWithDefaults(table, typeRegistry) {
     }
     return fieldsWithDefaults;
 }
-/**
- * Get the set of field names that actually exist in the create/update input type.
- * Fields not in this set (e.g. computed fields like searchTsvRank, hashUuid)
- * should be excluded from the data object in create/update handlers.
- */
-function getWritableFieldNames(table, typeRegistry) {
-    if (!typeRegistry)
-        return null;
-    const createInputTypeName = getCreateInputTypeName(table);
-    const resolved = resolveInnerInputType(createInputTypeName, typeRegistry);
-    return resolved?.fields ?? null;
-}
 function buildMutationHandler(table, operation, targetName, typeRegistry, ormTypes) {
     const { singularName } = getTableNames(table);
     const pkFields = getPrimaryKeyInfo(table);
@@ -341,7 +301,7 @@ function buildMutationHandler(table, operation, targetName, typeRegistry, ormTyp
         ? t.objectExpression([
             t.objectProperty(t.identifier(pk.name), t.booleanLiteral(true)),
         ])
-        : buildSelectObject(table);
+        : buildSelectObject(table, typeRegistry);
     let ormArgs;
     // Build data properties without individual type assertions.
     // Instead, we build a plain object from cleanedData and cast the entire
@@ -549,9 +509,9 @@ export function generateTableCommand(table, options) {
     ]), false, true));
     const tn = options?.targetName;
     const ormTypes = { createInputTypeName, patchTypeName, innerFieldName };
-    statements.push(buildListHandler(table, tn));
+    statements.push(buildListHandler(table, tn, options?.typeRegistry));
     if (hasGet)
-        statements.push(buildGetHandler(table, tn));
+        statements.push(buildGetHandler(table, tn, options?.typeRegistry));
     statements.push(buildMutationHandler(table, 'create', tn, options?.typeRegistry, ormTypes));
     if (hasUpdate)
         statements.push(buildMutationHandler(table, 'update', tn, options?.typeRegistry, ormTypes));

package/esm/core/codegen/utils.d.ts

@@ -1,4 +1,4 @@
-import type { CleanField, CleanFieldType, CleanTable } from '../../types/schema';
+import type { CleanField, CleanFieldType, CleanTable, TypeRegistry } from '../../types/schema';
 /** Lowercase first character */
 export declare function lcFirst(str: string): string;
 /** Uppercase first character */
@@ -148,6 +148,31 @@ export declare function isRelationField(fieldName: string, table: CleanTable): b
  * Get only scalar fields (non-relation fields)
  */
 export declare function getScalarFields(table: CleanTable): CleanField[];
+/**
+ * Resolve the inner input type from a CreateXInput.
+ * PostGraphile create inputs wrap the actual field definitions in an inner type
+ * (e.g. CreateUserInput -> { user: UserInput }) — this resolves that inner type
+ * and returns the set of field names it contains.
+ */
+export declare function resolveInnerInputType(inputTypeName: string, typeRegistry: TypeRegistry): {
+    name: string;
+    fields: Set<string>;
+} | null;
+/**
+ * Get the set of field names that actually exist in the create input type.
+ * Fields not in this set (e.g. computed fields like searchTsvRank, hashUuid)
+ * are plugin-added computed fields that don't correspond to real database columns.
+ * Returns null when no typeRegistry is provided (caller should treat as "no filtering").
+ */
+export declare function getWritableFieldNames(table: CleanTable, typeRegistry?: TypeRegistry): Set<string> | null;
+/**
+ * Get scalar fields that represent actual database columns (not computed/plugin-added).
+ * When a TypeRegistry is provided, filters out fields that don't exist in the
+ * create input type — these are computed fields added by plugins (e.g. search scores,
+ * hash UUIDs) that aren't real columns and shouldn't appear in default selections.
+ * Without a TypeRegistry, falls back to all scalar fields.
+ */
+export declare function getSelectableScalarFields(table: CleanTable, typeRegistry?: TypeRegistry): CleanField[];
 /**
  * Primary key field information
  */

package/esm/core/codegen/utils.js

@@ -261,6 +261,54 @@ export function isRelationField(fieldName, table) {
 export function getScalarFields(table) {
     return table.fields.filter((f) => !isRelationField(f.name, table));
 }
+/**
+ * Resolve the inner input type from a CreateXInput.
+ * PostGraphile create inputs wrap the actual field definitions in an inner type
+ * (e.g. CreateUserInput -> { user: UserInput }) — this resolves that inner type
+ * and returns the set of field names it contains.
+ */
+export function resolveInnerInputType(inputTypeName, typeRegistry) {
+    const inputType = typeRegistry.get(inputTypeName);
+    if (!inputType?.inputFields)
+        return null;
+    for (const inputField of inputType.inputFields) {
+        const innerTypeName = inputField.type.name
+            || inputField.type.ofType?.name
+            || inputField.type.ofType?.ofType?.name;
+        if (!innerTypeName)
+            continue;
+        const innerType = typeRegistry.get(innerTypeName);
+        if (!innerType?.inputFields)
+            continue;
+        const fields = new Set(innerType.inputFields.map((f) => f.name));
+        return { name: innerTypeName, fields };
+    }
+    return null;
+}
+/**
+ * Get the set of field names that actually exist in the create input type.
+ * Fields not in this set (e.g. computed fields like searchTsvRank, hashUuid)
+ * are plugin-added computed fields that don't correspond to real database columns.
+ * Returns null when no typeRegistry is provided (caller should treat as "no filtering").
+ */
+export function getWritableFieldNames(table, typeRegistry) {
+    if (!typeRegistry)
+        return null;
+    const createInputTypeName = getCreateInputTypeName(table);
+    const resolved = resolveInnerInputType(createInputTypeName, typeRegistry);
+    return resolved?.fields ?? null;
+}
+/**
+ * Get scalar fields that represent actual database columns (not computed/plugin-added).
+ * When a TypeRegistry is provided, filters out fields that don't exist in the
+ * create input type — these are computed fields added by plugins (e.g. search scores,
+ * hash UUIDs) that aren't real columns and shouldn't appear in default selections.
+ * Without a TypeRegistry, falls back to all scalar fields.
+ */
+export function getSelectableScalarFields(table, typeRegistry) {
+    const writableFields = getWritableFieldNames(table, typeRegistry);
+    return getScalarFields(table).filter((f) => writableFields === null || writableFields.has(f.name));
+}
 /**
  * Get primary key field information from table constraints
  * Returns array to support composite primary keys

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constructive-io/graphql-codegen",
-  "version": "4.14.0",
+  "version": "4.14.1",
   "description": "GraphQL SDK generator for Constructive databases with React Query hooks",
   "keywords": [
     "graphql",
@@ -101,5 +101,5 @@
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   },
-  "gitHead": "1ade5f10df8e38a5f87bbd2e2f7ec2ba97267079"
+  "gitHead": "64ef59e5114d52bc897c7e9ef92d35ca6525f12f"
 }