OpenKatana · List fonts:
OpenKatana_list_fonts helps you discover font files and compare their identifying information before choosing typography for your OpenKatana work. It reads font metadata to identify the family and style, supports case-insensitive searching, and can check whether a font contains the characters needed for a particular piece of text. The discovery process considers TrueType, OpenType, and TrueType Collection files, using a bounded directory search rather than an unrestricted scan through every subfolder. This makes it useful for finding suitable lettering for titles, captions, and multilingual artwork while identifying files that cannot be read. It is a font-discovery tool, not a visual font-identification service or a guarantee of licensing permission; bundled fonts receive additional metadata, and the tool explicitly distinguishes their licensing status from that of other fonts.
OpenKatana · List fonts Input Parameters:
project_id
A required STRING that supplies the project identifier to OpenKatana’s argument-preparation step before the font-listing tool is called. Use the identifier associated with the project you intend to work with so that the request is prepared in the appropriate project context. The supplied code does not show how this identifier is validated or exactly how it affects font-search locations, so it should not be treated as a directory path or a font search term. No default value, allowed-value list, length limit, minimum, or maximum is shown in the provided node interface.
arguments
A required STRING containing the tool arguments that OpenKatana prepares and passes to the font-listing operation. The underlying function shown in the context accepts directory, query, limit, and optional text; these belong inside the tool’s argument data rather than appearing as separate inputs on this node. The search loop uses query to match a substring against the combined family name, style, and filename without distinguishing uppercase from lowercase, and limit caps the number of font records returned. Supplying text requests a character-coverage check for each matching font, helping you identify whether your intended lettering is supported. Although this field is intended for serialized tool arguments, the supplied code does not include the argument parser or complete tool schema, so exact JSON requirements, accepted directory behavior, validation limits, and defaults cannot be established here. The underlying function explicitly shows text=None as its default; defaults for the other tool arguments and for the node’s arguments input are not provided.
after
An optional STRING accepted by the execution method but not explicitly referenced inside the displayed method body. The provided code does not establish a font-search effect or any particular interpretation of its contents, so it should not be used to control the search directory, query, result limit, or character-coverage check. If your surrounding OpenKatana workflow provides a convention for connecting this field, follow that convention; otherwise, it is not required by the shown interface. No default is shown in the input declaration, although the execution method uses None when this argument is omitted; no minimum, maximum, length restriction, or allowed-value list is provided.
OpenKatana · List fonts Output Parameters:
result_json
A STRING containing the response returned through OpenKatana’s response wrapper. The underlying font-listing function produces a structured result with fonts, matches, truncated, unreadable, and note; the exact outer response envelope is not shown. The fonts list contains up to the requested limit of records, each with an absolute resolved path, a family name, a style, and a Boolean collection value indicating whether the file is a TrueType Collection. Bundled fonts may include additional metadata whose complete field set is not supplied. When text checking is requested, each record also includes missing and covers: an empty missing string with covers=true means no missing characters were found, a nonempty string with covers=false identifies unsupported characters, and null values mean coverage could not be determined. The matches count reports all matching records found before the result limit is applied, while truncated indicates whether some matching records were omitted. The unreadable list identifies font paths that raised an OSError during metadata loading; these paths are collected before query filtering and therefore need not match your search. The note explains licensing limitations and states that a TTC record describes the first face in the collection rather than every face it contains.
OpenKatana · List fonts Usage Tips:
- Use a distinctive family name, style word, or filename fragment in the tool’s
queryargument to narrow your choices. Matching is case-insensitive, so changing capitalization will not change the search results. - Supply your actual title or caption through the tool’s
textargument when checking language support. Include accented letters, punctuation, and special symbols that you intend to use, then inspect bothcoversandmissing. - Treat
covers=nullas “not determined,” not as confirmation that the font supports your text. Preview the font in your intended rendering workflow before relying on it. - Check
matchesandtruncatedbefore assuming the returned font list is complete. Iftruncatedis true, increase the tool’slimitwithin the accepted schema or narrow your query; the shown implementation applies the limit after scanning and collecting matches, so a smaller limit does not necessarily reduce scanning work. - Keep relevant fonts directly inside a searched root or one directory below it. The shown search checks
*and*/*rather than traversing arbitrarily deep folder structures. - Do not expect WOFF or WOFF2 files to appear in this listing. Although other OpenKatana font workflows mention those formats, this discovery loop filters specifically for
.ttf,.otf, and.ttc. - For TTC files, verify that the first face is the one you want. This tool does not enumerate every face in a collection, and its returned note says timeline font loading also uses the first face.
- Review licensing separately for non-bundled fonts. The returned note identifies rows marked
bundled: trueas fonts shipped under SIL OFL 1.1 and states thatimport_mediacopies their licence into the project; listing a font alone does not perform that import.
OpenKatana · List fonts Common Errors and Solutions:
unexpected inputs: ...
- Explanation: This is an explicit error raised by the node when execution receives named fields outside its recognized tool-field definitions. Adding
directory,query,limit, ortextas extra node inputs is not supported by the authoritative interface shown here. - Solution: Keep the node inputs to
project_id,arguments, and optionalafter. Supply font-listing options throughargumentsusing the tool’s accepted argument schema.
Argument parsing or validation failure
- Explanation: Arguments are processed before the tool is invoked, but the parser, schema, and exact error messages are not included in the supplied code. Incorrect serialization, unsupported argument names, or unsuitable value types may prevent the request from reaching the font search.
- Solution: Check the installed tool’s signature or schema and provide arguments in its required format. Keep search text as text and use the documented type for the result limit rather than guessing defaults or permitted ranges.
Font paths appear in unreadable
- Explanation: This is a reported condition rather than a fatal error. The tool catches
OSErrorwhile loading a candidate font’s metadata, adds the path tounreadable, and continues scanning. The supplied code does not preserve the individual exception message, so the list alone does not identify the precise cause. - Solution: Check that each file is accessible and is a valid font that your environment can open. Replace damaged files or correct access permissions as appropriate; readable fonts can still appear in the same result.
No matching fonts are returned
- Explanation: An empty font list does not necessarily indicate a failure. The query may not match the font metadata or filename, files may be outside the supported formats or search depth, or a search root may not exist as a directory. The code silently skips roots that are not directories.
- Solution: Check the configured search location, shorten the query, and confirm that the files use
.ttf,.otf, or.ttcextensions. Place deeply nested files within the supported search depth and reviewunreadablefor files that could not be inspected.
truncated is true
- Explanation: The search found more matching records than the requested limit allows in the returned
fontslist. This is a normal result condition, not a font-loading error. - Solution: Increase
limitaccording to the installed tool’s accepted range, or use a more specificquery. Compare the returned list length withmatchesto understand how much of the result set you are seeing.
covers is false
- Explanation: The coverage check found characters from your supplied text that the font does not support. The
missingfield identifies those characters; this is a font-selection issue rather than a node execution failure. - Solution: Choose another font and test the same text again. Prioritize fonts that support the scripts and symbols in your artwork, and preview the final lettering in your intended renderer.
covers and missing are null
- Explanation: Coverage could not be determined. The supplied coverage reader looks for supported Unicode character-map structures and can return no result when it cannot interpret the relevant data; this is different from a successful check reporting no missing characters.
- Solution: Test the text directly in the intended rendering workflow or try another font file with readable character-map data. Do not treat null values as either confirmed support or confirmed lack of support.
