{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"vscode-p42ai-refactor","slug":"js-refactoring-assistant","name":"JS Refactoring Assistant","type":"extension","url":"https://marketplace.visualstudio.com/items?itemName=p42ai.refactor","page_url":"https://unfragile.ai/js-refactoring-assistant","categories":["code-editors"],"tags":["__web_extension","action","cjs","clean code","code action","code assist","codemod","convert","cts","ecmascript","es2015","es2016","es2017","es2018","es2019","es2020","es2021","es2022","es5","es6","extract","inline","javascript","javascriptreact","js","jsx","keybinding","keybindings","languages","legacy code","lint","linting","lodash","mjs","modernization","modernize","mts","programming languages","quick fix","react","refactor","refactoring","replace","ts","tsx","typescript","typescriptreact","update","upgrade","vue","vuejs"],"pricing":{"model":"freemium","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"vscode-p42ai-refactor__cap_0","uri":"capability://code.generation.editing.ast.based.variable.extraction.with.occurrence.detection","name":"ast-based variable extraction with occurrence detection","description":"Analyzes JavaScript/TypeScript syntax trees to identify selected code or expressions, then automatically detects all semantically equivalent occurrences in the current file scope. Generates refactored code with a new variable declaration and replaces all matched instances, handling both single and multiple occurrence scenarios through AST pattern matching rather than text-based regex.","intents":["Extract a selected expression into a named variable to reduce duplication","Find all places where the same expression appears and consolidate them into a single variable reference","Refactor magic numbers or repeated strings into named constants for readability"],"best_for":["JavaScript/TypeScript developers refactoring legacy code with repeated expressions","Teams modernizing codebases and improving variable naming clarity"],"limitations":["Single-file scope only — cannot detect or refactor equivalent expressions across multiple files","Requires valid, parseable syntax — will not execute on files with syntax errors","No semantic type-aware matching — relies on syntactic AST equivalence, not value equivalence"],"requires":["VS Code 1.x (minimum version unspecified)","JavaScript, TypeScript, JSX, or TSX file open in editor","Text selection or cursor position in valid code context"],"input_types":["source code (JavaScript/TypeScript/JSX/TSX)","text selection or cursor position"],"output_types":["refactored source code with new variable declaration","modified source code with replaced occurrences"],"categories":["code-generation-editing","ast-parsing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"vscode-p42ai-refactor__cap_1","uri":"capability://code.generation.editing.logical.expression.simplification.via.operator.normalization","name":"logical expression simplification via operator normalization","description":"Detects common patterns in conditional logic (string comparisons, double negations, redundant operators) and applies targeted transformations using AST rewriting. Converts verbose boolean expressions into modern JavaScript idioms (optional chaining, array.includes()) by pattern-matching against known anti-patterns and emitting optimized AST nodes that are then serialized back to source code.","intents":["Convert a chain of string equality checks (a === 'x' || a === 'y') into a single array.includes() call","Replace verbose null/undefined checks with optional chaining operator (?.)","Remove double negation (!!x) and simplify to single negation or positive form","Invert conditional logic to improve readability (flip if-else branches)"],"best_for":["Teams modernizing JavaScript codebases to ES2020+ standards","Developers improving code readability and reducing cognitive load in boolean expressions","Linting-adjacent workflows where code style enforcement is desired"],"limitations":["Pattern-based approach — only recognizes explicitly coded anti-patterns; cannot infer intent from complex custom logic","No semantic analysis of side effects — may suggest simplifications that alter evaluation order if expressions have side effects","Limited to single-file scope — cannot refactor expressions that depend on cross-file type information"],"requires":["VS Code 1.x (minimum version unspecified)","JavaScript or TypeScript file with conditional expressions","Cursor positioned on or selection containing a boolean expression"],"input_types":["source code (JavaScript/TypeScript)","conditional expressions, comparison chains, negation operators"],"output_types":["refactored source code with simplified boolean logic","modernized syntax using optional chaining, array methods, or inverted conditions"],"categories":["code-generation-editing","ast-parsing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"vscode-p42ai-refactor__cap_10","uri":"capability://code.generation.editing.interactive.code.action.discovery.via.context.menus.and.keyboard.shortcuts","name":"interactive code action discovery via context menus and keyboard shortcuts","description":"Integrates with VS Code's code action system to surface refactoring suggestions through multiple UI surfaces: Quick Fix menu (Cmd+.), Refactor menu (Ctrl+Cmd+R), Source Action menu (Ctrl+Cmd+S), and direct keyboard shortcuts (Ctrl+Cmd+X for Extract, Ctrl+Cmd+I for Inline). Analyzes cursor position and selection context to determine available actions and displays them in a prioritized list, enabling one-click application of refactorings.","intents":["Discover available refactoring actions for the current code context without memorizing keyboard shortcuts","Apply refactoring actions with a single keyboard shortcut or menu selection","Explore refactoring options interactively to improve code quality"],"best_for":["VS Code users familiar with code action workflows","Developers who prefer interactive discovery over command-line tools","Teams using VS Code as the primary development environment"],"limitations":["Requires VS Code as the editor — not available in other editors or IDEs","Action availability depends on cursor position and selection — not all actions are available in all contexts","No batch refactoring — actions must be applied one at a time through the UI"],"requires":["VS Code 1.x (minimum version unspecified)","JS Refactoring Assistant extension installed","Cursor positioned in a code context where refactoring actions are available"],"input_types":["cursor position in source code","text selection (optional)"],"output_types":["list of available code actions","refactored source code after action selection"],"categories":["code-generation-editing","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"vscode-p42ai-refactor__cap_11","uri":"capability://code.generation.editing.automated.suggestion.panel.with.file.level.refactoring.recommendations","name":"automated suggestion panel with file-level refactoring recommendations","description":"Scans the current file for common refactoring opportunities and displays recommendations in a suggestion panel with visual indicators (underlines with three dots) marking code that can be refactored. Analyzes the entire file scope to identify patterns that match known refactoring rules, then surfaces suggestions without requiring explicit user action, enabling proactive code quality improvements.","intents":["Discover refactoring opportunities in the current file without manually reviewing code","Identify code patterns that violate style guidelines or best practices","Improve code quality by applying suggested refactorings across the entire file"],"best_for":["Developers who want passive, proactive refactoring suggestions","Teams enforcing code style standards and best practices","Codebases with legacy patterns that need modernization"],"limitations":["File-level scope only — does not analyze cross-file patterns or dependencies","Suggestion accuracy depends on pattern matching rules — may produce false positives or miss subtle opportunities","No configuration for suggestion filtering — all detected patterns are surfaced"],"requires":["VS Code 1.x (minimum version unspecified)","JS Refactoring Assistant extension installed and enabled","JavaScript, TypeScript, JSX, TSX, or Vue.js file open in editor"],"input_types":["source code (JavaScript/TypeScript/JSX/TSX/Vue.js)","entire file content for pattern analysis"],"output_types":["list of refactoring suggestions with visual indicators","refactored source code after suggestion selection"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"vscode-p42ai-refactor__cap_12","uri":"capability://code.generation.editing.keybinding.driven.refactoring.with.macos.touch.bar.support","name":"keybinding-driven refactoring with macos touch bar support","description":"Provides direct keyboard shortcuts for common refactoring actions (Extract: Ctrl+Cmd+X, Inline: Ctrl+Cmd+I, Toggle Braces: Ctrl+Cmd+B, Move Up/Down: Ctrl+Alt+↑↓) with platform-specific variants for Windows/Linux, and adds dedicated Touch Bar buttons on macOS for Rename, Quick Fix, Refactor, and Source Action. Enables power users to apply refactorings without navigating menus, using keyboard-driven workflows for maximum efficiency.","intents":["Apply refactoring actions using keyboard shortcuts for faster workflow","Use Touch Bar buttons on macOS for quick access to common refactoring actions","Customize keybindings to match personal workflow preferences"],"best_for":["Power users who prefer keyboard-driven workflows","macOS developers using Touch Bar for quick action access","Teams with established keybinding conventions"],"limitations":["Keybindings may conflict with other VS Code extensions or custom keybinding configurations","Touch Bar support is macOS-only — not available on Windows or Linux","Keybinding customization requires manual VS Code configuration — no UI for rebinding"],"requires":["VS Code 1.x (minimum version unspecified)","JS Refactoring Assistant extension installed","macOS (for Touch Bar support) or Windows/Linux (for keyboard shortcuts)"],"input_types":["keyboard input (keybindings)","Touch Bar button press (macOS only)"],"output_types":["refactored source code after action execution"],"categories":["code-generation-editing","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"vscode-p42ai-refactor__cap_13","uri":"capability://tool.use.integration.freemium.licensing.with.free.tier.and.premium.features","name":"freemium licensing with free tier and premium features","description":"Offers a free tier with core refactoring actions (extract variable, inline variable, basic simplifications) and a premium tier with advanced features (additional code actions, priority support, early access to new features). Uses VS Code's extension marketplace for distribution and licensing, with in-app prompts to upgrade to premium for advanced features.","intents":["Use basic refactoring actions without paying for a license","Upgrade to premium tier for access to advanced refactoring features","Evaluate the extension before committing to a paid subscription"],"best_for":["Individual developers evaluating refactoring tools","Teams with budget constraints who want to start with free tier","Organizations willing to pay for advanced features and support"],"limitations":["Free tier limitations are not documented — unclear which features are free vs. premium","Pricing for premium tier is not disclosed in marketplace listing","No information on subscription model (monthly, annual, one-time purchase)"],"requires":["VS Code 1.x (minimum version unspecified)","JS Refactoring Assistant extension installed","Internet connection for license verification (assumed)"],"input_types":["license key or account authentication (for premium tier)"],"output_types":["access to free or premium features based on license"],"categories":["tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"vscode-p42ai-refactor__cap_2","uri":"capability://code.generation.editing.inline.variable.elimination.with.scope.aware.replacement","name":"inline variable elimination with scope-aware replacement","description":"Identifies variable declarations and their usage sites within the current file scope, then replaces all references with the variable's assigned value by performing AST-level substitution. Handles scope boundaries (block scope, function scope) and validates that inlining does not create unintended variable shadowing or reference errors before applying the transformation.","intents":["Remove intermediate variables that are assigned once and used once, reducing code verbosity","Consolidate temporary variables back into their assignment expressions for cleaner code flow","Eliminate variables that were extracted for debugging but are no longer needed"],"best_for":["Developers cleaning up refactored code with unnecessary intermediate variables","Teams applying code style standards that discourage single-use temporary variables"],"limitations":["Cannot inline variables with multiple assignments — only works for single-assignment variables","No cross-file scope awareness — cannot inline variables that are exported or imported","Does not handle variables with side effects in their initialization — may produce incorrect results if inlining changes evaluation order"],"requires":["VS Code 1.x (minimum version unspecified)","JavaScript or TypeScript file with variable declarations","Cursor positioned on a variable declaration statement"],"input_types":["source code (JavaScript/TypeScript)","variable declaration with single assignment"],"output_types":["refactored source code with variable references replaced by assigned values","modified code with variable declaration removed"],"categories":["code-generation-editing","ast-parsing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"vscode-p42ai-refactor__cap_3","uri":"capability://code.generation.editing.return.statement.extraction.from.assignments","name":"return statement extraction from assignments","description":"Detects variable assignments that are immediately followed by a return statement (or are the final statement in a function), then refactors the code to eliminate the intermediate variable by replacing the assignment with a direct return of the assigned expression. Uses AST pattern matching to identify this specific anti-pattern and applies a single-step transformation.","intents":["Remove unnecessary intermediate variables that exist only to hold a return value","Simplify function bodies by returning expressions directly instead of assigning to a variable first","Reduce code lines and improve function readability"],"best_for":["Developers refactoring functions with unnecessary intermediate variables","Teams enforcing code style that discourages single-use temporary variables in return paths"],"limitations":["Only applies to the specific pattern of assignment-then-return; does not handle more complex control flow","Cannot refactor if the variable is referenced elsewhere before the return statement","No multi-statement expression support — only works for single-expression assignments"],"requires":["VS Code 1.x (minimum version unspecified)","JavaScript or TypeScript file with assignment-return pattern","Cursor positioned on the assignment statement"],"input_types":["source code (JavaScript/TypeScript)","variable assignment followed by return statement"],"output_types":["refactored source code with direct return of assigned expression","modified code with intermediate variable declaration removed"],"categories":["code-generation-editing","ast-parsing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"vscode-p42ai-refactor__cap_4","uri":"capability://code.generation.editing.operator.inversion.and.condition.flipping","name":"operator inversion and condition flipping","description":"Analyzes conditional expressions and if-statements to identify opportunities for logical inversion, then generates refactored code with inverted operators (< to >, && to ||) or flipped if-else branches. Uses AST transformation to negate conditions and swap branch bodies while preserving semantic equivalence, improving code readability by reducing nested negations.","intents":["Flip an if-else statement to reduce nesting depth and improve readability","Invert a comparison operator to make the condition more intuitive","Remove double negations and simplify boolean logic"],"best_for":["Developers improving code readability by reducing conditional nesting","Teams applying code style standards that prefer positive conditions over negations"],"limitations":["Does not handle complex multi-branch conditions (switch statements, ternary chains)","Cannot invert conditions with side effects in the condition expression itself","Limited to simple comparison and logical operators — does not handle custom operator overloads"],"requires":["VS Code 1.x (minimum version unspecified)","JavaScript or TypeScript file with conditional expressions or if-statements","Cursor positioned on the condition or if-statement"],"input_types":["source code (JavaScript/TypeScript)","conditional expressions, if-statements, comparison operators"],"output_types":["refactored source code with inverted operators or flipped branches","modified code with simplified boolean logic"],"categories":["code-generation-editing","ast-parsing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"vscode-p42ai-refactor__cap_5","uri":"capability://code.generation.editing.negation.push.down.and.pull.up.transformation","name":"negation push-down and pull-up transformation","description":"Detects negation operators (!) in boolean expressions and applies De Morgan's laws to move negation deeper into expressions (push-down) or pull negation out of nested expressions (pull-up). Uses AST rewriting to transform expressions like !(a && b) into !a || !b or vice versa, improving code readability by reducing double negations and simplifying boolean logic.","intents":["Apply De Morgan's laws to simplify negated boolean expressions","Move negation operators to make conditions more readable and intuitive","Eliminate double negations and reduce cognitive load in complex boolean logic"],"best_for":["Developers improving readability of complex boolean expressions","Teams enforcing code style that discourages nested negations"],"limitations":["Only applies to standard logical operators (&&, ||, !); does not handle custom operator overloads","Cannot optimize expressions with side effects in sub-expressions","Limited to single-file scope — no cross-file expression analysis"],"requires":["VS Code 1.x (minimum version unspecified)","JavaScript or TypeScript file with negated boolean expressions","Cursor positioned on a negation operator or boolean expression"],"input_types":["source code (JavaScript/TypeScript)","negated boolean expressions with && and || operators"],"output_types":["refactored source code with negation pushed down or pulled up","simplified boolean expressions applying De Morgan's laws"],"categories":["code-generation-editing","ast-parsing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"vscode-p42ai-refactor__cap_6","uri":"capability://code.generation.editing.string.comparison.chain.to.array.includes.conversion","name":"string comparison chain to array.includes() conversion","description":"Identifies patterns where a variable is compared against multiple string literals using OR operators (a === 'x' || a === 'y' || a === 'z'), then automatically refactors the expression into a single array.includes() call (['x', 'y', 'z'].includes(a)). Uses AST pattern matching to detect this anti-pattern and generates optimized code that is more readable and performant for large comparison chains.","intents":["Simplify long chains of string equality comparisons into a single array.includes() call","Improve code readability by replacing verbose OR chains with a more idiomatic JavaScript pattern","Modernize legacy code that uses outdated comparison patterns"],"best_for":["Developers modernizing JavaScript codebases to use ES2015+ idioms","Teams refactoring code with long comparison chains for improved readability"],"limitations":["Only recognizes the specific pattern of variable === literal || variable === literal; does not handle reverse patterns (literal === variable)","Limited to string literals — does not convert number or boolean comparison chains","Cannot optimize if the variable is reassigned or has side effects between comparisons"],"requires":["VS Code 1.x (minimum version unspecified)","JavaScript or TypeScript file with string comparison chains","Cursor positioned on a comparison chain expression"],"input_types":["source code (JavaScript/TypeScript)","string comparison chains using === and || operators"],"output_types":["refactored source code using array.includes() method","modernized code with improved readability and performance"],"categories":["code-generation-editing","ast-parsing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"vscode-p42ai-refactor__cap_7","uri":"capability://code.generation.editing.optional.chaining.operator.insertion.for.null.undefined.checks","name":"optional chaining operator insertion for null/undefined checks","description":"Analyzes property access and method call expressions that are preceded by explicit null/undefined checks (if (obj && obj.prop) or if (obj !== null && obj.method())), then refactors the code to use the optional chaining operator (?.) to eliminate the verbose guard clause. Uses AST pattern matching to identify guard patterns and generates modernized code that is more concise and readable.","intents":["Replace verbose null/undefined checks with optional chaining operator for cleaner code","Modernize legacy code that uses explicit guard clauses for property access","Reduce code verbosity in conditional expressions that check for null/undefined before accessing properties"],"best_for":["Developers modernizing JavaScript codebases to ES2020+ standards","Teams refactoring code with verbose null/undefined checks for improved readability"],"limitations":["Only recognizes explicit guard patterns (if (obj && obj.prop)); does not infer intent from other null-checking patterns","Cannot convert if the guard clause has side effects or additional conditions","Limited to single-file scope — no cross-file type information for null-safety analysis"],"requires":["VS Code 1.x (minimum version unspecified)","JavaScript or TypeScript file with null/undefined guard clauses","Cursor positioned on a guard clause or property access expression"],"input_types":["source code (JavaScript/TypeScript)","null/undefined guard clauses, property access expressions"],"output_types":["refactored source code using optional chaining operator (?.)","modernized code with eliminated guard clauses"],"categories":["code-generation-editing","ast-parsing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"vscode-p42ai-refactor__cap_8","uri":"capability://code.generation.editing.double.negation.removal.and.simplification","name":"double negation removal and simplification","description":"Detects double negation patterns (!!x) in boolean expressions and refactors them to their simplified form (x for truthy coercion, or !x for single negation). Uses AST analysis to identify redundant negation operators and applies targeted transformations that preserve semantic equivalence while improving code readability.","intents":["Remove double negations (!!x) that are used for truthy coercion and replace with idiomatic alternatives","Simplify boolean expressions by eliminating redundant negation operators","Improve code readability by reducing cognitive load in boolean logic"],"best_for":["Developers improving code readability by eliminating redundant operators","Teams enforcing code style that discourages double negation for truthy coercion"],"limitations":["Only recognizes explicit double negation patterns; does not infer intent from complex boolean expressions","Cannot optimize if the expression has side effects","Limited to single-file scope — no cross-file expression analysis"],"requires":["VS Code 1.x (minimum version unspecified)","JavaScript or TypeScript file with double negation expressions","Cursor positioned on a double negation operator"],"input_types":["source code (JavaScript/TypeScript)","double negation expressions (!!x)"],"output_types":["refactored source code with double negation removed","simplified boolean expressions"],"categories":["code-generation-editing","ast-parsing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"vscode-p42ai-refactor__cap_9","uri":"capability://code.generation.editing.multi.language.syntax.support.with.language.specific.code.actions","name":"multi-language syntax support with language-specific code actions","description":"Provides unified refactoring interface across JavaScript, TypeScript, React (JSX/TSX), and Vue.js, with language-specific code actions that adapt to each language's syntax and idioms. Automatically detects file type and language context, then surfaces only relevant refactoring actions for that language, using language-specific AST parsers and transformation rules.","intents":["Refactor JavaScript code using modern ES2020+ syntax and idioms","Refactor TypeScript code with type-aware transformations and type-safe refactorings","Refactor React components with JSX-specific code actions and patterns","Refactor Vue.js components with Vue-specific syntax and template support"],"best_for":["Full-stack developers working across multiple JavaScript-family languages","Teams with mixed JavaScript/TypeScript/React/Vue codebases","Developers modernizing legacy JavaScript code to TypeScript"],"limitations":["Limited to JavaScript-family languages — does not support other languages (Python, Java, etc.)","Vue.js support is limited to script sections; template refactoring is not documented","No cross-language refactoring — cannot refactor code that spans multiple files in different languages"],"requires":["VS Code 1.x (minimum version unspecified)","JavaScript, TypeScript, JSX, TSX, or Vue.js file open in editor","File extension recognized as one of the supported languages"],"input_types":["source code (JavaScript/TypeScript/JSX/TSX/Vue.js)","language-specific syntax and idioms"],"output_types":["refactored source code with language-specific transformations","modernized code following language-specific best practices"],"categories":["code-generation-editing","ast-parsing"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":46,"verified":false,"data_access_risk":"moderate","permissions":["VS Code 1.x (minimum version unspecified)","JavaScript, TypeScript, JSX, or TSX file open in editor","Text selection or cursor position in valid code context","JavaScript or TypeScript file with conditional expressions","Cursor positioned on or selection containing a boolean expression","JS Refactoring Assistant extension installed","Cursor positioned in a code context where refactoring actions are available","JS Refactoring Assistant extension installed and enabled","JavaScript, TypeScript, JSX, TSX, or Vue.js file open in editor","macOS (for Touch Bar support) or Windows/Linux (for keyboard shortcuts)"],"failure_modes":["Single-file scope only — cannot detect or refactor equivalent expressions across multiple files","Requires valid, parseable syntax — will not execute on files with syntax errors","No semantic type-aware matching — relies on syntactic AST equivalence, not value equivalence","Pattern-based approach — only recognizes explicitly coded anti-patterns; cannot infer intent from complex custom logic","No semantic analysis of side effects — may suggest simplifications that alter evaluation order if expressions have side effects","Limited to single-file scope — cannot refactor expressions that depend on cross-file type information","Requires VS Code as the editor — not available in other editors or IDEs","Action availability depends on cursor position and selection — not all actions are available in all contexts","No batch refactoring — actions must be applied one at a time through the UI","File-level scope only — does not analyze cross-file patterns or dependencies","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.54,"quality":0.5,"ecosystem":0.35000000000000003,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.15,"match_graph":0.23,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:34.803Z","last_scraped_at":"2026-05-03T15:20:37.518Z","last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=js-refactoring-assistant","compare_url":"https://unfragile.ai/compare?artifact=js-refactoring-assistant"}},"signature":"RDQrW8Ux5Q7dIG1oi+NhXOr28MrzEjvVK8qBNGAl5mjvWQ4TKYbqpMixNioGpO7fu5cEyk194ktWVpRmRjrhBA==","signedAt":"2026-06-21T15:04:08.528Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/js-refactoring-assistant","artifact":"https://unfragile.ai/js-refactoring-assistant","verify":"https://unfragile.ai/api/v1/verify?slug=js-refactoring-assistant","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}