Changelog

Consistent light and dark themes

Refines the monochrome interface with shared surface, text and status colors across tools and resources.

• Normalizes legacy cards, editors, controls and diagrams
• Prevents mixed-color transitions when changing themes
• Keeps theme controls working with blocked browser storage
• Synchronizes themes between tabs and fixes low-contrast helper text

Folder and ZIP import preview

Discover integration sources in a local folder or ZIP, select what to import, and review file-by-file results.

• Adds folder selection and ZIP imports with source paths
• Previews supported files, parser errors and skipped files
• Skips dependency folders and duplicate content
• Checks ZIP integrity and bounds extraction sizes

Local project opening fixes

Open downloaded architecture projects from the upload area and recover cleanly from blocked browser storage.

• Recognizes project files even after renaming
• Accepts UTF-8 BOM project JSON
• Explains review exports and browser-local project storage
• Handles corrupt saved-project metadata and closes blocked database connections

Generic samples and more integration platforms

Map Workato recipes, IBM ACE/IIB flows and Terraform exports, and generate Terraform infrastructure alongside application code.

• Uses generic GateSift and Sample integration names
• Adds local Workato recipe and IBM ACE/IIB flow imports
• Maps explicit Terraform plan/state dependencies
• Offers Terraform JSON generation with validation CI and deployment instructions

Saved architecture projects and flow tracing

Save integration sources, review decisions, notes and map settings locally, then trace dependencies from a chosen starting point.

• Adds named browser projects and portable project files containing original configuration
• Preserves source identities, link decisions, notes and trace settings when reopening projects
• Adds upstream and downstream tracing with evidence, confidence filters and unresolved references
• Draws consumer references in delivery direction and keeps unrelated functions out of entity traces
• Keeps sanitized JSON review exports separate from reopenable project files

Centralized application theme

Moves the GateSift palette into one theme control center and aligns builders, visualizers and reports around the same visual language.

• Adds src/app/theme.css as the single application palette source for dark and light mode
• Standardizes actions and selections on green, warnings on amber, destructive states on rose and structural UI on neutrals
• Moves React Flow canvas, edge, minimap and role colors to CSS theme variables instead of component-local color literals
• Reworks Integration Solution Builder, BizTalk summary chips, Service Bus chips and catalogue status badges to consume shared semantic tokens
• Strengthens theme parity tests so centralized tokens, contrast and retired blue/purple/slate accents are checked across primary style and flow sources
• Aligns standalone report exports with the same green / amber / rose / neutral visual language

Theme parity hotfix

Keeps the visual refresh within GateSift's supported green, amber and rose palette so CI theme parity passes.

• Removes the reintroduced blue/purple palette rejected by the theme-parity guard
• Uses green selected and action states that remain readable in both light and dark mode
• Gives BizTalk receive, send and review summary chips distinct green, amber and rose semantics
• Preserves the stronger visual hierarchy from the visual refresh without weakening the theme tests

Builder summary typecheck hotfix

Fixes the Integration Solution Builder summary metric after the application/deployment split.

• Uses the shared applicationFileCount summary field for Function App and Logic App patterns
• Renames the UI metric from Function files to Application files
• Restores TypeScript compilation in the deployment workflow

Static Web Apps deployment hotfix

Builds the static Next.js export explicitly in GitHub Actions and deploys the finished out/ directory without relying on Oryx build detection.

• Uses Node.js 22 and npm ci before the deployment step
• Runs the existing quality checks and static Next.js export before upload
• Verifies out/index.html exists so a missing export fails with a clear error
• Deploys out/ with skip_app_build enabled, bypassing Oryx framework detection

Visual refresh for builders and chips

Improves contrast and makes action buttons, tabs and summary chips clearer in both dark and light mode.

• Gives builder action buttons and tabs stronger accent styling that reads on both dark and light backgrounds
• Keeps Download ZIP as a solid green primary action while secondary buttons use a clearer visual hierarchy
• Improves numbered step badges and selected-state affordances in the Integration Solution Builder
• Refreshes summary chips used in BizTalk and Service Bus views so counts stand out more clearly
• Makes status badges across the catalogue more readable instead of using flat gray-on-gray pills

Integration solution patterns

Adds the first multi-component pattern: file pickup with Logic Apps Standard and Service Bus.

• Adds Function App and File pickup → messaging as explicit solution patterns
• Generates a Logic Apps Standard workflow for SFTP or mounted file-server pickup
• Generates Service Bus queue or topic infrastructure and sender RBAC
• Keeps Application and Deployment files separated in the generated preview
• Keeps the pattern model open for Claim Check, API and Pub/Sub generators

Function App Builder refinement

Makes the Function App generator quieter and closer to a real integration repository structure.

• Adds configurable integration-folder and Function App project names, with matching sample defaults
• Replaces the generated Handler layer with Orchestrators
• Removes generated nuget.config and trims generated README/Bicep metadata
• Removes the separate Deployment Modules roadmap item and keeps Function App Builder as the single build surface
• Reduces explanatory UI copy while preserving validation and generated-file preview

Flow-first BizTalk

Turns BizTalk send-port subscriptions into searchable flow evidence and makes flows, not the full configuration map, the primary way to understand a binding.

• Parses BTS.ReceivePortName and BTS.InboundTransportLocation subscription filters into structured routing evidence
• Resolves high-confidence receive-to-send subscription routes alongside orchestration bindings
• Opens bound BizTalk exports on a searchable Flows workspace with Map and Components as secondary views
• Simplifies map controls to search, trace, full map and filters while keeping technical details collapsible
• Separates important issues from lower-priority observations and improves typography for dense enterprise bindings

BizTalk flow readability

Made large BizTalk bindings open around their resolved runtime path, protected map text from over-zooming and moved supporting analysis behind an optional section.

• Large bindings with a concise resolved relationship set start in detailed runtime-path mode with unrelated configuration hidden
• The Unlinked filter now also works for grouped adapter overview nodes and reports the concrete endpoints represented by those groups
• Dense maps keep a readable minimum fit zoom and focused components center closer for inspection
• BizTalk edges, details, explorer labels and supporting explanations use stronger light-mode contrast
• Relationship health, adapter landscape and detected patterns now sit in a collapsed Supporting analysis section below the primary workspace

Contrast and CI hotfix

Fixed the v0.37 architecture regression fixture and made light mode deliberately higher-contrast across execution flows, documentation and semantic status surfaces.

• Architecture regression fixture now contains the blob dependency it asserts, allowing the v0.37 cross-artifact suite to complete in CI
• Removed an unused Architecture Mapper helper that produced an ESLint warning
• Light mode uses darker secondary text and borders instead of washed-out dark-theme values
• APIM execution documentation uses light surfaces with dark copy rather than inherited dark section headers
• Logic App flow cards, badges and semantic states now use stronger accessible green, amber and red accents
• Deployment Builder and Service Bus semantic states use stronger light-mode borders, text and backgrounds

Cross-artifact intelligence

Expanded deterministic architecture matching across Azure and legacy integration artifacts without adding fuzzy or AI-generated relationships.

• Architecture Mapper now accepts Azure Function ARM/resource JSON and exposes Function App hosts, functions and bindings as normalized entities
• APIM, Logic App and BizTalk HTTP endpoints can resolve to loaded Azure Functions by explicit azurewebsites.net host and function route
• Azure Function Service Bus bindings resolve to loaded queues or topics; duplicate entity names remain Possible rather than being guessed
• Logic App HTTP references retain the full local URL identity for matching while exported/displayed URLs continue to strip credentials and query strings
• Logic App Standard service-provider references and blob/file/container resource names are extracted for clearer external dependency evidence
• Relationship review now uses a direct Why linked? action and the safe Architecture sample includes APIM → Function → Service Bus alongside APIM → Logic App → Service Bus

Architecture map review

Made larger architecture workspaces easier to read by showing participating entities, adding map filters and turning node selection into a source-evidence drill-down.

• Architecture maps now distinguish loaded artifacts, participating entities and unresolved external references
• Cross-links connect the exact policy statement, workflow action, BizTalk endpoint or Service Bus entity when that evidence is available
• Added APIM, Logic Apps, Service Bus and BizTalk map filters plus a Confirmed only review mode
• Artifact and entity selection now exposes normalized inventory, metadata and relationship evidence without leaving the map
• Dense maps switch to a vertical Dagre layout and grow in height so 10–30 visible nodes remain easier to inspect
• Safe-example regression fixtures now use stable IDs or dedicated test data so public example ordering cannot break CI

Safe starts

Restored one quiet synthetic example path for each main GateSift tool without bringing back the old demo-heavy interface.

• APIM, Logic Apps, Service Bus, BizTalk, Architecture Mapper and Deployment Builder now expose a compact Use safe example action
• The examples describe one synthetic GateSift Orders system so cross-tool behavior is easier to understand
• Loaded sample input is marked as Sample data without adding explanatory cards or marketing copy
• Architecture Mapper sample input resolves the deterministic APIM → Logic App → Service Bus path

Light-first polish

Made light mode the first-run theme, neutralized pale status colors and hardened recovery for browser-side tool failures.

• New visitors start in light mode while an explicit saved light/dark preference still wins
• Success and warning surfaces use neutral grey styling in light mode instead of pale green and yellow panels
• The browser error screen now has readable light-mode controls and performs a full reload to recover from stale deployment chunks
• Logic App and Service Bus export preparation is isolated so a non-critical report error cannot take down the analyzer view

Quieter interface

Reduced the public site to the parts people actually need and replaced the accent-heavy presentation with a neutral light/dark interface.

• Added a dedicated About page and moved project story, feedback, support and future direction away from the homepage
• Rebuilt the homepage, Tools and Build pages around short lists instead of repeated marketing sections, cards and roadmap copy
• Reduced tool-page intros and removed repeated trust badges, outcome strips and onboarding explanations
• Changed the visual system from blue/purple accents to black, white and neutral greys with flatter surfaces, smaller radii and no marketing gradients
• Simplified the APIM and BizTalk first-run screens and trimmed Architecture Mapper labels without changing analyzer behavior

Focused product surface

Removed generic conversion utilities, public demo shortcuts and Markdown export surfaces so GateSift stays centered on integration analysis, architecture review and structured outputs.

• Removed the XML, JSON and flat-file to C# generator route, registry entry, implementation and generator-specific release checks
• Removed public safe-example loaders from APIM, Logic Apps, Service Bus, BizTalk and the Architecture Mapper while retaining internal regression fixtures
• Removed user-facing Markdown export and preview options; APIM keeps PDF/HTML/JSON while other review tools keep versioned JSON exports
• Updated discovery, smoke routes, documentation and product copy to match the narrower GateSift scope

Integration Architecture Mapper MVP

Added a local multi-artifact architecture workspace that combines APIM, Logic Apps, BizTalk and Service Bus into one evidence-backed map without introducing cloud discovery or fuzzy AI guesses.

• New Integration Architecture Mapper Early access route with multi-file drag/drop and a safe APIM → Logic App → Service Bus example
• Existing platform parsers feed a shared workspace inventory instead of being duplicated inside the mapper
• Deterministic cross-artifact rules resolve Logic App workflow URLs, Service Bus connector resources, Service Bus endpoints and exact explicit references
• Every cross-artifact link keeps confirmed, high or possible confidence plus the configuration evidence and match rule that produced it
• High/possible links can be confirmed or dismissed locally without mutating the uploaded source artifacts
• Architecture map, source-artifact inventory, unresolved external references and Markdown/JSON exports are included in the MVP
• Logic App parsing now exposes connector/resource references, while BizTalk static transport addresses contribute conservative endpoint evidence
• Architecture Mapper styles live in a dedicated stylesheet so the already-large global stylesheet does not grow further

Architecture foundation and product hardening

Consolidated tool maturity metadata, split oversized workbench UI, added static-route smoke coverage and introduced the shared artifact model that will power the Integration Architecture Mapper.

• Tool maturity now derives from the shared platform catalog across tool pages, structured data and the BizTalk workspace
• Removed the obsolete BizTalk coming-soon component and extracted BizTalk workspace insight panels plus the APIM welcome screen from oversized workbench files
• Added deterministic APIM, Logic App, BizTalk and Service Bus artifact detection and a shared entity/relationship summary contract
• Added artifact-summary builders with explicit confirmed, high and possible relationship confidence instead of pretending unresolved links are known
• Added architecture-foundation regression coverage and a post-build static-export smoke test for the primary GateSift routes
• Azure Static Web Apps deployment now runs the complete npm run check gate instead of build-only validation
• The public roadmap now emphasizes local-first analyzers, architecture mapping and open resources over speculative cloud features

BizTalk large-binding search

Made the BizTalk Component Explorer faster to use with hundreds of components by replacing expanded search trees with bounded, relevance-ranked component results.

• Active Explorer searches now show a flat ranked result list instead of expanding every matching application and receive-port branch
• Exact component names rank ahead of prefix, parent-port, application and adapter metadata matches
• Broad searches render at most 80 strongest matches with an explicit refine-search notice while preserving the full matching count
• Search results show component type, application, receive-port context and operational metadata before navigation
• The existing hierarchical explorer remains unchanged when no search is active

BizTalk cross-view component context

Made component-oriented review easier in large BizTalk bindings by keeping the current component visible across workspace views and linking directly to its map, findings and relationship evidence.

• A persistent current-component bar now keeps endpoint or orchestration context visible while moving between Map, Endpoints, Relationships and Findings
• Component actions expose finding and relationship counts before navigation so reviewers can move directly to relevant evidence
• Relationship scoping now uses component IDs rather than name-only search, including receive locations whose parent port uses a different name
• Relationship scope can be cleared independently while all parser, analyzer, comparison and export behavior remains unchanged

BizTalk large-map balance

Made large detailed BizTalk maps more representative under the existing node safety limit instead of letting source ordering hide entire component types.

• Detailed-map truncation now samples receive locations, orchestrations and send ports in balance instead of taking only the first nodes from the binding
• Components with findings and relationship-connected components are prioritized so high-signal evidence remains visible in large reviews
• The node-limit notice now explains the sampling behavior and points users to explorer search and filters for exact component navigation
• Regression coverage protects large bindings from returning to source-order-biased map truncation

BizTalk first-run input clarity

Made the BizTalk file-first workflow more explicit so new users know which XML shape is expected and what GateSift will produce before selecting customer input.

• Initial copy now names BizTalk BindingInfo XML and the expected BindingInfo root element instead of using generic binding-file wording
• The existing outcome strip now appears before the drop zone so component inventory, relationship mapping, findings and sanitized exports are visible before upload
• Primary file selection and safe-example actions now use clearer labels while all parsing, analysis, comparison and export behavior remains unchanged

APIM first-run input clarity

Aligned the APIM primary start path with the input methods already available in the editor so a new user can paste, import or drop policy XML without an extra focus step.

• Primary APIM start action now describes paste, import and drag-and-drop instead of implying paste is the only input path
• Choosing the primary APIM start action focuses the policy editor immediately so clipboard input does not require a second click
• Editor guidance now names paste, import and drop consistently while keeping all parsing and analysis behavior unchanged

First-use clarity

Made the homepage entry path more self-explanatory with a direct start action, a compact three-step workflow and more readable input choices.

• Primary homepage action now jumps directly to the artifact-first entry workflow instead of adding an extra catalogue step
• Added a compact Choose → Work locally → Review explanation without introducing a forced tour or large onboarding block
• Increased the homepage input-card text slightly so the most important selection labels are easier to scan
• Kept all existing tools, routes, analyzers, parsers, exports, local storage and tool registry behavior unchanged

Homepage hierarchy refinement

Reduced repeated homepage choices so the artifact-first workflow is the clear starting point and deeper catalogue content stays on dedicated pages.

• Removed the redundant Analyze now shortcut row from the hero while preserving the product-level Tools and Pattern Library actions
• Removed the previously hidden Available now catalogue from the homepage render so duplicate tool markup is no longer kept in the DOM
• Reduced the homepage Pattern Library preview to three representative patterns
• Reduced version history on the homepage to the latest meaningful release with the full history still available in the changelog
• Kept all existing tools, routes, registry metadata, roadmap information and support behavior unchanged

Homepage focus and artifact-first entry

Reduced homepage repetition and made the configuration or task a user already has the clearest path into GateSift, while promoting the current local-first privacy boundary.

• Homepage entry now derives directly from the shared accepted-input tool registry instead of duplicating product copy
• Six large repeated tool cards are replaced in the homepage presentation by a compact analyzer, build-tool and Pattern Library summary
• Local browser processing, no account and no cloud project storage are surfaced beside the primary entry workflow
• Existing tools, routes and lower-page product information remain intact so the hierarchy change is easy to review and roll back

First-time discoverability and outcome guidance

Made tool selection input-first and clarified what each analyzer produces, while keeping onboarding optional and lightweight for experienced integration engineers.

• Tools catalogue now starts with the configuration or task the user already has instead of requiring product-name knowledge
• APIM, Logic Apps, BizTalk and Service Bus expose compact What you’ll get outcomes before deeper review surfaces
• APIM offers an optional 30-second workflow instead of a forced product tour
• Available-tool registry tests now require explicit accepted inputs and expected outcomes so discoverability cannot silently drift

Light and dark theme parity

Hardened light-mode contrast and semantic color behavior across navigation, first-run controls and analyzer surfaces while preserving the established GateSift dark-mode identity.

• Semantic action, accent, muted, success and warning colors now meet the same readability standard in both appearance modes
• Light-mode navigation, Quick Start, trust badges and maturity states no longer rely on pale cyan or slate text against white surfaces
• Service Bus, BizTalk, Pattern Intelligence and deployment guidance receive targeted light-theme contrast and surface fixes
• Theme regression coverage checks the shared semantic palette maintains at least 4.5:1 text contrast against both theme backgrounds

Visual hierarchy and first-run polish

Refined tool-page typography, contrast and first-run hierarchy so users reach input actions sooner, while simplifying trust messaging and reducing unnecessary visual weight across analyzers.

• Tool-page headings and vertical spacing are smaller so Quick Start appears earlier without changing the homepage identity
• Secondary text, inactive navigation and first-run controls have stronger contrast while semantic green/cyan accents carry clearer meaning
• Logic App feedback duplication was removed, review scores are less dominant and metric cards use a lighter visual treatment
• BizTalk first-run spacing and Early access styling now match the broader GateSift analyzer language

Release-candidate consistency and tool discovery

Removed the APIM-only hero bias, derived Logic App maturity copy from the shared tool registry, and added release-candidate regression guards for the default Analysis/Source experience.

• Homepage now exposes APIM, Logic Apps, BizTalk and Service Bus as compact analyzer shortcuts instead of privileging one analyzer
• Primary hero actions focus on the complete tool catalogue and Pattern Library for clearer first-time discovery
• Logic App page and in-tool maturity messaging derive from the shared catalogue status and no longer use stale early-access score language
• Regression checks protect the Logic App Analysis-first workspace and homepage analyzer registry from future drift

v1.0 hardening and accessibility

Hardened GateSift for larger and malformed inputs, improved keyboard and mobile behavior, added recoverable route errors, and made parser failures clearer without changing user input.

• Shared browser-safe input limits for APIM, Logic Apps, BizTalk, Service Bus and code-generation samples
• Depth guards for nested APIM policies, Logic App actions and ARM resource trees to avoid runaway browser recursion
• Keyboard focus trapping and Escape handling for policy and improvement dialogs, plus skip-to-content navigation
• Recoverable route error UI and clearer parser/import messages that explicitly preserve local input
• Mobile hardening for analyzer tabs, maps, dialogs and wide flat-file column previews

Unified reviews and exports

Standardized human-readable review exports across APIM, Logic Apps, BizTalk and Service Bus, with plain-language summaries, consistent classifications, versioned JSON and explicit limitations for new users.

• Logic App and Service Bus analyzers now export the same Markdown and schema-versioned JSON review structure
• BizTalk sanitized exports retain detailed evidence while adding the shared plain-language review model
• APIM HTML, Markdown, JSON and PDF reports now include GateSift version, reader guidance and explicit analysis limitations
• Problems, recommendations, opportunities and information use consistent language across exported reviews

Service Bus reliability and operations

Deepened Service Bus review with delivery and failure-path explanations, risk-qualified operational findings, topology investigation controls and broader ARM forwarding resolution. Logic App Workflow Helper is now marked Live.

• Delivery, Recovery, Routing and Configuration review scores with positive signals and context-aware review items
• Queue and subscription delivery paths explain filters, consumers, dead-letter behavior and forwarding without inventing runtime application behavior
• Map search, focus, findings-only mode and rule/DLQ visibility controls make larger topologies easier to investigate
• ARM resourceId forwarding resolution, transfer-hop validation and stronger dead-letter/durable-delivery Pattern Intelligence
• Logic App Workflow Helper promoted from Early access to Live after resilience, pattern and regression hardening

Product consistency and trust

Centralized live tool and release metadata, simplified the Logic App review flow, removed stale roadmap language and added a technical Privacy & Security page for local-first usage.

• Homepage, catalogues, sitemap and roadmap derive availability from the shared tool registry
• Current product version and homepage release count derive from the release catalogue instead of duplicated constants
• Logic App analysis is shown before raw workflow JSON, with Source available as an explicit workspace view
• Privacy & Security documentation explains browser storage, configuration handling, exports, analytics boundaries and external payment links

Service Bus topology early access

Added a local-first Azure Service Bus topology visualizer for ARM template JSON with queues, topics, subscriptions, filters, dead-letter paths, forwarding review and shared pattern intelligence.

• ARM template, single-resource and resource-array input with common parameter and concat name resolution
• Topology map for namespaces, queues, topics, subscriptions, filter rules and built-in dead-letter subqueues
• Review findings for unresolved forwarding, forwarding cycles, Basic-tier topic definitions and delivery/filter settings
• Pattern Intelligence for publish/subscribe, content-based routing and queue-based load leveling

Pattern Library deep dives

Deepened fifteen high-value integration patterns with decision guidance, explicit tradeoffs, operational risks, Azure implementation review notes and pattern-specific architecture questions.

• Fifteen curated deep dives across routing, messaging, transformation, orchestration and reliability
• Good-fit and caution guidance so patterns are not presented as universal best practices
• Operational risks with impact labels and concrete Azure implementation review notes
• Pattern-specific review questions replace generic architecture prompts on curated pages

Shared pattern intelligence

Connected APIM, Logic Apps and BizTalk analysis to one confidence-aware pattern signal model, with evidence, Pattern Library links and analyzer support shown back on pattern pages.

• Shared PatternSignal model with high, medium and low confidence across all three analyzers
• APIM, Logic App and BizTalk surfaces use one consistent detected/possible pattern experience
• Pattern detail pages show which GateSift analyzers can detect or signal each supported pattern
• APIM and BizTalk reports include pattern evidence instead of leaving pattern intelligence only in the UI

Improved policy proposal workflow

Made APIM improvements easier to discover and review by surfacing recommendations before optional context, exposing generated XML directly, and combining explicitly selected guided changes into one proposed policy.

• Recommendations are shown before the optional API context questionnaire
• Guided previews can be added to a proposal without changing the editor
• Multiple configured changes can be combined into one risk-scored policy preview and semantic diff
• Generated policy XML is visible directly in both individual and combined previews before anything is applied

APIM explanation and recommendation depth

Deepened APIM analysis with context-aware statement explanations, lightweight decision paths, explainable risk contribution and clearer separation between problems, recommendations and optional architecture opportunities.

• Statement details explain execution consequences, surrounding policy context and concrete review checks
• Problems, recommendations, opportunities and information are separated so optional guidance does not read like risk
• Choose branches expose lightweight execution paths, including terminating return-response branches
• Risk contributors and detected policy patterns link analysis back to the relevant integration guidance

BizTalk map focus and navigation

Made large BizTalk bindings easier to investigate with a searchable component explorer, relationship-neighborhood focus, navigation history and clearer node-limit guidance.

• Application tree with orchestrations, receive locations, send ports, findings and disabled-state indicators
• Direct, two-level and complete-application focus modes with Back and Forward navigation
• Finding, relationship and environment-comparison results can open the same focused map workflow
• Visibility toggles, map legend, viewport preservation and hidden-component counts

Flat-file to C# generation

Expanded the local C# generator with delimited flat-file parsing, conservative multi-row inference and editable column mappings.

• CSV, TSV, semicolon, pipe and custom delimiters
• Automatic delimiter and header detection with quoted-value support
• Editable property names and C# type overrides
• Culture-aware numbers, dates, nullability and leading-zero protection

BizTalk environment comparison v2

Upgraded environment comparison from a raw component diff to a classified review of expected substitutions, configuration drift, missing components, secret-bearing settings and operational risk.

• Environment-aware component matching across common dev, test, UAT and prod naming
• Classified differences with severity, evidence and side-by-side sanitized values
• Search plus application, component and difference-area filters
• Comparison summary and Markdown export for enterprise review

PayPal support link

Replaced the previous contribution options with the public provider-hosted GateSift PayPal donation page.

• PayPal donation link enabled by default
• Previous contribution-provider UI and configuration removed
• Optional build-time PayPal URL override retained
• Payment credentials remain outside GateSift

Reliability pattern collection

Expanded the Pattern Library into curated collections and added ten cloud reliability patterns without changing any existing Enterprise Integration Pattern URL.

• Enterprise Messaging and Reliability & Delivery collections
• Ten new patterns for faults, distributed consistency, load protection and operational recovery
• Collection-aware search, categories, attribution and detail pages
• All existing 65 messaging pattern routes preserved

Search and sharing foundation

Added search-engine discovery files, canonical metadata, social previews and structured data across GateSift tools and the Integration Pattern Library.

• Generated sitemap covering current pages and all 65 pattern articles
• robots.txt and web app manifest for the production domain
• Unique canonical, Open Graph and social metadata across tools
• SoftwareApplication, CollectionPage and TechArticle structured data

Azure Deployment Builder early access

Added a local-first guided builder that generates original Bicep modules, environment parameter files, documentation and Azure DevOps or GitHub Actions deployment pipelines.

• Modern .NET 8 isolated Function workload on Flex Consumption
• Managed identity, secure storage, monitoring, optional Service Bus and Key Vault
• Dev/Test/Prod .bicepparam files and downloadable ZIP package
• Template-safety checks for unsafe placeholders and external pipeline dependencies

Logic App Workflow Helper early access

Added a local-first Logic App workflow reviewer with structural visualization, runAfter dependency context, configuration inventory and early reliability findings.

• Workflow definition, workflow.json, ARM resource and ARM template input
• Triggers, nested actions, conditions, scopes, loops and dependency structure
• Review score and findings for endpoints, retries, failure paths, secure data and naming
• Dedicated early-access feedback path for parser bugs and missing workflow types

Clearer tool discovery

Updated the Tools catalogue so the live XML / JSON to C# Class Generator appears alongside the analysis tools instead of being discoverable only through Resources.

• Dedicated developer utilities section on the Tools page
• XML / JSON to C# Class Generator shown as a live tool
• Clearer distinction between analyzers and focused build utilities

Support foundation

Added a dedicated support page with provider-hosted contribution links and clear payment-boundary messaging.

• Support route available from the global header and homepage
• Dedicated support page with transparent contribution status
• Payment credentials remain outside GateSift

XML and JSON to C# generator

Added GateSift's first live Build utility: a local-first generator that turns representative XML or JSON payloads into serializer-ready C# classes.

• Automatic XML and JSON format detection
• Intermediate schema model with nested object and collection inference
• System.Text.Json and XmlSerializer attributes
• Nullable references, file-scoped namespaces, copy and .cs download

GateSift platform foundation

Repositioned GateSift around Analyze, Learn and Build, added dedicated Tools and Resources pages, and published the roadmap for Logic Apps, Service Bus, deployment modules, generators and open engineering resources.

• New Tools, Patterns, Resources, Roadmap and About navigation
• Analyze, Learn and Build product pillars
• Coming-soon catalogue for Logic Apps, Service Bus, deployment modules and developer utilities
• Bicep-first open-resource direction with generated ARM artifacts

Pattern visual explanations and clearer attribution

Added original GateSift how-it-works diagrams to every pattern page and strengthened source, licence, adaptation and no-endorsement notices.

• Pattern-specific routing, fan-out, aggregation, transformation and request/reply diagrams
• Three-step mechanics explanation on every pattern
• Explicit CC BY 3.0 links and modification wording
• Clear separation between licensed pattern material and original GateSift content

Integration Pattern Library

Added a searchable library of all 65 Enterprise Integration Patterns with GateSift explanations, Azure implementation examples, analyzer relevance and dedicated pattern pages.

• Top-level Patterns navigation
• Search and category filters
• Static detail pages for every pattern
• Latest five releases on the homepage and a complete changelog

APIM authoring and richer BizTalk context

Added start-from-scratch APIM authoring, selectable policy blocks, unified export navigation and BizTalk descriptions in endpoint details and reports.

BizTalk configuration workbench

Added dedicated Map, Endpoints and grouped Findings views, clearer unbound exports, compact endpoint inspection and improved large-binding navigation.

Clearer BizTalk binding maps

Small bindings now open with every endpoint visible, while unbound exports explain which runtime relationships are unavailable.

BizTalk visualizer early access

Added scalable binding maps, adapter-aware details, environment comparison and expanded configuration review rules.

GateSift tools hub

Introduced the GateSift tools homepage, SIFT principles, roadmap, feedback and partnership paths.

Clearer policy comparison

Separated Compare from Improve and added intentional comparison setup, navigation and feedback improvements.

APIM Policy Analyzer MVP

Launched local-first policy parsing, execution flow, risk review, documentation, improvement guidance and exports.