[{"data":1,"prerenderedAt":8153},["ShallowReactive",2],{"navigation":3,"\u002Fdocs\u002Freference\u002Fks-compatibility-matrix":314,"\u002Fdocs\u002Freference\u002Fks-compatibility-matrix-surround":8148},[4,38,86,149,176,219,257,273],{"title":5,"path":6,"stem":7,"children":8,"icon":37},"Getting Started","\u002Fdocs\u002Fgetting-started","1.docs\u002F1.getting-started\u002F1.index",[9,12,17,22,27,32],{"title":10,"path":6,"stem":7,"icon":11},"Getting started","i-lucide-flag",{"title":13,"path":14,"stem":15,"icon":16},"Modules overview","\u002Fdocs\u002Fgetting-started\u002Fmodules-overview","1.docs\u002F1.getting-started\u002F2.modules-overview","i-lucide-boxes",{"title":18,"path":19,"stem":20,"icon":21},"Installation","\u002Fdocs\u002Fgetting-started\u002Finstallation","1.docs\u002F1.getting-started\u002F3.installation","i-lucide-download",{"title":23,"path":24,"stem":25,"icon":26},"License configuration","\u002Fdocs\u002Fgetting-started\u002Flicense-configuration","1.docs\u002F1.getting-started\u002F4.license-configuration","i-lucide-key-round",{"title":28,"path":29,"stem":30,"icon":31},"Your first app","\u002Fdocs\u002Fgetting-started\u002Ffirst-app","1.docs\u002F1.getting-started\u002F5.first-app","i-lucide-square-play",{"title":33,"path":34,"stem":35,"icon":36},"Project setup","\u002Fdocs\u002Fgetting-started\u002Fproject-setup","1.docs\u002F1.getting-started\u002F6.project-setup","i-lucide-package",false,{"title":39,"path":40,"stem":41,"children":42,"icon":45},"Core Concepts","\u002Fdocs\u002Fconcepts","1.docs\u002F2.concepts\u002F1.index",[43,46,51,56,61,66,71,76,81],{"title":44,"path":40,"stem":41,"icon":45},"Core concepts","i-lucide-book-open",{"title":47,"path":48,"stem":49,"icon":50},"Architecture","\u002Fdocs\u002Fconcepts\u002Farchitecture","1.docs\u002F2.concepts\u002F2.architecture","i-lucide-layers",{"title":52,"path":53,"stem":54,"icon":55},"Exactly-once semantics","\u002Fdocs\u002Fconcepts\u002Fexactly-once","1.docs\u002F2.concepts\u002F3.exactly-once","i-lucide-shield-check",{"title":57,"path":58,"stem":59,"icon":60},"Lanes and parallelism","\u002Fdocs\u002Fconcepts\u002Flanes-and-parallelism","1.docs\u002F2.concepts\u002F4.lanes-and-parallelism","i-lucide-split",{"title":62,"path":63,"stem":64,"icon":65},"State and thread-safety","\u002Fdocs\u002Fconcepts\u002Fstate-and-thread-safety","1.docs\u002F2.concepts\u002F5.state-and-thread-safety","i-lucide-lock",{"title":67,"path":68,"stem":69,"icon":70},"Event time and watermarks","\u002Fdocs\u002Fconcepts\u002Fevent-time-and-watermarks","1.docs\u002F2.concepts\u002F6.event-time-and-watermarks","i-lucide-clock",{"title":72,"path":73,"stem":74,"icon":75},"The configuration model","\u002Fdocs\u002Fconcepts\u002Fconfiguration-model","1.docs\u002F2.concepts\u002F7.configuration-model","i-lucide-sliders-horizontal",{"title":77,"path":78,"stem":79,"icon":80},"The error-handling model","\u002Fdocs\u002Fconcepts\u002Ferror-handling-model","1.docs\u002F2.concepts\u002F8.error-handling-model","i-lucide-triangle-alert",{"title":82,"path":83,"stem":84,"icon":85},"How StoatFlow differs from Kafka Streams","\u002Fdocs\u002Fconcepts\u002Fhow-stoatflow-differs-from-ks","1.docs\u002F2.concepts\u002F9.how-stoatflow-differs-from-ks","i-lucide-arrow-left-right",{"title":87,"path":88,"stem":89,"children":90,"icon":93},"Building Topologies","\u002Fdocs\u002Fbuilding","1.docs\u002F3.building\u002F1.index",[91,94,99,104,109,114,119,124,129,134,139,144],{"title":92,"path":88,"stem":89,"icon":93},"Building topologies","i-lucide-blocks",{"title":95,"path":96,"stem":97,"icon":98},"Error handling and DLQ","\u002Fdocs\u002Fbuilding\u002Ferror-handling-dlq","1.docs\u002F3.building\u002F10.error-handling-dlq","i-lucide-circle-x",{"title":100,"path":101,"stem":102,"icon":103},"State stores","\u002Fdocs\u002Fbuilding\u002Fstate-stores","1.docs\u002F3.building\u002F11.state-stores","i-lucide-database",{"title":105,"path":106,"stem":107,"icon":108},"Testing topologies","\u002Fdocs\u002Fbuilding\u002Ftesting","1.docs\u002F3.building\u002F12.testing","i-lucide-flask-conical",{"title":110,"path":111,"stem":112,"icon":113},"Sources and sinks","\u002Fdocs\u002Fbuilding\u002Fstreams-builder","1.docs\u002F3.building\u002F2.streams-builder","i-lucide-import",{"title":115,"path":116,"stem":117,"icon":118},"KStream and KTable operations","\u002Fdocs\u002Fbuilding\u002Fkstream-ktable","1.docs\u002F3.building\u002F3.kstream-ktable","i-lucide-waypoints",{"title":120,"path":121,"stem":122,"icon":123},"Aggregations","\u002Fdocs\u002Fbuilding\u002Faggregations","1.docs\u002F3.building\u002F4.aggregations","i-lucide-sigma",{"title":125,"path":126,"stem":127,"icon":128},"Windowing","\u002Fdocs\u002Fbuilding\u002Fwindowing","1.docs\u002F3.building\u002F5.windowing","i-lucide-calendar-clock",{"title":130,"path":131,"stem":132,"icon":133},"Joins","\u002Fdocs\u002Fbuilding\u002Fjoins","1.docs\u002F3.building\u002F6.joins","i-lucide-git-merge",{"title":135,"path":136,"stem":137,"icon":138},"The Processor API","\u002Fdocs\u002Fbuilding\u002Fprocessor-api","1.docs\u002F3.building\u002F7.processor-api","i-lucide-cpu",{"title":140,"path":141,"stem":142,"icon":143},"Scheduled sources","\u002Fdocs\u002Fbuilding\u002Fscheduled-sources","1.docs\u002F3.building\u002F8.scheduled-sources","i-lucide-timer",{"title":145,"path":146,"stem":147,"icon":148},"Serdes and Avro","\u002Fdocs\u002Fbuilding\u002Fserdes","1.docs\u002F3.building\u002F9.serdes","i-lucide-binary",{"title":150,"path":151,"stem":152,"children":153,"icon":75},"Configuration","\u002Fdocs\u002Fconfiguration","1.docs\u002F4.configuration\u002F1.index",[154,156,161,166,171],{"title":155,"path":151,"stem":152,"icon":75},"How configuration works",{"title":157,"path":158,"stem":159,"icon":160},"Engine configuration (:core)","\u002Fdocs\u002Fconfiguration\u002Fcore-config","1.docs\u002F4.configuration\u002F2.core-config","i-lucide-settings-2",{"title":162,"path":163,"stem":164,"icon":165},"Runtime configuration (:runtime)","\u002Fdocs\u002Fconfiguration\u002Fruntime-config","1.docs\u002F4.configuration\u002F3.runtime-config","i-lucide-server-cog",{"title":167,"path":168,"stem":169,"icon":170},"Defaults, adaptivity, and presets","\u002Fdocs\u002Fconfiguration\u002Fdefaults-and-presets","1.docs\u002F4.configuration\u002F4.defaults-and-presets","i-lucide-gauge",{"title":172,"path":173,"stem":174,"icon":175},"Kafka client configuration","\u002Fdocs\u002Fconfiguration\u002Fkafka-client-config","1.docs\u002F4.configuration\u002F5.kafka-client-config","i-lucide-plug",{"title":177,"path":178,"stem":179,"children":180,"icon":183},"Running in Production","\u002Fdocs\u002Fruntime","1.docs\u002F5.runtime\u002F1.index",[181,184,189,194,199,204,209,214],{"title":182,"path":178,"stem":179,"icon":183},"The runtime","i-lucide-server",{"title":185,"path":186,"stem":187,"icon":188},"The REST API","\u002Fdocs\u002Fruntime\u002Frest-api","1.docs\u002F5.runtime\u002F2.rest-api","i-lucide-globe",{"title":190,"path":191,"stem":192,"icon":193},"Health checks","\u002Fdocs\u002Fruntime\u002Fhealth-checks","1.docs\u002F5.runtime\u002F3.health-checks","i-lucide-heart-pulse",{"title":195,"path":196,"stem":197,"icon":198},"Metrics","\u002Fdocs\u002Fruntime\u002Fmetrics","1.docs\u002F5.runtime\u002F4.metrics","i-lucide-activity",{"title":200,"path":201,"stem":202,"icon":203},"Pause and resume","\u002Fdocs\u002Fruntime\u002Fpause-unpause","1.docs\u002F5.runtime\u002F5.pause-unpause","i-lucide-pause",{"title":205,"path":206,"stem":207,"icon":208},"Plugins and lifecycle hooks","\u002Fdocs\u002Fruntime\u002Fplugins","1.docs\u002F5.runtime\u002F6.plugins","i-lucide-puzzle",{"title":210,"path":211,"stem":212,"icon":213},"Docker images","\u002Fdocs\u002Fruntime\u002Fdocker","1.docs\u002F5.runtime\u002F7.docker","i-lucide-container",{"title":215,"path":216,"stem":217,"icon":218},"GraalVM native image","\u002Fdocs\u002Fruntime\u002Fnative-image","1.docs\u002F5.runtime\u002F8.native-image","i-lucide-zap",{"title":220,"path":221,"stem":222,"children":223,"icon":226},"Deploying & Operating","\u002Fdocs\u002Foperating","1.docs\u002F6.operating\u002F1.index",[224,227,232,237,242,247,252],{"title":225,"path":221,"stem":222,"icon":226},"Deploying and operating","i-lucide-life-buoy",{"title":228,"path":229,"stem":230,"icon":231},"Running on Kubernetes","\u002Fdocs\u002Foperating\u002Fkubernetes","1.docs\u002F6.operating\u002F2.kubernetes","i-lucide-ship",{"title":233,"path":234,"stem":235,"icon":236},"High availability","\u002Fdocs\u002Foperating\u002Fhigh-availability","1.docs\u002F6.operating\u002F3.high-availability","i-lucide-copy",{"title":238,"path":239,"stem":240,"icon":241},"Liveness and readiness probes","\u002Fdocs\u002Foperating\u002Fprobes","1.docs\u002F6.operating\u002F4.probes","i-lucide-stethoscope",{"title":243,"path":244,"stem":245,"icon":246},"Observability","\u002Fdocs\u002Foperating\u002Fobservability","1.docs\u002F6.operating\u002F5.observability","i-lucide-telescope",{"title":248,"path":249,"stem":250,"icon":251},"Tuning under load","\u002Fdocs\u002Foperating\u002Ftuning","1.docs\u002F6.operating\u002F6.tuning","i-lucide-sliders",{"title":253,"path":254,"stem":255,"icon":256},"Production checklist","\u002Fdocs\u002Foperating\u002Fproduction-checklist","1.docs\u002F6.operating\u002F7.production-checklist","i-lucide-clipboard-check",{"title":258,"path":259,"stem":260,"children":261,"icon":85},"Migrating from Kafka Streams","\u002Fdocs\u002Fmigration","1.docs\u002F7.migration\u002F1.index",[262,263,268],{"title":258,"path":259,"stem":260,"icon":85},{"title":264,"path":265,"stem":266,"icon":267},"Migration without carrying state","\u002Fdocs\u002Fmigration\u002Fwithout-data-migration","1.docs\u002F7.migration\u002F2.without-data-migration","i-lucide-sparkles",{"title":269,"path":270,"stem":271,"icon":272},"Migration carrying state","\u002Fdocs\u002Fmigration\u002Fwith-data-migration","1.docs\u002F7.migration\u002F3.with-data-migration","i-lucide-database-backup",{"title":274,"path":275,"stem":276,"children":277,"icon":279},"Reference","\u002Fdocs\u002Freference","1.docs\u002F8.reference\u002F1.index",[278,280,285,290,295,300,305,309],{"title":274,"path":275,"stem":276,"icon":279},"i-lucide-list",{"title":281,"path":282,"stem":283,"icon":284},"Configuration reference","\u002Fdocs\u002Freference\u002Fconfiguration-reference","1.docs\u002F8.reference\u002F2.configuration-reference","i-lucide-table",{"title":286,"path":287,"stem":288,"icon":289},"REST API reference","\u002Fdocs\u002Freference\u002Frest-api-reference","1.docs\u002F8.reference\u002F3.rest-api-reference","i-lucide-network",{"title":291,"path":292,"stem":293,"icon":294},"Gradle plugin reference","\u002Fdocs\u002Freference\u002Fgradle-plugin-reference","1.docs\u002F8.reference\u002F4.gradle-plugin-reference","i-lucide-box",{"title":296,"path":297,"stem":298,"icon":299},"Maven reference","\u002Fdocs\u002Freference\u002Fmaven-reference","1.docs\u002F8.reference\u002F5.maven-reference","i-simple-icons-apachemaven",{"title":301,"path":302,"stem":303,"icon":304},"Kafka Streams compatibility matrix","\u002Fdocs\u002Freference\u002Fks-compatibility-matrix","1.docs\u002F8.reference\u002F6.ks-compatibility-matrix","i-lucide-table-2",{"title":306,"path":307,"stem":308,"icon":170},"Metrics reference","\u002Fdocs\u002Freference\u002Fmetrics-reference","1.docs\u002F8.reference\u002F7.metrics-reference",{"title":310,"path":311,"stem":312,"icon":313},"Glossary","\u002Fdocs\u002Freference\u002Fglossary","1.docs\u002F8.reference\u002F8.glossary","i-lucide-book-a",{"id":315,"title":301,"body":316,"description":8141,"extension":8142,"meta":8143,"navigation":8144,"pageType":8145,"path":302,"seo":8146,"stem":303,"__hash__":8147},"docs\u002F1.docs\u002F8.reference\u002F6.ks-compatibility-matrix.md",{"type":317,"value":318,"toc":8050},"minimark",[319,332,343,355,360,436,440,738,742,752,886,890,898,984,988,1144,1148,1211,1215,1281,1285,1337,1341,1569,1578,1582,1642,1646,1738,1742,1745,1757,1806,1810,1859,1863,1867,1927,1931,1961,1965,2001,2005,2254,2258,2265,2364,2372,2376,2394,2474,2478,2495,2553,2557,2590,2595,2599,2603,2743,2747,2954,2958,3093,3106,3110,3125,3128,3219,3223,3297,3302,3306,3309,3521,3525,3529,3663,3667,3682,3759,3771,3804,3807,3907,3910,3965,3968,4114,4117,4166,4169,4178,4219,4223,4290,4293,4308,4422,4426,4495,4499,4593,4626,4629,4775,4778,4910,4914,4948,4962,4966,5016,5035,5047,5051,5163,5167,5258,5274,5277,5281,5345,5349,5374,5378,5513,5517,5599,5603,5610,5761,5765,5799,5803,5949,5953,5986,5990,6021,6274,6278,6281,6315,6319,6326,6402,6406,6410,6538,6542,6586,6590,6664,6673,6677,6684,6751,6755,6857,6861,7094,7097,7419,7423,7431,7534,7538,7547,7550,7661,7665,7699,7703,7784,7788,7843,7851,7855,7858,8006,8012,8016],[320,321,322,323,327,328,331],"p",{},"The engineering view of Kafka Streams DSL parity in StoatFlow: every operator, helper class, and store method, with its current status and notes where behaviour differs. Targets ",[324,325,326],"strong",{},"Kafka Streams 4.3.x",": StoatFlow reimplements the Kafka Streams DSL surface under its own package, so most KS applications port by swapping the dependency and rewriting imports — see ",[329,330,258],"a",{"href":259},".",[320,333,334,335,339,340,331],{},"For the high-level, feature-by-feature comparison against Kafka Streams and Flink, see ",[329,336,338],{"href":337},"\u002Fproduct\u002Fcomparison-matrix","Comparison matrix",". For how-to guidance on the operators below, see ",[329,341,342],{"href":88},"Building",[344,345,348],"callout",{"color":346,"icon":347},"info","i-lucide-git-compare",[320,349,350,351,354],{},"This matrix is transcribed from the in-repository compatibility reference and curated for the public docs. Status reflects the current alpha (",[352,353],"stoatflow-version",{},"); the surface is still moving. A small number of rows differ in signature from Kafka Streams (marked ⚠️) or are intentionally absent (marked 🛑) — read the notes.",[356,357,359],"h2",{"id":358},"legend","Legend",[361,362,363,376],"table",{},[364,365,366],"thead",{},[367,368,369,373],"tr",{},[370,371,372],"th",{},"Symbol",[370,374,375],{},"Meaning",[377,378,379,388,396,404,412,420,428],"tbody",{},[367,380,381,385],{},[382,383,384],"td",{},"✅",[382,386,387],{},"Implemented",[367,389,390,393],{},[382,391,392],{},"⚠️",[382,394,395],{},"Partial — stub, limited, or differing signature",[367,397,398,401],{},[382,399,400],{},"❌",[382,402,403],{},"Not implemented yet",[367,405,406,409],{},[382,407,408],{},"🛑",[382,410,411],{},"Incompatible, or won't be implemented (not needed in the single-instance model)",[367,413,414,417],{},[382,415,416],{},"↘️",[382,418,419],{},"Deprecated in Kafka Streams",[367,421,422,425],{},[382,423,424],{},"🚀",[382,426,427],{},"StoatFlow extension — not in Kafka Streams",[367,429,430,433],{},[382,431,432],{},"🆕",[382,434,435],{},"StoatFlow extension on an otherwise KS-compatible interface",[356,437,439],{"id":438},"streamsbuilder","StreamsBuilder",[361,441,442,455],{},[364,443,444],{},[367,445,446,449,452],{},[370,447,448],{},"Method",[370,450,451],{},"Status",[370,453,454],{},"Notes",[377,456,457,467,490,500,510,520,529,539,549,559,569,579,608,618,628,638,648,658,668,678,688,698,708,718,728],{},[367,458,459,462,464],{},[382,460,461],{},"StreamsBuilder()",[382,463,384],{},[382,465,466],{},"No-arg",[367,468,469,472,474],{},[382,470,471],{},"StreamsBuilder(TopologyConfig)",[382,473,384],{},[382,475,476,477,481,482,485,486,489],{},"KSC-77 — seeds build-time defaults (serdes, DSL store format) from a ",[478,479,480],"code",{},"TopologyConfig"," projection of ",[478,483,484],{},"StreamsConfig",". Named-topology \u002F per-topology overrides N\u002FA (single-instance); a non-default ",[478,487,488],{},"processor.wrapper.class"," throws",[367,491,492,495,497],{},[382,493,494],{},"stream(topic, consumed?)",[382,496,384],{},[382,498,499],{},"Single topic subscription; single-arg form Java-callable",[367,501,502,505,507],{},[382,503,504],{},"stream(Collection\u003CString>)",[382,506,384],{},[382,508,509],{},"Multiple topics subscription",[367,511,512,515,517],{},[382,513,514],{},"stream(Pattern)",[382,516,384],{},[382,518,519],{},"Pattern-based subscription",[367,521,522,525,527],{},[382,523,524],{},"table(topic, consumed?)",[382,526,384],{},[382,528],{},[367,530,531,534,536],{},[382,532,533],{},"table(topic, materialized)",[382,535,384],{},[382,537,538],{},"Explicit skip-Consumed overload (KS parity)",[367,540,541,544,546],{},[382,542,543],{},"table(topic, consumed?, materialized)",[382,545,384],{},[382,547,548],{},"With state store",[367,550,551,554,556],{},[382,552,553],{},"globalTable(topic, consumed?)",[382,555,384],{},[382,557,558],{},"Wraps KTable",[367,560,561,564,566],{},[382,562,563],{},"globalTable(topic, materialized)",[382,565,384],{},[382,567,568],{},"Without Consumed parameter",[367,570,571,574,576],{},[382,572,573],{},"build()",[382,575,384],{},[382,577,578],{},"Returns Topology",[367,580,581,584,586],{},[382,582,583],{},"build(Properties)",[382,585,392],{},[382,587,588,589,592,593,596,597,599,600,603,604,607],{},"The ",[478,590,591],{},"Properties"," are ",[324,594,595],{},"ignored"," — logs a warning and delegates to ",[478,598,573],{},". Config carries over via ",[478,601,602],{},"StreamsConfig.fromProperties(...)"," \u002F the KS-shaped ",[478,605,606],{},"StreamsConfig(Properties)"," ctor instead (ADR-124)",[367,609,610,613,615],{},[382,611,612],{},"addStateStore(storeBuilder)",[382,614,384],{},[382,616,617],{},"Register standalone store",[367,619,620,623,625],{},[382,621,622],{},"addStateStore(storeBuilder, keySerde, valueSerde)",[382,624,384],{},[382,626,627],{},"With changelog Serdes",[367,629,630,633,635],{},[382,631,632],{},"addStateStore(storeSupplier, keySerde, valueSerde)",[382,634,384],{},[382,636,637],{},"Convenience overload",[367,639,640,643,645],{},[382,641,642],{},"addGlobalStore(storeBuilder, topic, consumed, processor)",[382,644,384],{},[382,646,647],{},"Custom update processor",[367,649,650,653,655],{},[382,651,652],{},"addGlobalStore(storeBuilder, topic, consumed)",[382,654,384],{},[382,656,657],{},"Default put\u002Fdelete semantics",[367,659,660,663,665],{},[382,661,662],{},"addReadOnlyStateStore(storeBuilder, topic, consumed, processor)",[382,664,384],{},[382,666,667],{},"KIP-813: custom processor",[367,669,670,673,675],{},[382,671,672],{},"addReadOnlyStateStore(storeBuilder, topic, consumed)",[382,674,384],{},[382,676,677],{},"KIP-813: default put\u002Fdelete semantics",[367,679,680,683,685],{},[382,681,682],{},"scheduled(interval, type, emitter)",[382,684,424],{},[382,686,687],{},"Interval-based periodic record source",[367,689,690,693,695],{},[382,691,692],{},"scheduled(interval, type, named, emitter)",[382,694,424],{},[382,696,697],{},"With explicit naming",[367,699,700,703,705],{},[382,701,702],{},"scheduled(interval, type, keySerde, emitter)",[382,704,424],{},[382,706,707],{},"With explicit key serde for lane assignment",[367,709,710,713,715],{},[382,711,712],{},"scheduled(cron, emitter)",[382,714,424],{},[382,716,717],{},"Cron-based calendar scheduling",[367,719,720,723,725],{},[382,721,722],{},"scheduled(cron, named, emitter)",[382,724,424],{},[382,726,727],{},"Cron with explicit naming",[367,729,730,733,735],{},[382,731,732],{},"scheduled(cron, keySerde, emitter)",[382,734,424],{},[382,736,737],{},"Cron with explicit key serde for lane assignment",[356,739,741],{"id":740},"topology-processor-api","Topology (Processor API)",[320,743,744,745,747,748,751],{},"Both the high-level DSL (",[478,746,439],{},") and the low-level ",[478,749,750],{},"Topology"," builder are supported.",[361,753,754,764],{},[364,755,756],{},[367,757,758,760,762],{},[370,759,448],{},[370,761,451],{},[370,763,454],{},[377,765,766,804,816,826,836,846,856,866,876],{},[367,767,768,771,773],{},[382,769,770],{},"describe()",[382,772,384],{},[382,774,775,776,779,780,783,784,783,787,783,790,783,793,796,797,800,801],{},"Returns the Kafka Streams ",[478,777,778],{},"TopologyDescription"," (nested ",[478,781,782],{},"Source","\u002F",[478,785,786],{},"Processor",[478,788,789],{},"Sink",[478,791,792],{},"Subtopology",[478,794,795],{},"GlobalStore"," node graph). ",[324,798,799],{},"Breaking vs older StoatFlow:"," previously returned the native model — that view moved to ",[478,802,803],{},"describeStoatFlow()",[367,805,806,808,810],{},[382,807,803],{},[382,809,424],{},[382,811,812,813,815],{},"StoatFlow-native topology model (the former ",[478,814,770],{}," shape)",[367,817,818,821,823],{},[382,819,820],{},"addSource(name, topics...)",[382,822,384],{},[382,824,825],{},"14 overloads: offset reset, timestamp extractor, deserializers, pattern",[367,827,828,831,833],{},[382,829,830],{},"addProcessor(name, supplier, parents...)",[382,832,384],{},[382,834,835],{},"User-defined processor with ProcessorSupplier",[367,837,838,841,843],{},[382,839,840],{},"addSink(name, topic, parents...)",[382,842,384],{},[382,844,845],{},"8 overloads: serializers, partitioner, TopicNameExtractor",[367,847,848,851,853],{},[382,849,850],{},"addStateStore(builder, processors...)",[382,852,384],{},[382,854,855],{},"Register store and optionally connect to processors",[367,857,858,861,863],{},[382,859,860],{},"addGlobalStore(...)",[382,862,384],{},[382,864,865],{},"2 variants: with\u002Fwithout TimestampExtractor",[367,867,868,871,873],{},[382,869,870],{},"addReadOnlyStateStore(...)",[382,872,384],{},[382,874,875],{},"2 variants (KIP-813): source topic is changelog",[367,877,878,881,883],{},[382,879,880],{},"connectProcessorAndStateStores(...)",[382,882,384],{},[382,884,885],{},"Connect existing store to processor",[887,888,778],"h3",{"id":889},"topologydescription",[320,891,892,894,895,897],{},[478,893,770],{}," returns the Kafka Streams ",[478,896,778],{}," — a graph of nested node interfaces.",[361,899,900,911],{},[364,901,902],{},[367,903,904,907,909],{},[370,905,906],{},"Member",[370,908,451],{},[370,910,454],{},[377,912,913,928,937,946,955,965,975],{},[367,914,915,918,920],{},[382,916,917],{},"subtopologies() \u002F globalStores()",[382,919,384],{},[382,921,922,923,925,926],{},"Sets of ",[478,924,792],{}," \u002F ",[478,927,795],{},[367,929,930,933,935],{},[382,931,932],{},"Subtopology.id() \u002F nodes()",[382,934,384],{},[382,936],{},[367,938,939,942,944],{},[382,940,941],{},"Node.name() \u002F predecessors() \u002F successors()",[382,943,384],{},[382,945],{},[367,947,948,951,953],{},[382,949,950],{},"Source.topicSet() \u002F topicPattern()",[382,952,384],{},[382,954],{},[367,956,957,960,962],{},[382,958,959],{},"Processor.stores()",[382,961,384],{},[382,963,964],{},"Connected store names",[367,966,967,970,972],{},[382,968,969],{},"Sink.topic() \u002F topicNameExtractor()",[382,971,384],{},[382,973,974],{},"Static or dynamic routing",[367,976,977,980,982],{},[382,978,979],{},"GlobalStore.id() \u002F source() \u002F processor()",[382,981,384],{},[382,983],{},[356,985,987],{"id":986},"kstream-stateless-transformations","KStream — stateless transformations",[361,989,990,1000],{},[364,991,992],{},[367,993,994,996,998],{},[370,995,448],{},[370,997,451],{},[370,999,454],{},[377,1001,1002,1011,1020,1030,1039,1049,1058,1067,1076,1085,1095,1104,1114,1124,1134],{},[367,1003,1004,1007,1009],{},[382,1005,1006],{},"filter(predicate)",[382,1008,384],{},[382,1010],{},[367,1012,1013,1016,1018],{},[382,1014,1015],{},"filterNot(predicate)",[382,1017,384],{},[382,1019],{},[367,1021,1022,1025,1027],{},[382,1023,1024],{},"map(mapper)",[382,1026,384],{},[382,1028,1029],{},"Key-changing → sub-topology boundary",[367,1031,1032,1035,1037],{},[382,1033,1034],{},"mapValues(ValueMapper)",[382,1036,384],{},[382,1038],{},[367,1040,1041,1044,1046],{},[382,1042,1043],{},"mapValues(ValueMapperWithKey)",[382,1045,384],{},[382,1047,1048],{},"Key-aware value mapper variant",[367,1050,1051,1054,1056],{},[382,1052,1053],{},"flatMap(mapper)",[382,1055,384],{},[382,1057,1029],{},[367,1059,1060,1063,1065],{},[382,1061,1062],{},"flatMapValues(ValueMapper)",[382,1064,384],{},[382,1066],{},[367,1068,1069,1072,1074],{},[382,1070,1071],{},"flatMapValues(ValueMapperWithKey)",[382,1073,384],{},[382,1075,1048],{},[367,1077,1078,1081,1083],{},[382,1079,1080],{},"selectKey(keySelector)",[382,1082,384],{},[382,1084,1029],{},[367,1086,1087,1090,1092],{},[382,1088,1089],{},"peek(action)",[382,1091,384],{},[382,1093,1094],{},"Java BiConsumer overload",[367,1096,1097,1100,1102],{},[382,1098,1099],{},"merge(other)",[382,1101,384],{},[382,1103],{},[367,1105,1106,1109,1111],{},[382,1107,1108],{},"split()",[382,1110,384],{},[382,1112,1113],{},"Returns BranchedKStream",[367,1115,1116,1119,1121],{},[382,1117,1118],{},"repartition()",[382,1120,384],{},[382,1122,1123],{},"In-memory only",[367,1125,1126,1129,1131],{},[382,1127,1128],{},"repartition(Repartitioned)",[382,1130,384],{},[382,1132,1133],{},"Custom partitioner, naming",[367,1135,1136,1139,1141],{},[382,1137,1138],{},"print()",[382,1140,384],{},[382,1142,1143],{},"Configurable via Printed",[356,1145,1147],{"id":1146},"kstream-terminal-operations","KStream — terminal operations",[361,1149,1150,1160],{},[364,1151,1152],{},[367,1153,1154,1156,1158],{},[370,1155,448],{},[370,1157,451],{},[370,1159,454],{},[377,1161,1162,1171,1181,1191,1201],{},[367,1163,1164,1167,1169],{},[382,1165,1166],{},"forEach(action)",[382,1168,384],{},[382,1170,1094],{},[367,1172,1173,1176,1178],{},[382,1174,1175],{},"to(topic, produced?)",[382,1177,384],{},[382,1179,1180],{},"Static topic routing",[367,1182,1183,1186,1188],{},[382,1184,1185],{},"to(TopicNameExtractor, produced?)",[382,1187,384],{},[382,1189,1190],{},"Dynamic topic routing",[367,1192,1193,1196,1198],{},[382,1194,1195],{},"toTable()",[382,1197,384],{},[382,1199,1200],{},"Auto-generates store name",[367,1202,1203,1206,1208],{},[382,1204,1205],{},"toTable(named?, materialized?)",[382,1207,384],{},[382,1209,1210],{},"With naming and materialization",[356,1212,1214],{"id":1213},"kstream-processor-api","KStream — Processor API",[361,1216,1217,1227],{},[364,1218,1219],{},[367,1220,1221,1223,1225],{},[370,1222,448],{},[370,1224,451],{},[370,1226,454],{},[377,1228,1229,1247,1261,1271],{},[367,1230,1231,1234,1236],{},[382,1232,1233],{},"process(processorSupplier, named?, storeNames...)",[382,1235,384],{},[382,1237,1238,1239,1242,1243,1246],{},"Key-changing; ",[478,1240,1241],{},"ProcessorSupplier",". Connects the named stores (and any declared via ",[478,1244,1245],{},"supplier.stores()",")",[367,1248,1249,1252,1254],{},[382,1250,1251],{},"processValues(processorSupplier, named?, storeNames...)",[382,1253,384],{},[382,1255,1256,1257,1260],{},"Non-key-changing; ",[478,1258,1259],{},"FixedKeyProcessorSupplier"," + named\u002Fdeclared stores",[367,1262,1263,1266,1268],{},[382,1264,1265],{},"transform()",[382,1267,408],{},[382,1269,1270],{},"Removed from KStream in KS 4.x; use process()",[367,1272,1273,1276,1278],{},[382,1274,1275],{},"transformValues()",[382,1277,408],{},[382,1279,1280],{},"Removed from KStream in KS 4.x; use processValues()",[356,1282,1284],{"id":1283},"kstream-grouping","KStream — grouping",[361,1286,1287,1297],{},[364,1288,1289],{},[367,1290,1291,1293,1295],{},[370,1292,448],{},[370,1294,451],{},[370,1296,454],{},[377,1298,1299,1309,1319,1328],{},[367,1300,1301,1304,1306],{},[382,1302,1303],{},"groupByKey()",[382,1305,384],{},[382,1307,1308],{},"Returns KGroupedStream",[367,1310,1311,1314,1316],{},[382,1312,1313],{},"groupByKey(Grouped)",[382,1315,384],{},[382,1317,1318],{},"With Serdes configuration",[367,1320,1321,1324,1326],{},[382,1322,1323],{},"groupBy(keySelector)",[382,1325,384],{},[382,1327,1029],{},[367,1329,1330,1333,1335],{},[382,1331,1332],{},"groupBy(keySelector, Grouped)",[382,1334,384],{},[382,1336,1318],{},[356,1338,1340],{"id":1339},"kstream-joins","KStream — joins",[361,1342,1343,1353],{},[364,1344,1345],{},[367,1346,1347,1349,1351],{},[370,1348,448],{},[370,1350,451],{},[370,1352,454],{},[377,1354,1355,1365,1375,1385,1395,1405,1414,1423,1432,1442,1451,1460,1469,1479,1488,1498,1507,1517,1526,1539,1549,1558],{},[367,1356,1357,1360,1362],{},[382,1358,1359],{},"join(KStream, ValueJoiner, windows)",[382,1361,384],{},[382,1363,1364],{},"Stream-stream windowed join",[367,1366,1367,1370,1372],{},[382,1368,1369],{},"join(KStream, ValueJoiner, windows, streamJoined)",[382,1371,384],{},[382,1373,1374],{},"With StreamJoined config",[367,1376,1377,1380,1382],{},[382,1378,1379],{},"join(KStream, ValueJoinerWithKey, windows)",[382,1381,384],{},[382,1383,1384],{},"Key-aware joiner variant",[367,1386,1387,1390,1392],{},[382,1388,1389],{},"join(KStream, ValueJoinerWithKey, windows, streamJoined)",[382,1391,384],{},[382,1393,1394],{},"Key-aware joiner with config",[367,1396,1397,1400,1402],{},[382,1398,1399],{},"leftJoin(KStream, ValueJoiner, windows)",[382,1401,384],{},[382,1403,1404],{},"Stream-stream left join",[367,1406,1407,1410,1412],{},[382,1408,1409],{},"leftJoin(KStream, ValueJoiner, windows, streamJoined)",[382,1411,384],{},[382,1413,1374],{},[367,1415,1416,1419,1421],{},[382,1417,1418],{},"leftJoin(KStream, ValueJoinerWithKey, windows)",[382,1420,384],{},[382,1422,1384],{},[367,1424,1425,1428,1430],{},[382,1426,1427],{},"leftJoin(KStream, ValueJoinerWithKey, windows, streamJoined)",[382,1429,384],{},[382,1431,1394],{},[367,1433,1434,1437,1439],{},[382,1435,1436],{},"outerJoin(KStream, ValueJoiner, windows)",[382,1438,384],{},[382,1440,1441],{},"Stream-stream outer join",[367,1443,1444,1447,1449],{},[382,1445,1446],{},"outerJoin(KStream, ValueJoiner, windows, streamJoined)",[382,1448,384],{},[382,1450,1374],{},[367,1452,1453,1456,1458],{},[382,1454,1455],{},"outerJoin(KStream, ValueJoinerWithKey, windows)",[382,1457,384],{},[382,1459,1384],{},[367,1461,1462,1465,1467],{},[382,1463,1464],{},"outerJoin(KStream, ValueJoinerWithKey, windows, streamJoined)",[382,1466,384],{},[382,1468,1394],{},[367,1470,1471,1474,1476],{},[382,1472,1473],{},"join(KTable, ValueJoiner)",[382,1475,384],{},[382,1477,1478],{},"Stream-table inner join",[367,1480,1481,1484,1486],{},[382,1482,1483],{},"join(KTable, ValueJoinerWithKey)",[382,1485,384],{},[382,1487,1384],{},[367,1489,1490,1493,1495],{},[382,1491,1492],{},"leftJoin(KTable, ValueJoiner)",[382,1494,384],{},[382,1496,1497],{},"Stream-table left join",[367,1499,1500,1503,1505],{},[382,1501,1502],{},"leftJoin(KTable, ValueJoinerWithKey)",[382,1504,384],{},[382,1506,1384],{},[367,1508,1509,1512,1514],{},[382,1510,1511],{},"join(GlobalKTable, keySelector, ValueJoiner)",[382,1513,384],{},[382,1515,1516],{},"Stream-GlobalKTable inner join",[367,1518,1519,1522,1524],{},[382,1520,1521],{},"join(GlobalKTable, keySelector, ValueJoinerWithKey)",[382,1523,384],{},[382,1525,1384],{},[367,1527,1528,1531,1533],{},[382,1529,1530],{},"join(GlobalKTable, keySelector, ValueJoiner|ValueJoinerWithKey, Named)",[382,1532,384],{},[382,1534,1535,1538],{},[478,1536,1537],{},"Named"," overloads",[367,1540,1541,1544,1546],{},[382,1542,1543],{},"leftJoin(GlobalKTable, keySelector, ValueJoiner)",[382,1545,384],{},[382,1547,1548],{},"Stream-GlobalKTable left join",[367,1550,1551,1554,1556],{},[382,1552,1553],{},"leftJoin(GlobalKTable, keySelector, ValueJoinerWithKey)",[382,1555,384],{},[382,1557,1384],{},[367,1559,1560,1563,1565],{},[382,1561,1562],{},"leftJoin(GlobalKTable, keySelector, ValueJoiner|ValueJoinerWithKey, Named)",[382,1564,384],{},[382,1566,1567,1538],{},[478,1568,1537],{},[344,1570,1572],{"color":346,"icon":1571},"i-lucide-info",[320,1573,1574,1577],{},[324,1575,1576],{},"Temporal join semantics (KIP-914)."," When the backing table uses a versioned store (KIP-889), stream-table joins perform a temporal lookup against the stream record's timestamp — returning the table value that was valid at the stream event time, so results stay correct when records arrive out of order. Stream-table joins are otherwise point-in-time lookups; a table update does not re-trigger the join.",[356,1579,1581],{"id":1580},"kstream-branching-branchedkstream","KStream — branching (BranchedKStream)",[361,1583,1584,1594],{},[364,1585,1586],{},[367,1587,1588,1590,1592],{},[370,1589,448],{},[370,1591,451],{},[370,1593,454],{},[377,1595,1596,1605,1615,1624,1633],{},[367,1597,1598,1601,1603],{},[382,1599,1600],{},"branch(predicate)",[382,1602,384],{},[382,1604],{},[367,1606,1607,1610,1612],{},[382,1608,1609],{},"branch(predicate, branched)",[382,1611,384],{},[382,1613,1614],{},"With Branched config",[367,1616,1617,1620,1622],{},[382,1618,1619],{},"defaultBranch()",[382,1621,384],{},[382,1623],{},[367,1625,1626,1629,1631],{},[382,1627,1628],{},"defaultBranch(branched)",[382,1630,384],{},[382,1632,1614],{},[367,1634,1635,1638,1640],{},[382,1636,1637],{},"noDefaultBranch()",[382,1639,384],{},[382,1641],{},[356,1643,1645],{"id":1644},"kgroupedstream","KGroupedStream",[361,1647,1648,1658],{},[364,1649,1650],{},[367,1651,1652,1654,1656],{},[370,1653,448],{},[370,1655,451],{},[370,1657,454],{},[377,1659,1660,1670,1679,1688,1701,1718,1728],{},[367,1661,1662,1665,1667],{},[382,1663,1664],{},"count()",[382,1666,384],{},[382,1668,1669],{},"With Materialized overloads",[367,1671,1672,1675,1677],{},[382,1673,1674],{},"reduce(reducer)",[382,1676,384],{},[382,1678,1669],{},[367,1680,1681,1684,1686],{},[382,1682,1683],{},"aggregate(initializer, aggregator)",[382,1685,384],{},[382,1687,1669],{},[367,1689,1690,1693,1695],{},[382,1691,1692],{},"windowedBy(TimeWindows)",[382,1694,384],{},[382,1696,1697,1698],{},"Tumbling\u002Fhopping windows → ",[478,1699,1700],{},"TimeWindowedKStream",[367,1702,1703,1706,1708],{},[382,1704,1705],{},"windowedBy(SlidingWindows)",[382,1707,384],{},[382,1709,1710,1711,1713,1714,1717],{},"Sliding windows (KIP-450) → returns ",[478,1712,1700],{},", exactly like Kafka Streams (no separate ",[478,1715,1716],{},"SlidingWindowedKStream"," type)",[367,1719,1720,1723,1725],{},[382,1721,1722],{},"windowedBy(SessionWindows)",[382,1724,384],{},[382,1726,1727],{},"Session windows",[367,1729,1730,1733,1735],{},[382,1731,1732],{},"cogroup()",[382,1734,384],{},[382,1736,1737],{},"Returns CogroupedKStream",[356,1739,1741],{"id":1740},"windowed-grouped-streams","Windowed grouped streams",[887,1743,1700],{"id":1744},"timewindowedkstream",[320,1746,1747,1748,1750,1751,1753,1754,331],{},"Reached by both ",[478,1749,1692],{}," (tumbling\u002Fhopping) and ",[478,1752,1705],{}," (KIP-450\nsliding) — sliding windows flow through this type, exactly as in Kafka Streams. All overloads take a\nplain-key ",[478,1755,1756],{},"Materialized\u003CK, V, …>",[361,1758,1759,1769],{},[364,1760,1761],{},[367,1762,1763,1765,1767],{},[370,1764,448],{},[370,1766,451],{},[370,1768,454],{},[377,1770,1771,1780,1788,1796],{},[367,1772,1773,1775,1777],{},[382,1774,1664],{},[382,1776,384],{},[382,1778,1779],{},"With Materialized overloads (plain key)",[367,1781,1782,1784,1786],{},[382,1783,1674],{},[382,1785,384],{},[382,1787,1669],{},[367,1789,1790,1792,1794],{},[382,1791,1683],{},[382,1793,384],{},[382,1795,1669],{},[367,1797,1798,1801,1803],{},[382,1799,1800],{},"emitStrategy()",[382,1802,384],{},[382,1804,1805],{},"OnWindowUpdate (default), OnWindowClose",[887,1807,1809],{"id":1808},"sessionwindowedkstream","SessionWindowedKStream",[361,1811,1812,1822],{},[364,1813,1814],{},[367,1815,1816,1818,1820],{},[370,1817,448],{},[370,1819,451],{},[370,1821,454],{},[377,1823,1824,1833,1842,1851],{},[367,1825,1826,1828,1830],{},[382,1827,1664],{},[382,1829,384],{},[382,1831,1832],{},"With session merger",[367,1834,1835,1837,1839],{},[382,1836,1674],{},[382,1838,384],{},[382,1840,1841],{},"Reducer doubles as merger",[367,1843,1844,1847,1849],{},[382,1845,1846],{},"aggregate(initializer, aggregator, sessionMerger)",[382,1848,384],{},[382,1850,1832],{},[367,1852,1853,1855,1857],{},[382,1854,1800],{},[382,1856,384],{},[382,1858,1805],{},[356,1860,1862],{"id":1861},"cogrouped-streams","Cogrouped streams",[887,1864,1866],{"id":1865},"cogroupedkstream","CogroupedKStream",[361,1868,1869,1879],{},[364,1870,1871],{},[367,1872,1873,1875,1877],{},[370,1874,448],{},[370,1876,451],{},[370,1878,454],{},[377,1880,1881,1891,1900,1909,1918],{},[367,1882,1883,1886,1888],{},[382,1884,1885],{},"cogroup(KGroupedStream, aggregator)",[382,1887,384],{},[382,1889,1890],{},"Add another stream to the cogroup",[367,1892,1893,1896,1898],{},[382,1894,1895],{},"aggregate(initializer)",[382,1897,384],{},[382,1899,1669],{},[367,1901,1902,1904,1906],{},[382,1903,1692],{},[382,1905,384],{},[382,1907,1908],{},"Returns TimeWindowedCogroupedKStream",[367,1910,1911,1913,1915],{},[382,1912,1705],{},[382,1914,384],{},[382,1916,1917],{},"Sliding windows (KIP-450) → returns TimeWindowedCogroupedKStream",[367,1919,1920,1922,1924],{},[382,1921,1722],{},[382,1923,384],{},[382,1925,1926],{},"Returns SessionWindowedCogroupedKStream",[887,1928,1930],{"id":1929},"timewindowedcogroupedkstream","TimeWindowedCogroupedKStream",[361,1932,1933,1943],{},[364,1934,1935],{},[367,1936,1937,1939,1941],{},[370,1938,448],{},[370,1940,451],{},[370,1942,454],{},[377,1944,1945,1953],{},[367,1946,1947,1949,1951],{},[382,1948,1895],{},[382,1950,384],{},[382,1952,1669],{},[367,1954,1955,1957,1959],{},[382,1956,1800],{},[382,1958,384],{},[382,1960,1805],{},[887,1962,1964],{"id":1963},"sessionwindowedcogroupedkstream","SessionWindowedCogroupedKStream",[361,1966,1967,1977],{},[364,1968,1969],{},[367,1970,1971,1973,1975],{},[370,1972,448],{},[370,1974,451],{},[370,1976,454],{},[377,1978,1979,1993],{},[367,1980,1981,1984,1986],{},[382,1982,1983],{},"aggregate(initializer, sessionMerger)",[382,1985,384],{},[382,1987,1988,1989,1992],{},"With Materialized overloads; ",[478,1990,1991],{},"(initializer, sessionMerger)"," argument order matches Kafka Streams",[367,1994,1995,1997,1999],{},[382,1996,1800],{},[382,1998,384],{},[382,2000,1805],{},[356,2002,2004],{"id":2003},"ktable-transformations","KTable — transformations",[361,2006,2007,2017],{},[364,2008,2009],{},[367,2010,2011,2013,2015],{},[370,2012,448],{},[370,2014,451],{},[370,2016,454],{},[377,2018,2019,2028,2038,2048,2057,2066,2075,2084,2093,2101,2110,2119,2128,2136,2145,2154,2163,2173,2183,2193,2203,2212,2222,2235],{},[367,2020,2021,2023,2025],{},[382,2022,1006],{},[382,2024,384],{},[382,2026,2027],{},"Derived table (no state store)",[367,2029,2030,2033,2035],{},[382,2031,2032],{},"filter(predicate, Named)",[382,2034,384],{},[382,2036,2037],{},"With naming",[367,2039,2040,2043,2045],{},[382,2041,2042],{},"filter(predicate, Materialized)",[382,2044,384],{},[382,2046,2047],{},"With materialization",[367,2049,2050,2053,2055],{},[382,2051,2052],{},"filter(predicate, Named, Materialized)",[382,2054,384],{},[382,2056,1210],{},[367,2058,2059,2061,2063],{},[382,2060,1015],{},[382,2062,384],{},[382,2064,2065],{},"Inverse of filter",[367,2067,2068,2071,2073],{},[382,2069,2070],{},"filterNot(predicate, Named)",[382,2072,384],{},[382,2074,2037],{},[367,2076,2077,2080,2082],{},[382,2078,2079],{},"filterNot(predicate, Materialized)",[382,2081,384],{},[382,2083,2047],{},[367,2085,2086,2089,2091],{},[382,2087,2088],{},"filterNot(predicate, Named, Materialized)",[382,2090,384],{},[382,2092,1210],{},[367,2094,2095,2097,2099],{},[382,2096,1034],{},[382,2098,384],{},[382,2100,2027],{},[367,2102,2103,2106,2108],{},[382,2104,2105],{},"mapValues(ValueMapper, Named)",[382,2107,384],{},[382,2109,2037],{},[367,2111,2112,2115,2117],{},[382,2113,2114],{},"mapValues(ValueMapper, Materialized)",[382,2116,384],{},[382,2118,2047],{},[367,2120,2121,2124,2126],{},[382,2122,2123],{},"mapValues(ValueMapper, Named, Materialized)",[382,2125,384],{},[382,2127,1210],{},[367,2129,2130,2132,2134],{},[382,2131,1043],{},[382,2133,384],{},[382,2135,1048],{},[367,2137,2138,2141,2143],{},[382,2139,2140],{},"mapValues(ValueMapperWithKey, Named)",[382,2142,384],{},[382,2144,2037],{},[367,2146,2147,2150,2152],{},[382,2148,2149],{},"mapValues(ValueMapperWithKey, Materialized)",[382,2151,384],{},[382,2153,2047],{},[367,2155,2156,2159,2161],{},[382,2157,2158],{},"mapValues(ValueMapperWithKey, Named, Materialized)",[382,2160,384],{},[382,2162,1210],{},[367,2164,2165,2168,2170],{},[382,2166,2167],{},"toStream()",[382,2169,384],{},[382,2171,2172],{},"Same key type",[367,2174,2175,2178,2180],{},[382,2176,2177],{},"toStream(KeyValueMapper)",[382,2179,384],{},[382,2181,2182],{},"Key-changing variant; sub-topology boundary",[367,2184,2185,2188,2190],{},[382,2186,2187],{},"queryableStoreName()",[382,2189,384],{},[382,2191,2192],{},"Returns store name if materialized",[367,2194,2195,2198,2200],{},[382,2196,2197],{},"groupBy(keyValueSelector)",[382,2199,384],{},[382,2201,2202],{},"Selector returns KeyValue\u003CKR, VR>; returns KGroupedTable\u003CKR, VR>",[367,2204,2205,2208,2210],{},[382,2206,2207],{},"groupBy(keyValueSelector, Grouped)",[382,2209,384],{},[382,2211,1318],{},[367,2213,2214,2217,2219],{},[382,2215,2216],{},"suppress(Suppressed)",[382,2218,384],{},[382,2220,2221],{},"untilWindowCloses, untilTimeLimit",[367,2223,2224,2227,2229],{},[382,2225,2226],{},"transformValues(ValueTransformerWithKeySupplier, named?, storeNames...)",[382,2228,384],{},[382,2230,2231,2232],{},"Stateful per-key value transform; returns ",[478,2233,2234],{},"KTable\u003CK, VR>",[367,2236,2237,2245,2247],{},[382,2238,2239,2240,2244],{},"transformValues(ValueTransformerWithKeySupplier, Materialized, ",[2241,2242,2243],"span",{},"Named,"," storeNames...)",[382,2246,384],{},[382,2248,2249,2250,2253],{},"Materializes the result into a queryable store (tombstone-aware: a ",[478,2251,2252],{},"null"," transform deletes)",[356,2255,2257],{"id":2256},"ktable-primary-key-joins","KTable — primary-key joins",[320,2259,2260,2261,2264],{},"Both tables share key type ",[478,2262,2263],{},"K",". No co-partitioning required (global state model).",[361,2266,2267,2277],{},[364,2268,2269],{},[367,2270,2271,2273,2275],{},[370,2272,448],{},[370,2274,451],{},[370,2276,454],{},[377,2278,2279,2289,2299,2308,2318,2327,2336,2346,2355],{},[367,2280,2281,2284,2286],{},[382,2282,2283],{},"join(KTable, joiner)",[382,2285,384],{},[382,2287,2288],{},"Inner join; both must be materialized",[367,2290,2291,2294,2296],{},[382,2292,2293],{},"join(KTable, joiner, Materialized)",[382,2295,384],{},[382,2297,2298],{},"With materialization of join result",[367,2300,2301,2304,2306],{},[382,2302,2303],{},"join(KTable, joiner, Named, Materialized)",[382,2305,384],{},[382,2307,1210],{},[367,2309,2310,2313,2315],{},[382,2311,2312],{},"leftJoin(KTable, joiner)",[382,2314,384],{},[382,2316,2317],{},"Left table always emits",[367,2319,2320,2323,2325],{},[382,2321,2322],{},"leftJoin(KTable, joiner, Materialized)",[382,2324,384],{},[382,2326,2298],{},[367,2328,2329,2332,2334],{},[382,2330,2331],{},"leftJoin(KTable, joiner, Named, Materialized)",[382,2333,384],{},[382,2335,1210],{},[367,2337,2338,2341,2343],{},[382,2339,2340],{},"outerJoin(KTable, joiner)",[382,2342,384],{},[382,2344,2345],{},"Full outer join",[367,2347,2348,2351,2353],{},[382,2349,2350],{},"outerJoin(KTable, joiner, Materialized)",[382,2352,384],{},[382,2354,2298],{},[367,2356,2357,2360,2362],{},[382,2358,2359],{},"outerJoin(KTable, joiner, Named, Materialized)",[382,2361,384],{},[382,2363,1210],{},[344,2365,2366],{"color":346,"icon":1571},[320,2367,2368,2371],{},[324,2369,2370],{},"KIP-914 semantics."," When both tables are backed by versioned stores, out-of-order records do not trigger join evaluation, and temporal lookups return the correct value from the other table — preventing inconsistent results under out-of-order arrival.",[356,2373,2375],{"id":2374},"ktable-foreign-key-joins","KTable — foreign-key joins",[320,2377,2378,2379,2382,2383,2386,2387,925,2390,2393],{},"Foreign-key extractor: a Java ",[478,2380,2381],{},"Function\u003CV, KO?>"," (or ",[478,2384,2385],{},"BiFunction\u003CK, V, KO?>"," for key-aware extraction) — or a Kotlin ",[478,2388,2389],{},"(V) -> KO?",[478,2391,2392],{},"(K, V) -> KO?"," lambda.",[361,2395,2396,2406],{},[364,2397,2398],{},[367,2399,2400,2402,2404],{},[370,2401,448],{},[370,2403,451],{},[370,2405,454],{},[377,2407,2408,2418,2427,2436,2446,2455,2464],{},[367,2409,2410,2413,2415],{},[382,2411,2412],{},"join(KTable, fkExtractor, joiner)",[382,2414,384],{},[382,2416,2417],{},"Inner FK join",[367,2419,2420,2423,2425],{},[382,2421,2422],{},"join(KTable, fkExtractor, joiner, Materialized)",[382,2424,384],{},[382,2426,2298],{},[367,2428,2429,2432,2434],{},[382,2430,2431],{},"join(KTable, fkExtractor, joiner, TableJoined, Materialized)",[382,2433,384],{},[382,2435,1210],{},[367,2437,2438,2441,2443],{},[382,2439,2440],{},"leftJoin(KTable, fkExtractor, joiner)",[382,2442,384],{},[382,2444,2445],{},"Left FK join",[367,2447,2448,2451,2453],{},[382,2449,2450],{},"leftJoin(KTable, fkExtractor, joiner, Materialized)",[382,2452,384],{},[382,2454,2298],{},[367,2456,2457,2460,2462],{},[382,2458,2459],{},"leftJoin(KTable, fkExtractor, joiner, TableJoined, Materialized)",[382,2461,384],{},[382,2463,1210],{},[367,2465,2466,2469,2471],{},[382,2467,2468],{},"outerJoin(KTable, fkExtractor, joiner)",[382,2470,392],{},[382,2472,2473],{},"Not supported in KS either",[356,2475,2477],{"id":2476},"kgroupedtable","KGroupedTable",[320,2479,2480,2482,2483,2486,2487,2490,2491,2494],{},[478,2481,2477],{}," is the result of ",[478,2484,2485],{},"KTable.groupBy()"," and uses changelog semantics — moving a key from group A to group B decrements A and increments B. The source ",[478,2488,2489],{},"KTable"," must be materialized for ",[478,2492,2493],{},"groupBy()"," to track old values.",[361,2496,2497,2507],{},[364,2498,2499],{},[367,2500,2501,2503,2505],{},[370,2502,448],{},[370,2504,451],{},[370,2506,454],{},[377,2508,2509,2518,2531],{},[367,2510,2511,2513,2515],{},[382,2512,1664],{},[382,2514,384],{},[382,2516,2517],{},"Changelog semantics",[367,2519,2520,2523,2525],{},[382,2521,2522],{},"reduce(adder, subtractor)",[382,2524,384],{},[382,2526,2527,2528],{},"Kafka Streams compatible; both adder and subtractor are ",[478,2529,2530],{},"Reducer\u003CV>",[367,2532,2533,2536,2538],{},[382,2534,2535],{},"aggregate(init, adder, subtractor)",[382,2537,384],{},[382,2539,2540,2541,2544,2545,2548,2549,2552],{},"Kafka Streams compatible; both adder ",[324,2542,2543],{},"and"," subtractor are ",[478,2546,2547],{},"Aggregator\u003CK, V, VR>"," — no StoatFlow-only ",[478,2550,2551],{},"Subtractor"," type",[356,2554,2556],{"id":2555},"globalktable","GlobalKTable",[361,2558,2559,2569],{},[364,2560,2561],{},[367,2562,2563,2565,2567],{},[370,2564,448],{},[370,2566,451],{},[370,2568,454],{},[377,2570,2571,2580],{},[367,2572,2573,2575,2577],{},[382,2574,2187],{},[382,2576,384],{},[382,2578,2579],{},"Returns underlying table's store name",[367,2581,2582,2585,2587],{},[382,2583,2584],{},"asKTable()",[382,2586,424],{},[382,2588,2589],{},"StoatFlow extension to unwrap",[344,2591,2592],{"color":346,"icon":1571},[320,2593,2594],{},"GlobalKTable wraps KTable internally. Because all state is global, its behaviour is identical to KTable.",[356,2596,2598],{"id":2597},"processor-api","Processor API",[887,2600,2602],{"id":2601},"processorcontext","ProcessorContext",[361,2604,2605,2615],{},[364,2606,2607],{},[367,2608,2609,2611,2613],{},[370,2610,448],{},[370,2612,451],{},[370,2614,454],{},[377,2616,2617,2627,2637,2647,2657,2667,2677,2687,2697,2710,2724,2733],{},[367,2618,2619,2622,2624],{},[382,2620,2621],{},"forward(record)",[382,2623,384],{},[382,2625,2626],{},"Forward to downstream processors",[367,2628,2629,2632,2634],{},[382,2630,2631],{},"forward(record, childName)",[382,2633,384],{},[382,2635,2636],{},"Forward to specific child",[367,2638,2639,2642,2644],{},[382,2640,2641],{},"getStateStore(name)",[382,2643,384],{},[382,2645,2646],{},"Access connected state stores",[367,2648,2649,2652,2654],{},[382,2650,2651],{},"schedule(interval, type, punctuator)",[382,2653,384],{},[382,2655,2656],{},"KS-compatible punctuator",[367,2658,2659,2662,2664],{},[382,2660,2661],{},"schedule(interval, type, mode, punctuator)",[382,2663,424],{},[382,2665,2666],{},"StoatFlow extension with BLOCKING\u002FNON_BLOCKING mode",[367,2668,2669,2672,2674],{},[382,2670,2671],{},"schedule(interval, startTime, type, punctuator)",[382,2673,384],{},[382,2675,2676],{},"KIP-1146: anchored punctuation with grid-aligned fire times",[367,2678,2679,2682,2684],{},[382,2680,2681],{},"schedule(interval, startTime, type, mode, punctuator)",[382,2683,384],{},[382,2685,2686],{},"KIP-1146: anchored punctuation with BLOCKING\u002FNON_BLOCKING mode",[367,2688,2689,2692,2694],{},[382,2690,2691],{},"recordMetadata()",[382,2693,384],{},[382,2695,2696],{},"Source partition, offset, topic",[367,2698,2699,2702,2704],{},[382,2700,2701],{},"currentSystemTimeMs()",[382,2703,384],{},[382,2705,2706,2707],{},"Wall-clock time via ",[478,2708,2709],{},"System.currentTimeMillis()",[367,2711,2712,2715,2717],{},[382,2713,2714],{},"currentStreamTimeMs()",[382,2716,384],{},[382,2718,2719,2720,2723],{},"Delegates to ",[478,2721,2722],{},"currentWatermarkMs()"," (global watermark)",[367,2725,2726,2728,2730],{},[382,2727,2722],{},[382,2729,432],{},[382,2731,2732],{},"Global watermark in epoch millis",[367,2734,2735,2738,2740],{},[382,2736,2737],{},"timerService()",[382,2739,424],{},[382,2741,2742],{},"Key-based timer access (Flink-inspired)",[887,2744,2746],{"id":2745},"processor-interfaces","Processor interfaces",[361,2748,2749,2760],{},[364,2750,2751],{},[367,2752,2753,2756,2758],{},[370,2754,2755],{},"Type",[370,2757,451],{},[370,2759,454],{},[377,2761,2762,2772,2782,2792,2802,2812,2822,2832,2853,2870,2884,2912],{},[367,2763,2764,2767,2769],{},[382,2765,2766],{},"Processor\u003CKIn,VIn,KOut,VOut>",[382,2768,384],{},[382,2770,2771],{},"Key-changing processor interface",[367,2773,2774,2777,2779],{},[382,2775,2776],{},"FixedKeyProcessor\u003CKIn,VIn,VOut>",[382,2778,384],{},[382,2780,2781],{},"Key-preserving processor interface",[367,2783,2784,2787,2789],{},[382,2785,2786],{},"ContextualProcessor\u003CKIn,VIn,KOut,VOut>",[382,2788,384],{},[382,2790,2791],{},"Abstract base managing ProcessorContext",[367,2793,2794,2797,2799],{},[382,2795,2796],{},"ContextualFixedKeyProcessor\u003CKIn,VIn,VOut>",[382,2798,384],{},[382,2800,2801],{},"Abstract base managing FixedKeyProcessorContext",[367,2803,2804,2807,2809],{},[382,2805,2806],{},"ProcessorSupplier\u003CKIn,VIn,KOut,VOut>",[382,2808,384],{},[382,2810,2811],{},"Factory for Processor instances",[367,2813,2814,2817,2819],{},[382,2815,2816],{},"ProcessorSupplier.stores()",[382,2818,384],{},[382,2820,2821],{},"KS 4.x pattern for declaring stores inline",[367,2823,2824,2827,2829],{},[382,2825,2826],{},"FixedKeyProcessorSupplier\u003CKIn,VIn,VOut>",[382,2828,384],{},[382,2830,2831],{},"Factory for FixedKeyProcessor instances",[367,2833,2834,2837,2839],{},[382,2835,2836],{},"ValueTransformerWithKey\u003CK,V,VR>",[382,2838,384],{},[382,2840,2841,2842,2845,2846,2849,2850],{},"Consumed by ",[478,2843,2844],{},"KTable.transformValues","; ",[478,2847,2848],{},"init"," binds StoatFlow's ",[478,2851,2852],{},"FixedKeyProcessorContext",[367,2854,2855,2858,2860],{},[382,2856,2857],{},"ValueTransformerWithKeySupplier\u003CK,V,VR>",[382,2859,384],{},[382,2861,2862,2863,2866,2867],{},"Factory for ",[478,2864,2865],{},"ValueTransformerWithKey","; declares stores via ",[478,2868,2869],{},"stores()",[367,2871,2872,2875,2877],{},[382,2873,2874],{},"ValueTransformer \u002F Transformer (+ suppliers)",[382,2876,416],{},[382,2878,2879,2880,2883],{},"Deprecated in KS and removed from ",[478,2881,2882],{},"KStream","; kept as nameable types for source compatibility",[367,2885,2886,2895,2897],{},[382,2887,2888,925,2891,2894],{},[478,2889,2890],{},"init()",[478,2892,2893],{},"close()"," lifecycle",[382,2896,384],{},[382,2898,2899,2900,2902,2903,2905,2906,925,2909],{},"Once per task — ",[478,2901,2890],{}," before any records, ",[478,2904,2893],{}," once at shutdown (KS contract), across all processor paths incl. ",[478,2907,2908],{},"processValues",[478,2910,2911],{},"transformValues",[367,2913,2914,2925,2927],{},[382,2915,2916,2919,2920,925,2923],{},[478,2917,2918],{},"FixedKeyProcessor.onTimer"," + ",[478,2921,2922],{},"schedule()",[478,2924,2737],{},[382,2926,384],{},[382,2928,2929,2930,2932,2933,2936,2937,2939,2940,2942,2943,2945,2946,2949,2950,2953],{},"Full ",[478,2931,786],{}," timer parity for ",[478,2934,2935],{},"FixedKeyProcessor"," (",[478,2938,2908],{},"): periodic punctuators via ",[478,2941,2922],{}," and keyed timers via ",[478,2944,2737],{}," → ",[478,2947,2948],{},"onTimer(...)"," (key-preserving ",[478,2951,2952],{},"FixedKeyTimerContext",", full state access, re-registration). Record timestamp is the event time",[887,2955,2957],{"id":2956},"punctuators-and-timers","Punctuators and timers",[361,2959,2960,2971],{},[364,2961,2962],{},[367,2963,2964,2967,2969],{},[370,2965,2966],{},"Type \u002F Method",[370,2968,451],{},[370,2970,454],{},[377,2972,2973,2983,2993,3003,3013,3023,3033,3043,3053,3063,3073,3083],{},[367,2974,2975,2978,2980],{},[382,2976,2977],{},"PunctuationType.STREAM_TIME",[382,2979,384],{},[382,2981,2982],{},"Fires on event-time watermark advancement",[367,2984,2985,2988,2990],{},[382,2986,2987],{},"PunctuationType.WALL_CLOCK_TIME",[382,2989,384],{},[382,2991,2992],{},"Fires on system clock",[367,2994,2995,2998,3000],{},[382,2996,2997],{},"PunctuatorMode.BLOCKING",[382,2999,424],{},[382,3001,3002],{},"Barriers wait for punctuator completion before commit",[367,3004,3005,3008,3010],{},[382,3006,3007],{},"PunctuatorMode.NON_BLOCKING",[382,3009,424],{},[382,3011,3012],{},"Barriers proceed independently (default)",[367,3014,3015,3018,3020],{},[382,3016,3017],{},"Punctuator.punctuate(timestamp)",[382,3019,384],{},[382,3021,3022],{},"Callback invoked at scheduled time",[367,3024,3025,3028,3030],{},[382,3026,3027],{},"Cancellable.cancel()",[382,3029,384],{},[382,3031,3032],{},"Cancel scheduled punctuator or timer",[367,3034,3035,3038,3040],{},[382,3036,3037],{},"TimerService.registerEventTimeTimer(key, timestamp)",[382,3039,424],{},[382,3041,3042],{},"Fire when watermark ≥ timestamp",[367,3044,3045,3048,3050],{},[382,3046,3047],{},"TimerService.registerProcessingTimeTimer(key, timestamp)",[382,3049,424],{},[382,3051,3052],{},"Fire at wall-clock time",[367,3054,3055,3058,3060],{},[382,3056,3057],{},"TimerService.deleteEventTimeTimer(key, timestamp)",[382,3059,424],{},[382,3061,3062],{},"Cancel event-time timer",[367,3064,3065,3068,3070],{},[382,3066,3067],{},"TimerService.deleteProcessingTimeTimer(key, timestamp)",[382,3069,424],{},[382,3071,3072],{},"Cancel processing-time timer",[367,3074,3075,3078,3080],{},[382,3076,3077],{},"TimerService.currentWatermark()",[382,3079,424],{},[382,3081,3082],{},"Current event-time watermark",[367,3084,3085,3088,3090],{},[382,3086,3087],{},"TimerService.currentProcessingTime()",[382,3089,424],{},[382,3091,3092],{},"Current wall-clock time",[344,3094,3095],{"color":346,"icon":1571},[320,3096,3097,3098,3101,3102,3105],{},"Kafka Streams punctuators are partition-scoped with writable state and always non-blocking. StoatFlow punctuators run globally with read-only state on dedicated virtual threads; ",[478,3099,3100],{},"PunctuatorMode"," and the key-based ",[478,3103,3104],{},"TimerService"," (which fires in the key's affinity lane with full read\u002Fwrite state access) are StoatFlow extensions.",[356,3107,3109],{"id":3108},"scheduled-sources-stoatflow-extension","Scheduled sources (StoatFlow extension)",[320,3111,3112,3113,3116,3117,3120,3121,3124],{},"A ",[478,3114,3115],{},"ScheduledEmitter"," — registered via ",[478,3118,3119],{},"StreamsBuilder.scheduled(...)"," — periodically emits records (interval- or cron-based) using the ",[478,3122,3123],{},"ScheduledEmitterContext"," below, without consuming from Kafka.",[887,3126,3123],{"id":3127},"scheduledemittercontext",[361,3129,3130,3140],{},[364,3131,3132],{},[367,3133,3134,3136,3138],{},[370,3135,448],{},[370,3137,451],{},[370,3139,454],{},[377,3141,3142,3152,3162,3171,3180,3189,3200,3210],{},[367,3143,3144,3147,3149],{},[382,3145,3146],{},"forward(key, value)",[382,3148,424],{},[382,3150,3151],{},"Emit record with current wall-clock time",[367,3153,3154,3157,3159],{},[382,3155,3156],{},"forward(key, value, timestamp)",[382,3158,424],{},[382,3160,3161],{},"Emit record with explicit timestamp",[367,3163,3164,3166,3168],{},[382,3165,2621],{},[382,3167,424],{},[382,3169,3170],{},"Emit record with key, value, timestamp, headers",[367,3172,3173,3175,3177],{},[382,3174,2641],{},[382,3176,424],{},[382,3178,3179],{},"Access read-only state store",[367,3181,3182,3184,3186],{},[382,3183,2722],{},[382,3185,432],{},[382,3187,3188],{},"Current watermark (global event-time progress)",[367,3190,3191,3193,3195],{},[382,3192,2714],{},[382,3194,384],{},[382,3196,2719,3197,3199],{},[478,3198,2722],{}," (KS compat)",[367,3201,3202,3204,3206],{},[382,3203,2701],{},[382,3205,384],{},[382,3207,2706,3208,3199],{},[478,3209,2709],{},[367,3211,3212,3215,3217],{},[382,3213,3214],{},"currentWallClockTime()",[382,3216,424],{},[382,3218,3092],{},[887,3220,3222],{"id":3221},"cronexpression","CronExpression",[361,3224,3225,3235],{},[364,3226,3227],{},[367,3228,3229,3231,3233],{},[370,3230,448],{},[370,3232,451],{},[370,3234,454],{},[377,3236,3237,3247,3257,3267,3277,3287],{},[367,3238,3239,3242,3244],{},[382,3240,3241],{},"unix(expression)",[382,3243,424],{},[382,3245,3246],{},"Unix cron (5 fields: min hour dom mon dow)",[367,3248,3249,3252,3254],{},[382,3250,3251],{},"quartz(expression)",[382,3253,424],{},[382,3255,3256],{},"Quartz cron (6 fields with seconds)",[367,3258,3259,3262,3264],{},[382,3260,3261],{},"spring(expression)",[382,3263,424],{},[382,3265,3266],{},"Spring cron (6 fields with seconds)",[367,3268,3269,3272,3274],{},[382,3270,3271],{},"parse(expression, cronType)",[382,3273,424],{},[382,3275,3276],{},"Parse with explicit type",[367,3278,3279,3282,3284],{},[382,3280,3281],{},"nextExecutionTime(afterMs, zoneId?)",[382,3283,424],{},[382,3285,3286],{},"Calculate next fire time",[367,3288,3289,3292,3294],{},[382,3290,3291],{},"timeUntilNextExecution(fromMs, zoneId?)",[382,3293,424],{},[382,3295,3296],{},"Duration until next fire",[344,3298,3299],{"color":346,"icon":1571},[320,3300,3301],{},"Cron-based scheduling always uses wall-clock time.",[356,3303,3305],{"id":3304},"functional-interfaces","Functional interfaces",[320,3307,3308],{},"KS-compatible functional interfaces backing the Java-friendly DSL overloads.",[361,3310,3311,3323],{},[364,3312,3313],{},[367,3314,3315,3318,3320],{},[370,3316,3317],{},"Interface",[370,3319,451],{},[370,3321,3322],{},"Used in",[377,3324,3325,3347,3362,3377,3394,3411,3426,3450,3463,3477,3489,3501],{},[367,3326,3327,3332,3334],{},[382,3328,3329],{},[478,3330,3331],{},"KeyValueMapper\u003CK, V, VR>",[382,3333,384],{},[382,3335,3336,3339,3340,3339,3343,3346],{},[478,3337,3338],{},"map",", ",[478,3341,3342],{},"flatMap",[478,3344,3345],{},"groupBy",", FK joins",[367,3348,3349,3354,3356],{},[382,3350,3351],{},[478,3352,3353],{},"ValueMapper\u003CV, VR>",[382,3355,384],{},[382,3357,3358,3361],{},[478,3359,3360],{},"KTable.mapValues",", FK join extractors",[367,3363,3364,3369,3371],{},[382,3365,3366],{},[478,3367,3368],{},"ValueMapperWithKey\u003CK, V, VR>",[382,3370,384],{},[382,3372,3373,3376],{},[478,3374,3375],{},"mapValues"," with key access",[367,3378,3379,3384,3386],{},[382,3380,3381],{},[478,3382,3383],{},"Predicate\u003CK, V>",[382,3385,384],{},[382,3387,3388,3339,3391],{},[478,3389,3390],{},"filter",[478,3392,3393],{},"filterNot",[367,3395,3396,3401,3403],{},[382,3397,3398],{},[478,3399,3400],{},"ForeachAction\u003CK, V>",[382,3402,384],{},[382,3404,3405,3339,3408],{},[478,3406,3407],{},"peek",[478,3409,3410],{},"forEach",[367,3412,3413,3418,3420],{},[382,3414,3415],{},[478,3416,3417],{},"Initializer\u003CVA>",[382,3419,384],{},[382,3421,3422,3423],{},"All ",[478,3424,3425],{},"aggregate()",[367,3427,3428,3433,3435],{},[382,3429,3430],{},[478,3431,3432],{},"Aggregator\u003CK, V, VA>",[382,3434,384],{},[382,3436,3422,3437,3439,3440,3443,3444,3447,3448,1717],{},[478,3438,3425],{}," — incl. both the adder and subtractor of ",[478,3441,3442],{},"KGroupedTable.aggregate()"," (KS uses ",[478,3445,3446],{},"Aggregator"," for both; no ",[478,3449,2551],{},[367,3451,3452,3456,3458],{},[382,3453,3454],{},[478,3455,2530],{},[382,3457,384],{},[382,3459,3422,3460],{},[478,3461,3462],{},"reduce()",[367,3464,3465,3470,3472],{},[382,3466,3467],{},[478,3468,3469],{},"Merger\u003CK, V>",[382,3471,384],{},[382,3473,3474,3475],{},"Session window ",[478,3476,3425],{},[367,3478,3479,3484,3486],{},[382,3480,3481],{},[478,3482,3483],{},"ValueJoiner\u003CV1, V2, VR>",[382,3485,384],{},[382,3487,3488],{},"All joins",[367,3490,3491,3496,3498],{},[382,3492,3493],{},[478,3494,3495],{},"ValueJoinerWithKey\u003CK, V1, V2, VR>",[382,3497,384],{},[382,3499,3500],{},"Key-aware joins",[367,3502,3503,3508,3510],{},[382,3504,3505],{},[478,3506,3507],{},"StreamPartitioner\u003CK, V>",[382,3509,384],{},[382,3511,3512,3513,3516,3517,3520],{},"KIP-837 ",[478,3514,3515],{},"partitions(...): Optional\u003CSet\u003CInteger>>"," (sole method). Sink multicast matches KS; the in-memory repartition path throws on multicast (single-instance). Lives in the ",[478,3518,3519],{},"topology"," package",[356,3522,3524],{"id":3523},"configuration-helper-classes","Configuration helper classes",[887,3526,3528],{"id":3527},"consumed","Consumed",[361,3530,3531,3541],{},[364,3532,3533],{},[367,3534,3535,3537,3539],{},[370,3536,448],{},[370,3538,451],{},[370,3540,454],{},[377,3542,3543,3552,3562,3571,3580,3589,3599,3613,3643,3653],{},[367,3544,3545,3548,3550],{},[382,3546,3547],{},"with(keySerde, valueSerde)",[382,3549,384],{},[382,3551],{},[367,3553,3554,3557,3559],{},[382,3555,3556],{},"with(keySerde, valueSerde, timestampExtractor, resetPolicy)",[382,3558,384],{},[382,3560,3561],{},"Extractor adapted to a stream-time watermark strategy",[367,3563,3564,3567,3569],{},[382,3565,3566],{},"keySerde(serde)",[382,3568,384],{},[382,3570],{},[367,3572,3573,3576,3578],{},[382,3574,3575],{},"valueSerde(serde)",[382,3577,384],{},[382,3579],{},[367,3581,3582,3585,3587],{},[382,3583,3584],{},"as(name)",[382,3586,384],{},[382,3588],{},[367,3590,3591,3594,3596],{},[382,3592,3593],{},"withWatermarkStrategy(strategy)",[382,3595,424],{},[382,3597,3598],{},"StoatFlow extension (mutually exclusive with withTimestampExtractor)",[367,3600,3601,3604,3606],{},[382,3602,3603],{},"withTimestampExtractor()",[382,3605,384],{},[382,3607,3608,3609,3612],{},"KS ",[478,3610,3611],{},"TimestampExtractor"," adapted to a per-source watermark strategy that assigns event time + emits stream-time watermarks (windowing\u002Fsuppress close as in KS); use withWatermarkStrategy for bounded-out-of-orderness\u002Fidleness",[367,3614,3615,3618,3620],{},[382,3616,3617],{},"withOffsetResetPolicy()",[382,3619,384],{},[382,3621,3622,3623,3626,3627,925,3630,925,3633,925,3636,3639,3640,1246],{},"Per-source offset reset. ",[478,3624,3625],{},"AutoOffsetReset",": ",[478,3628,3629],{},"Earliest",[478,3631,3632],{},"Latest",[478,3634,3635],{},"None",[478,3637,3638],{},"byDuration(Duration)"," (KIP-1106 — seek to the first offset at\u002Fafter ",[478,3641,3642],{},"now − duration",[367,3644,3645,3648,3650],{},[382,3646,3647],{},"withNumberOfLanes(int)",[382,3649,432],{},[382,3651,3652],{},"Sets this source chain's lane count (parallelism)",[367,3654,3655,3658,3660],{},[382,3656,3657],{},"withLaneQueueCapacity(int)",[382,3659,432],{},[382,3661,3662],{},"Sets this source chain's per-lane queue capacity",[887,3664,3666],{"id":3665},"watermarkstrategy-flink-inspired","WatermarkStrategy (Flink-inspired)",[320,3668,3669,3670,3673,3674,3677,3678,3681],{},"Event-time progress is driven by a ",[478,3671,3672],{},"WatermarkStrategy",". A KS ",[478,3675,3676],{},"Consumed.withTimestampExtractor(...)"," is supported and adapted to one under the hood; ",[478,3679,3680],{},"Consumed.withWatermarkStrategy(...)"," is the richer StoatFlow-native form (bounded out-of-orderness, idleness, alignment).",[361,3683,3684,3694],{},[364,3685,3686],{},[367,3687,3688,3690,3692],{},[370,3689,448],{},[370,3691,451],{},[370,3693,454],{},[377,3695,3696,3706,3716,3726,3736,3746],{},[367,3697,3698,3701,3703],{},[382,3699,3700],{},"forBoundedOutOfOrderness(maxOutOfOrderness)",[382,3702,424],{},[382,3704,3705],{},"Bounded out-of-orderness",[367,3707,3708,3711,3713],{},[382,3709,3710],{},"forMonotonousTimestamps()",[382,3712,424],{},[382,3714,3715],{},"Strictly increasing timestamps",[367,3717,3718,3721,3723],{},[382,3719,3720],{},"noWatermarks()",[382,3722,424],{},[382,3724,3725],{},"Processing-time only",[367,3727,3728,3731,3733],{},[382,3729,3730],{},"withTimestampAssigner(assigner)",[382,3732,424],{},[382,3734,3735],{},"Custom event-time assignment",[367,3737,3738,3741,3743],{},[382,3739,3740],{},"withIdleness(duration)",[382,3742,424],{},[382,3744,3745],{},"Idle-source handling",[367,3747,3748,3754,3756],{},[382,3749,3750,3751,1246],{},"withWatermarkAlignment(group, maxDrift",[2241,3752,3753],{},", updateInterval",[382,3755,424],{},[382,3757,3758],{},"Flink FLIP-217 alignment; pauses a partition whose watermark drifts beyond the group cap",[320,3760,588,3761,3763,3764,3767,3768,3770],{},[478,3762,3611],{}," SAM is present with the KS-exact, non-generic signature ",[478,3765,3766],{},"long extract(ConsumerRecord\u003CObject, Object>, long)",", and ",[478,3769,3676],{}," wires it to event-time + stream-time watermarks.",[320,3772,3773,3774,783,3776,783,3779,783,3782,783,3785,783,3788,783,3791,783,3794,3797,3798,3800,3801,3803],{},"KS-optional builder arguments (serdes, grace, partitioner, offset-reset, name) across ",[478,3775,3528],{},[478,3777,3778],{},"Grouped",[478,3780,3781],{},"Produced",[478,3783,3784],{},"Repartitioned",[478,3786,3787],{},"Joined",[478,3789,3790],{},"StreamJoined",[478,3792,3793],{},"Materialized",[478,3795,3796],{},"Branched"," accept ",[478,3799,2252],{}," (= \"use the default\"), matching Kafka Streams; ",[478,3802,1537],{}," itself still requires a non-null name.",[887,3805,3778],{"id":3806},"grouped",[361,3808,3809,3819],{},[364,3810,3811],{},[367,3812,3813,3815,3817],{},[370,3814,448],{},[370,3816,451],{},[370,3818,454],{},[377,3820,3821,3829,3837,3845,3853,3862,3871,3880,3889,3898],{},[367,3822,3823,3825,3827],{},[382,3824,3584],{},[382,3826,384],{},[382,3828],{},[367,3830,3831,3833,3835],{},[382,3832,3566],{},[382,3834,384],{},[382,3836],{},[367,3838,3839,3841,3843],{},[382,3840,3575],{},[382,3842,384],{},[382,3844],{},[367,3846,3847,3849,3851],{},[382,3848,3547],{},[382,3850,384],{},[382,3852],{},[367,3854,3855,3858,3860],{},[382,3856,3857],{},"with(name, keySerde, valueSerde)",[382,3859,384],{},[382,3861],{},[367,3863,3864,3867,3869],{},[382,3865,3866],{},"withName(name)",[382,3868,384],{},[382,3870],{},[367,3872,3873,3876,3878],{},[382,3874,3875],{},"withKeySerde(serde)",[382,3877,384],{},[382,3879],{},[367,3881,3882,3885,3887],{},[382,3883,3884],{},"withValueSerde(serde)",[382,3886,384],{},[382,3888],{},[367,3890,3891,3893,3895],{},[382,3892,3647],{},[382,3894,432],{},[382,3896,3897],{},"Sets the grouped sub-topology's lane count",[367,3899,3900,3902,3904],{},[382,3901,3657],{},[382,3903,432],{},[382,3905,3906],{},"Sets the grouped sub-topology's per-lane queue capacity",[887,3908,3781],{"id":3909},"produced",[361,3911,3912,3922],{},[364,3913,3914],{},[367,3915,3916,3918,3920],{},[370,3917,448],{},[370,3919,451],{},[370,3921,454],{},[377,3923,3924,3932,3940,3948,3956],{},[367,3925,3926,3928,3930],{},[382,3927,3547],{},[382,3929,384],{},[382,3931],{},[367,3933,3934,3936,3938],{},[382,3935,3566],{},[382,3937,384],{},[382,3939],{},[367,3941,3942,3944,3946],{},[382,3943,3575],{},[382,3945,384],{},[382,3947],{},[367,3949,3950,3952,3954],{},[382,3951,3584],{},[382,3953,384],{},[382,3955],{},[367,3957,3958,3961,3963],{},[382,3959,3960],{},"streamPartitioner(partitioner)",[382,3962,384],{},[382,3964],{},[887,3966,3793],{"id":3967},"materialized",[361,3969,3970,3980],{},[364,3971,3972],{},[367,3973,3974,3976,3978],{},[370,3975,448],{},[370,3977,451],{},[370,3979,454],{},[377,3981,3982,3991,4000,4010,4018,4026,4034,4044,4054,4064,4074,4084,4094,4104],{},[367,3983,3984,3987,3989],{},[382,3985,3986],{},"as(storeName)",[382,3988,384],{},[382,3990],{},[367,3992,3993,3996,3998],{},[382,3994,3995],{},"as(storeSupplier)",[382,3997,384],{},[382,3999],{},[367,4001,4002,4005,4007],{},[382,4003,4004],{},"as(DslStoreSuppliers)",[382,4006,384],{},[382,4008,4009],{},"Store type supplier",[367,4011,4012,4014,4016],{},[382,4013,3547],{},[382,4015,384],{},[382,4017],{},[367,4019,4020,4022,4024],{},[382,4021,3566],{},[382,4023,384],{},[382,4025],{},[367,4027,4028,4030,4032],{},[382,4029,3575],{},[382,4031,384],{},[382,4033],{},[367,4035,4036,4039,4041],{},[382,4037,4038],{},"withCachingEnabled()",[382,4040,384],{},[382,4042,4043],{},"Suppress downstream emissions (default enabled)",[367,4045,4046,4049,4051],{},[382,4047,4048],{},"withCachingDisabled()",[382,4050,384],{},[382,4052,4053],{},"Emit all intermediate updates downstream",[367,4055,4056,4059,4061],{},[382,4057,4058],{},"withLoggingEnabled()",[382,4060,384],{},[382,4062,4063],{},"Enable changelog with optional topic config",[367,4065,4066,4069,4071],{},[382,4067,4068],{},"withLoggingDisabled()",[382,4070,384],{},[382,4072,4073],{},"Disable changelog for this store",[367,4075,4076,4079,4081],{},[382,4077,4078],{},"withRetention()",[382,4080,384],{},[382,4082,4083],{},"Override computed retention for windowed stores",[367,4085,4086,4089,4091],{},[382,4087,4088],{},"withStoreType(DslStoreSuppliers)",[382,4090,384],{},[382,4092,4093],{},"Store type selection",[367,4095,4096,4099,4101],{},[382,4097,4098],{},"withRecordHeaders()",[382,4100,432],{},[382,4102,4103],{},"Persist the record's headers alongside key\u002Fvalue in the store (KIP-1271 \u002F KIP-1285)",[367,4105,4106,4109,4111],{},[382,4107,4108],{},"withoutRecordHeaders()",[382,4110,432],{},[382,4112,4113],{},"Disable header persistence (default)",[887,4115,3796],{"id":4116},"branched",[361,4118,4119,4129],{},[364,4120,4121],{},[367,4122,4123,4125,4127],{},[370,4124,448],{},[370,4126,451],{},[370,4128,454],{},[377,4130,4131,4139,4147,4156],{},[367,4132,4133,4135,4137],{},[382,4134,3584],{},[382,4136,384],{},[382,4138],{},[367,4140,4141,4143,4145],{},[382,4142,3866],{},[382,4144,384],{},[382,4146],{},[367,4148,4149,4152,4154],{},[382,4150,4151],{},"withFunction(chain)",[382,4153,384],{},[382,4155],{},[367,4157,4158,4161,4163],{},[382,4159,4160],{},"withConsumer(consumer)",[382,4162,384],{},[382,4164,4165],{},"Java Consumer overload",[887,4167,1537],{"id":4168},"named",[320,4170,4171,4173,4174,4177],{},[478,4172,1537],{}," is ",[478,4175,4176],{},"open","\u002Fsubclassable, so KSML's name-validation subclasses work.",[361,4179,4180,4190],{},[364,4181,4182],{},[367,4183,4184,4186,4188],{},[370,4185,448],{},[370,4187,451],{},[370,4189,454],{},[377,4191,4192,4200,4209],{},[367,4193,4194,4196,4198],{},[382,4195,3584],{},[382,4197,384],{},[382,4199],{},[367,4201,4202,4204,4206],{},[382,4203,3866],{},[382,4205,384],{},[382,4207,4208],{},"Fluent builder form",[367,4210,4211,4214,4216],{},[382,4212,4213],{},"name()",[382,4215,384],{},[382,4217,4218],{},"Read the configured name",[887,4220,4222],{"id":4221},"printed","Printed",[361,4224,4225,4235],{},[364,4226,4227],{},[367,4228,4229,4231,4233],{},[370,4230,448],{},[370,4232,451],{},[370,4234,454],{},[377,4236,4237,4247,4257,4267,4280],{},[367,4238,4239,4242,4244],{},[382,4240,4241],{},"toSysOut()",[382,4243,384],{},[382,4245,4246],{},"Default stdout",[367,4248,4249,4252,4254],{},[382,4250,4251],{},"toFile(filePath)",[382,4253,384],{},[382,4255,4256],{},"File output",[367,4258,4259,4262,4264],{},[382,4260,4261],{},"withLabel(label)",[382,4263,384],{},[382,4265,4266],{},"Prefix label",[367,4268,4269,4272,4274],{},[382,4270,4271],{},"withKeyValueMapper(mapper)",[382,4273,384],{},[382,4275,4276,4277],{},"Custom formatting; takes a KS ",[478,4278,4279],{},"KeyValueMapper\u003CK, V, String>",[367,4281,4282,4285,4287],{},[382,4283,4284],{},"withName(processorName)",[382,4286,384],{},[382,4288,4289],{},"Set processor name",[887,4291,3787],{"id":4292},"joined",[320,4294,4295,4298,4299,4302,4303,783,4305,4307],{},[478,4296,4297],{},"Joined\u003CK, VLeft, VRight>"," is the Kafka Streams generic form. Its serdes and grace period are ",[324,4300,4301],{},"advisory"," — stored and round-tripped for source compatibility, but StoatFlow resolves the effective serdes\u002Fgrace from the upstream ",[478,4304,3528],{},[478,4306,3778],{}," configuration.",[361,4309,4310,4320],{},[364,4311,4312],{},[367,4313,4314,4316,4318],{},[370,4315,448],{},[370,4317,451],{},[370,4319,454],{},[377,4321,4322,4330,4340,4350,4358,4368,4377,4385,4394,4402,4412],{},[367,4323,4324,4326,4328],{},[382,4325,3584],{},[382,4327,384],{},[382,4329],{},[367,4331,4332,4335,4337],{},[382,4333,4334],{},"create()",[382,4336,384],{},[382,4338,4339],{},"Create with defaults",[367,4341,4342,4345,4347],{},[382,4343,4344],{},"with(keySerde, valueSerde, otherValueSerde)",[382,4346,384],{},[382,4348,4349],{},"Static factory; serdes advisory",[367,4351,4352,4354,4356],{},[382,4353,3866],{},[382,4355,384],{},[382,4357],{},[367,4359,4360,4363,4365],{},[382,4361,4362],{},"withGracePeriod(duration)",[382,4364,384],{},[382,4366,4367],{},"Advisory grace period",[367,4369,4370,4372,4374],{},[382,4371,3875],{},[382,4373,384],{},[382,4375,4376],{},"Advisory",[367,4378,4379,4381,4383],{},[382,4380,3884],{},[382,4382,384],{},[382,4384,4376],{},[367,4386,4387,4390,4392],{},[382,4388,4389],{},"withOtherValueSerde(serde)",[382,4391,384],{},[382,4393,4376],{},[367,4395,4396,4398,4400],{},[382,4397,4213],{},[382,4399,384],{},[382,4401,4218],{},[367,4403,4404,4407,4409],{},[382,4405,4406],{},"gracePeriod()",[382,4408,384],{},[382,4410,4411],{},"Round-trips the advisory grace period",[367,4413,4414,4417,4419],{},[382,4415,4416],{},"keySerde() \u002F valueSerde() \u002F otherValueSerde()",[382,4418,384],{},[382,4420,4421],{},"Round-trip the advisory serdes",[887,4423,4425],{"id":4424},"tablejoined","TableJoined",[361,4427,4428,4438],{},[364,4429,4430],{},[367,4431,4432,4434,4436],{},[370,4433,448],{},[370,4435,451],{},[370,4437,454],{},[377,4439,4440,4448,4458,4468,4476,4486],{},[367,4441,4442,4444,4446],{},[382,4443,3584],{},[382,4445,384],{},[382,4447],{},[367,4449,4450,4453,4455],{},[382,4451,4452],{},"with()",[382,4454,384],{},[382,4456,4457],{},"Defaults",[367,4459,4460,4463,4465],{},[382,4461,4462],{},"with(partitioner, otherPartitioner)",[382,4464,384],{},[382,4466,4467],{},"Accepted no-op stub (partitioning is N\u002FA single-instance)",[367,4469,4470,4472,4474],{},[382,4471,3866],{},[382,4473,384],{},[382,4475],{},[367,4477,4478,4481,4483],{},[382,4479,4480],{},"withPartitioner()",[382,4482,384],{},[382,4484,4485],{},"Accepted no-op stub for KS source compatibility",[367,4487,4488,4491,4493],{},[382,4489,4490],{},"withOtherPartitioner()",[382,4492,384],{},[382,4494,4485],{},[887,4496,4498],{"id":4497},"joinwindows","JoinWindows",[361,4500,4501,4511],{},[364,4502,4503],{},[367,4504,4505,4507,4509],{},[370,4506,448],{},[370,4508,451],{},[370,4510,454],{},[377,4512,4513,4523,4533,4543,4553,4563,4573,4583],{},[367,4514,4515,4518,4520],{},[382,4516,4517],{},"of(timeDifference)",[382,4519,416],{},[382,4521,4522],{},"Deprecated; use ofTimeDifferenceWithNoGrace",[367,4524,4525,4528,4530],{},[382,4526,4527],{},"ofTimeDifferenceWithNoGrace(timeDifference)",[382,4529,384],{},[382,4531,4532],{},"Symmetric window, no grace",[367,4534,4535,4538,4540],{},[382,4536,4537],{},"ofTimeDifferenceAndGrace(timeDifference, grace)",[382,4539,384],{},[382,4541,4542],{},"Symmetric window with grace",[367,4544,4545,4548,4550],{},[382,4546,4547],{},"before(timeDifference)",[382,4549,384],{},[382,4551,4552],{},"Asymmetric window (look back)",[367,4554,4555,4558,4560],{},[382,4556,4557],{},"after(timeDifference)",[382,4559,384],{},[382,4561,4562],{},"Asymmetric window (look forward)",[367,4564,4565,4568,4570],{},[382,4566,4567],{},"grace(duration)",[382,4569,416],{},[382,4571,4572],{},"Deprecated; use ofTimeDifferenceAndGrace",[367,4574,4575,4578,4580],{},[382,4576,4577],{},"size()",[382,4579,384],{},[382,4581,4582],{},"Window size in ms",[367,4584,4585,4588,4590],{},[382,4586,4587],{},"gracePeriodMs()",[382,4589,384],{},[382,4591,4592],{},"Grace period in ms",[344,4594,4595],{"color":346,"icon":1571},[320,4596,4597,925,4600,4603,4604,925,4607,4610,4611,925,4614,4617,4618,4621,4622,4625],{},[478,4598,4599],{},"beforeMs",[478,4601,4602],{},"afterMs"," are exposed as read-only properties (",[478,4605,4606],{},"getBeforeMs()",[478,4608,4609],{},"getAfterMs()"," from Java; ",[478,4612,4613],{},"before",[478,4615,4616],{},"after"," return ",[478,4619,4620],{},"Duration","). A KS port that reads the public ",[478,4623,4624],{},"jw.beforeMs"," field replaces it with the accessor.",[887,4627,3790],{"id":4628},"streamjoined",[361,4630,4631,4641],{},[364,4632,4633],{},[367,4634,4635,4637,4639],{},[370,4636,448],{},[370,4638,451],{},[370,4640,454],{},[377,4642,4643,4652,4662,4670,4678,4687,4697,4707,4717,4727,4736,4746,4755,4765],{},[367,4644,4645,4647,4649],{},[382,4646,3584],{},[382,4648,384],{},[382,4650,4651],{},"Create with processor name",[367,4653,4654,4657,4659],{},[382,4655,4656],{},"with(keySerde, leftValueSerde, rightValueSerde)",[382,4658,384],{},[382,4660,4661],{},"Create with Serdes",[367,4663,4664,4666,4668],{},[382,4665,4334],{},[382,4667,384],{},[382,4669,4339],{},[367,4671,4672,4674,4676],{},[382,4673,3866],{},[382,4675,384],{},[382,4677,4289],{},[367,4679,4680,4682,4684],{},[382,4681,3875],{},[382,4683,384],{},[382,4685,4686],{},"Set key Serde",[367,4688,4689,4692,4694],{},[382,4690,4691],{},"withLeftValueSerde(serde)",[382,4693,384],{},[382,4695,4696],{},"Set left stream value Serde",[367,4698,4699,4702,4704],{},[382,4700,4701],{},"withRightValueSerde(serde)",[382,4703,384],{},[382,4705,4706],{},"Set right stream value Serde",[367,4708,4709,4712,4714],{},[382,4710,4711],{},"withThisStoreSupplier(storeSupplier)",[382,4713,384],{},[382,4715,4716],{},"Custom left window store",[367,4718,4719,4722,4724],{},[382,4720,4721],{},"withOtherStoreSupplier(storeSupplier)",[382,4723,384],{},[382,4725,4726],{},"Custom right window store",[367,4728,4729,4731,4733],{},[382,4730,4058],{},[382,4732,384],{},[382,4734,4735],{},"Enable changelog logging",[367,4737,4738,4741,4743],{},[382,4739,4740],{},"withLoggingEnabled(config)",[382,4742,384],{},[382,4744,4745],{},"Enable changelog logging with topic config",[367,4747,4748,4750,4752],{},[382,4749,4068],{},[382,4751,384],{},[382,4753,4754],{},"Disable changelog logging",[367,4756,4757,4760,4762],{},[382,4758,4759],{},"withDslStoreSuppliers(suppliers)",[382,4761,384],{},[382,4763,4764],{},"Both join stores use same type",[367,4766,4767,4770,4772],{},[382,4768,4769],{},"withStoreName(name)",[382,4771,384],{},[382,4773,4774],{},"Set base store name",[887,4776,3784],{"id":4777},"repartitioned",[361,4779,4780,4790],{},[364,4781,4782],{},[367,4783,4784,4786,4788],{},[370,4785,448],{},[370,4787,451],{},[370,4789,454],{},[377,4791,4792,4800,4809,4818,4826,4835,4845,4855,4864,4874,4883,4897],{},[367,4793,4794,4796,4798],{},[382,4795,3584],{},[382,4797,384],{},[382,4799],{},[367,4801,4802,4804,4806],{},[382,4803,3960],{},[382,4805,384],{},[382,4807,4808],{},"numPartitions = numLanes",[367,4810,4811,4814,4816],{},[382,4812,4813],{},"withStreamPartitioner(partitioner)",[382,4815,384],{},[382,4817],{},[367,4819,4820,4822,4824],{},[382,4821,3866],{},[382,4823,384],{},[382,4825],{},[367,4827,4828,4830,4832],{},[382,4829,3547],{},[382,4831,384],{},[382,4833,4834],{},"keySerde used for lane assignment hashing",[367,4836,4837,4840,4842],{},[382,4838,4839],{},"withKeySerde()",[382,4841,384],{},[382,4843,4844],{},"Used for lane assignment hashing at sub-topology boundary",[367,4846,4847,4850,4852],{},[382,4848,4849],{},"withValueSerde()",[382,4851,384],{},[382,4853,4854],{},"Reserved for future use",[367,4856,4857,4859,4861],{},[382,4858,3647],{},[382,4860,432],{},[382,4862,4863],{},"Sets the repartition sub-topology's lane count",[367,4865,4866,4869,4871],{},[382,4867,4868],{},"numberOfLanes(int)",[382,4870,432],{},[382,4872,4873],{},"Static factory; sets the lane count",[367,4875,4876,4878,4880],{},[382,4877,3657],{},[382,4879,432],{},[382,4881,4882],{},"Sets the per-lane queue capacity",[367,4884,4885,4888,4890],{},[382,4886,4887],{},"withNumberOfPartitions()",[382,4889,432],{},[382,4891,4892,4893,4896],{},"KS-compat alias of ",[478,4894,4895],{},"withNumberOfLanes"," (sets the lane count)",[367,4898,4899,4902,4904],{},[382,4900,4901],{},"numberOfPartitions(int)",[382,4903,432],{},[382,4905,4906,4907],{},"KS-compat static-factory alias of ",[478,4908,4909],{},"numberOfLanes",[887,4911,4913],{"id":4912},"emitstrategy","EmitStrategy",[361,4915,4916,4926],{},[364,4917,4918],{},[367,4919,4920,4922,4924],{},[370,4921,448],{},[370,4923,451],{},[370,4925,454],{},[377,4927,4928,4938],{},[367,4929,4930,4933,4935],{},[382,4931,4932],{},"onWindowUpdate()",[382,4934,384],{},[382,4936,4937],{},"Default; emit on every update",[367,4939,4940,4943,4945],{},[382,4941,4942],{},"onWindowClose()",[382,4944,384],{},[382,4946,4947],{},"Emit only when window closes; driven by the global event-time watermark",[344,4949,4950],{"color":346,"icon":1571},[320,4951,4952,4955,4956,4959,4960,331],{},[478,4953,4954],{},"OnWindowClose"," emission is ",[324,4957,4958],{},"watermark-driven",": a window's final result is emitted when the global watermark passes the window end plus any configured grace period. See ",[329,4961,67],{"href":68},[887,4963,4965],{"id":4964},"suppressed","Suppressed",[361,4967,4968,4978],{},[364,4969,4970],{},[367,4971,4972,4974,4976],{},[370,4973,448],{},[370,4975,451],{},[370,4977,454],{},[377,4979,4980,4994,5004],{},[367,4981,4982,4985,4987],{},[382,4983,4984],{},"untilWindowCloses(bufferConfig)",[382,4986,384],{},[382,4988,4989,4990,4993],{},"For windowed KTables; requires a ",[478,4991,4992],{},"StrictBufferConfig"," (KS parity); flush driven by the global event-time watermark",[367,4995,4996,4999,5001],{},[382,4997,4998],{},"untilTimeLimit(duration, bufferConfig)",[382,5000,384],{},[382,5002,5003],{},"Rate-limits per-key updates; flush driven by the global event-time watermark",[367,5005,5006,5008,5010],{},[382,5007,3866],{},[382,5009,384],{},[382,5011,3608,5012,5015],{},[478,5013,5014],{},"NamedOperation","; names the suppression node",[344,5017,5018],{"color":346,"icon":1571},[320,5019,5020,5021,5024,5025,5028,5029,5032,5033,331],{},"Suppression buffers are flushed on ",[324,5022,5023],{},"watermark advancement"," — ",[478,5026,5027],{},"untilWindowCloses"," releases a key's final value once the window closes, and ",[478,5030,5031],{},"untilTimeLimit"," releases the latest buffered value once the per-key time limit elapses in event time. See ",[329,5034,67],{"href":68},[344,5036,5037],{"color":346,"icon":1571},[320,5038,5039,5042,5043,5046],{},[324,5040,5041],{},"KIP-914:"," ",[478,5044,5045],{},"suppress()"," throws a validation exception for tables backed by versioned stores — their temporal semantics conflict with suppression.",[887,5048,5050],{"id":5049},"bufferconfig","BufferConfig",[361,5052,5053,5063],{},[364,5054,5055],{},[367,5056,5057,5059,5061],{},[370,5058,448],{},[370,5060,451],{},[370,5062,454],{},[377,5064,5065,5075,5085,5099,5109,5123,5133,5143,5153],{},[367,5066,5067,5070,5072],{},[382,5068,5069],{},"unbounded()",[382,5071,384],{},[382,5073,5074],{},"No limits (use with caution)",[367,5076,5077,5080,5082],{},[382,5078,5079],{},"maxRecords(count)",[382,5081,384],{},[382,5083,5084],{},"Bounded by record count",[367,5086,5087,5090,5092],{},[382,5088,5089],{},"maxBytes(bytes)",[382,5091,392],{},[382,5093,5094,5095,5098],{},"Accepted so KS code compiles, but ",[324,5096,5097],{},"throws"," at build time — in-memory object buffers have no byte size",[367,5100,5101,5104,5106],{},[382,5102,5103],{},"withMaxRecords(count)",[382,5105,384],{},[382,5107,5108],{},"Fluent record bound",[367,5110,5111,5114,5116],{},[382,5112,5113],{},"withMaxBytes(bytes)",[382,5115,392],{},[382,5117,5118,5119,5122],{},"Same as ",[478,5120,5121],{},"maxBytes"," — throws",[367,5124,5125,5128,5130],{},[382,5126,5127],{},"withNoBound()",[382,5129,384],{},[382,5131,5132],{},"Remove bounds",[367,5134,5135,5138,5140],{},[382,5136,5137],{},"emitEarlyWhenFull()",[382,5139,384],{},[382,5141,5142],{},"Emit instead of evict on overflow",[367,5144,5145,5148,5150],{},[382,5146,5147],{},"shutDownWhenFull()",[382,5149,384],{},[382,5151,5152],{},"Shut down on buffer overflow",[367,5154,5155,5158,5160],{},[382,5156,5157],{},"withLoggingEnabled(config) \u002F withLoggingDisabled()",[382,5159,384],{},[382,5161,5162],{},"Changelog control for the suppress buffer",[887,5164,5166],{"id":5165},"windowedserdes","WindowedSerdes",[361,5168,5169,5179],{},[364,5170,5171],{},[367,5172,5173,5175,5177],{},[370,5174,448],{},[370,5176,451],{},[370,5178,454],{},[377,5180,5181,5199,5211,5224,5236,5246],{},[367,5182,5183,5186,5188],{},[382,5184,5185],{},"timeWindowedSerdeFrom(...)",[382,5187,392],{},[382,5189,5190,5191,5194,5195,5198],{},"Takes ",[478,5192,5193],{},"Serde\u003CT>"," instead of ",[478,5196,5197],{},"Class\u003CT>"," (no serde registry)",[367,5200,5201,5204,5206],{},[382,5202,5203],{},"timeWindowedSerdeFrom(..., windowSize)",[382,5205,392],{},[382,5207,5190,5208,5210],{},[478,5209,5193],{}," only; window size encoded in serialized bytes",[367,5212,5213,5216,5218],{},[382,5214,5215],{},"sessionWindowedSerdeFrom(...)",[382,5217,392],{},[382,5219,5190,5220,5194,5222],{},[478,5221,5193],{},[478,5223,5197],{},[367,5225,5226,5229,5231],{},[382,5227,5228],{},"TimeWindowedSerde(inner)",[382,5230,384],{},[382,5232,5233],{},[478,5234,5235],{},"WindowedSerdes.TimeWindowedSerde(serde)",[367,5237,5238,5241,5243],{},[382,5239,5240],{},"TimeWindowedSerde(inner, windowSize)",[382,5242,392],{},[382,5244,5245],{},"Window size not required (encoded in serialized bytes)",[367,5247,5248,5251,5253],{},[382,5249,5250],{},"SessionWindowedSerde(inner)",[382,5252,384],{},[382,5254,5255],{},[478,5256,5257],{},"WindowedSerdes.SessionWindowedSerde(serde)",[344,5259,5261],{"color":5260,"icon":80},"warning",[320,5262,5263,5264,5266,5267,5269,5270,5273],{},"StoatFlow's factory methods take ",[478,5265,5193],{}," rather than KS's ",[478,5268,5197],{}," (there is no serde registry), and omit the window-size parameter (window bounds are encoded in the serialized bytes). ",[478,5271,5272],{},"TimeWindowedSerde.forChangelog()"," is not needed — StoatFlow uses identical encoding for client and changelog.",[356,5275,100],{"id":5276},"state-stores",[887,5278,5280],{"id":5279},"record-types-iterators","Record types & iterators",[361,5282,5283,5293],{},[364,5284,5285],{},[367,5286,5287,5289,5291],{},[370,5288,2755],{},[370,5290,451],{},[370,5292,454],{},[377,5294,5295,5308,5318,5335],{},[367,5296,5297,5300,5302],{},[382,5298,5299],{},"Windowed\u003CK>",[382,5301,384],{},[382,5303,5304,5305,1246],{},"Windowed-key wrapper (key + ",[478,5306,5307],{},"Window",[367,5309,5310,5313,5315],{},[382,5311,5312],{},"ValueAndTimestamp\u003CV>",[382,5314,384],{},[382,5316,5317],{},"Timestamped-store value wrapper (KIP-258)",[367,5319,5320,5323,5325],{},[382,5321,5322],{},"VersionedRecord\u003CV>",[382,5324,384],{},[382,5326,5327,5328,5331,5332],{},"Versioned-store record; ",[478,5329,5330],{},"validTo()"," returns ",[478,5333,5334],{},"Optional\u003CLong>",[367,5336,5337,5340,5342],{},[382,5338,5339],{},"KeyValueIterator \u002F WindowStoreIterator",[382,5341,384],{},[382,5343,5344],{},"Closeable iterators for range\u002Fscan queries",[887,5346,5348],{"id":5347},"state-store-metrics","State store metrics",[361,5350,5351,5362],{},[364,5352,5353],{},[367,5354,5355,5358,5360],{},[370,5356,5357],{},"Metric",[370,5359,451],{},[370,5361,454],{},[377,5363,5364],{},[367,5365,5366,5369,5371],{},[382,5367,5368],{},"num-keys (KIP-1250)",[382,5370,384],{},[382,5372,5373],{},"Entry-count gauge for in-memory KV\u002Fwindow\u002Fsession stores",[887,5375,5377],{"id":5376},"keyvaluestore","KeyValueStore",[361,5379,5380,5390],{},[364,5381,5382],{},[367,5383,5384,5386,5388],{},[370,5385,448],{},[370,5387,451],{},[370,5389,454],{},[377,5391,5392,5401,5410,5419,5428,5437,5447,5457,5467,5476,5485,5494,5503],{},[367,5393,5394,5397,5399],{},[382,5395,5396],{},"get(key)",[382,5398,384],{},[382,5400],{},[367,5402,5403,5406,5408],{},[382,5404,5405],{},"put(key, value)",[382,5407,384],{},[382,5409],{},[367,5411,5412,5415,5417],{},[382,5413,5414],{},"putIfAbsent(key, value)",[382,5416,384],{},[382,5418],{},[367,5420,5421,5424,5426],{},[382,5422,5423],{},"putAll(entries)",[382,5425,384],{},[382,5427],{},[367,5429,5430,5433,5435],{},[382,5431,5432],{},"delete(key)",[382,5434,384],{},[382,5436],{},[367,5438,5439,5442,5444],{},[382,5440,5441],{},"compute(key, remappingFunction)",[382,5443,424],{},[382,5445,5446],{},"Atomic read-compute-write; Kotlin lambda + Java BiFunction overloads",[367,5448,5449,5452,5454],{},[382,5450,5451],{},"merge(key, value, remappingFunction)",[382,5453,424],{},[382,5455,5456],{},"Atomic merge; Kotlin lambda + Java BiFunction overloads",[367,5458,5459,5462,5464],{},[382,5460,5461],{},"all()",[382,5463,384],{},[382,5465,5466],{},"Read-your-writes semantics",[367,5468,5469,5472,5474],{},[382,5470,5471],{},"range(from, to)",[382,5473,384],{},[382,5475,5466],{},[367,5477,5478,5481,5483],{},[382,5479,5480],{},"reverseAll()",[382,5482,384],{},[382,5484,5466],{},[367,5486,5487,5490,5492],{},[382,5488,5489],{},"reverseRange(from, to)",[382,5491,384],{},[382,5493,5466],{},[367,5495,5496,5499,5501],{},[382,5497,5498],{},"approximateNumEntries()",[382,5500,384],{},[382,5502],{},[367,5504,5505,5508,5510],{},[382,5506,5507],{},"prefixScan()",[382,5509,384],{},[382,5511,5512],{},"KIP-614; read-your-writes semantics",[887,5514,5516],{"id":5515},"readonlykeyvaluestore","ReadOnlyKeyValueStore",[361,5518,5519,5529],{},[364,5520,5521],{},[367,5522,5523,5525,5527],{},[370,5524,448],{},[370,5526,451],{},[370,5528,454],{},[377,5530,5531,5539,5549,5557,5565,5573,5581,5589],{},[367,5532,5533,5535,5537],{},[382,5534,5396],{},[382,5536,384],{},[382,5538],{},[367,5540,5541,5544,5546],{},[382,5542,5543],{},"containsKey(key)",[382,5545,424],{},[382,5547,5548],{},"StoatFlow extension; bloom filter optimization for RocksDB",[367,5550,5551,5553,5555],{},[382,5552,5461],{},[382,5554,384],{},[382,5556],{},[367,5558,5559,5561,5563],{},[382,5560,5471],{},[382,5562,384],{},[382,5564],{},[367,5566,5567,5569,5571],{},[382,5568,5480],{},[382,5570,384],{},[382,5572],{},[367,5574,5575,5577,5579],{},[382,5576,5489],{},[382,5578,384],{},[382,5580],{},[367,5582,5583,5585,5587],{},[382,5584,5498],{},[382,5586,384],{},[382,5588],{},[367,5590,5591,5594,5596],{},[382,5592,5593],{},"prefixScan(prefix, serializer)",[382,5595,384],{},[382,5597,5598],{},"KIP-614",[887,5600,5602],{"id":5601},"windowstore","WindowStore",[320,5604,5605,5606,5609],{},"Key range queries require ",[478,5607,5608],{},"K : Comparable\u003CK>",". All Instant variants delegate to the Long variants.",[361,5611,5612,5622],{},[364,5613,5614],{},[367,5615,5616,5618,5620],{},[370,5617,448],{},[370,5619,451],{},[370,5621,454],{},[377,5623,5624,5633,5643,5653,5663,5673,5683,5693,5703,5712,5722,5732,5742,5752],{},[367,5625,5626,5629,5631],{},[382,5627,5628],{},"put(key, value, windowStartTime)",[382,5630,384],{},[382,5632],{},[367,5634,5635,5638,5640],{},[382,5636,5637],{},"fetch(key, windowStartTime)",[382,5639,384],{},[382,5641,5642],{},"Point lookup",[367,5644,5645,5648,5650],{},[382,5646,5647],{},"fetch(key, timeFrom, timeTo)",[382,5649,384],{},[382,5651,5652],{},"Single key time range; Long and Instant variants",[367,5654,5655,5658,5660],{},[382,5656,5657],{},"backwardFetch(key, timeFrom, timeTo)",[382,5659,384],{},[382,5661,5662],{},"Reverse iteration; Long and Instant variants",[367,5664,5665,5668,5670],{},[382,5666,5667],{},"fetch(keyFrom, keyTo, timeFrom, timeTo)",[382,5669,384],{},[382,5671,5672],{},"Key range + time range; Long and Instant variants",[367,5674,5675,5678,5680],{},[382,5676,5677],{},"backwardFetch(keyFrom, keyTo, timeFrom, timeTo)",[382,5679,384],{},[382,5681,5682],{},"Reverse key range; Long and Instant variants",[367,5684,5685,5688,5690],{},[382,5686,5687],{},"fetchAll(timeFrom, timeTo)",[382,5689,384],{},[382,5691,5692],{},"All keys time range; Long and Instant variants",[367,5694,5695,5698,5700],{},[382,5696,5697],{},"backwardFetchAll(timeFrom, timeTo)",[382,5699,384],{},[382,5701,5702],{},"Reverse all keys; Long and Instant variants",[367,5704,5705,5707,5709],{},[382,5706,5461],{},[382,5708,384],{},[382,5710,5711],{},"All entries",[367,5713,5714,5717,5719],{},[382,5715,5716],{},"backwardAll()",[382,5718,384],{},[382,5720,5721],{},"Reverse iteration",[367,5723,5724,5727,5729],{},[382,5725,5726],{},"windowSizeMs",[382,5728,424],{},[382,5730,5731],{},"StoatFlow extension for window size access",[367,5733,5734,5737,5739],{},[382,5735,5736],{},"retentionMs",[382,5738,424],{},[382,5740,5741],{},"StoatFlow extension for retention access",[367,5743,5744,5747,5749],{},[382,5745,5746],{},"expireWindows(watermark)",[382,5748,424],{},[382,5750,5751],{},"StoatFlow extension for manual expiration",[367,5753,5754,5756,5758],{},[382,5755,5498],{},[382,5757,424],{},[382,5759,5760],{},"StoatFlow extension for entry count",[887,5762,5764],{"id":5763},"readonlywindowstore","ReadOnlyWindowStore",[361,5766,5767,5777],{},[364,5768,5769],{},[367,5770,5771,5773,5775],{},[370,5772,448],{},[370,5774,451],{},[370,5776,454],{},[377,5778,5779,5789],{},[367,5780,5781,5784,5786],{},[382,5782,5783],{},"All query methods from WindowStore",[382,5785,384],{},[382,5787,5788],{},"16 query methods total",[367,5790,5791,5794,5796],{},[382,5792,5793],{},"containsKey(key, windowStartTime)",[382,5795,424],{},[382,5797,5798],{},"StoatFlow extension; Long and Instant variants",[887,5800,5802],{"id":5801},"sessionstore","SessionStore",[361,5804,5805,5815],{},[364,5806,5807],{},[367,5808,5809,5811,5813],{},[370,5810,448],{},[370,5812,451],{},[370,5814,454],{},[377,5816,5817,5827,5836,5846,5855,5864,5874,5883,5893,5903,5913,5922,5932,5941],{},[367,5818,5819,5822,5824],{},[382,5820,5821],{},"put(sessionKey, aggregate)",[382,5823,384],{},[382,5825,5826],{},"Windowed key",[367,5828,5829,5832,5834],{},[382,5830,5831],{},"remove(sessionKey)",[382,5833,384],{},[382,5835,5826],{},[367,5837,5838,5841,5843],{},[382,5839,5840],{},"fetchSession(key, startTime, endTime)",[382,5842,384],{},[382,5844,5845],{},"Long and Instant variants",[367,5847,5848,5851,5853],{},[382,5849,5850],{},"findSessions(key, earliestEndTime, latestStartTime)",[382,5852,384],{},[382,5854,5845],{},[367,5856,5857,5860,5862],{},[382,5858,5859],{},"backwardFindSessions(key, earliestEndTime, latestStartTime)",[382,5861,384],{},[382,5863,5845],{},[367,5865,5866,5869,5871],{},[382,5867,5868],{},"findSessions(keyFrom, keyTo, earliestEndTime, latestStartTime)",[382,5870,384],{},[382,5872,5873],{},"Key range; Long and Instant variants",[367,5875,5876,5879,5881],{},[382,5877,5878],{},"backwardFindSessions(keyFrom, keyTo, earliestEndTime, latestStartTime)",[382,5880,384],{},[382,5882,5873],{},[367,5884,5885,5888,5890],{},[382,5886,5887],{},"fetch(key)",[382,5889,384],{},[382,5891,5892],{},"All sessions for single key",[367,5894,5895,5898,5900],{},[382,5896,5897],{},"backwardFetch(key)",[382,5899,384],{},[382,5901,5902],{},"Reverse order",[367,5904,5905,5908,5910],{},[382,5906,5907],{},"fetch(keyFrom, keyTo)",[382,5909,384],{},[382,5911,5912],{},"Key range queries",[367,5914,5915,5918,5920],{},[382,5916,5917],{},"backwardFetch(keyFrom, keyTo)",[382,5919,384],{},[382,5921,5902],{},[367,5923,5924,5927,5929],{},[382,5925,5926],{},"findAll()",[382,5928,424],{},[382,5930,5931],{},"StoatFlow extension",[367,5933,5934,5937,5939],{},[382,5935,5936],{},"expireSessions(watermark)",[382,5938,424],{},[382,5940,5931],{},[367,5942,5943,5945,5947],{},[382,5944,5498],{},[382,5946,424],{},[382,5948,5931],{},[887,5950,5952],{"id":5951},"readonlysessionstore","ReadOnlySessionStore",[361,5954,5955,5965],{},[364,5956,5957],{},[367,5958,5959,5961,5963],{},[370,5960,448],{},[370,5962,451],{},[370,5964,454],{},[377,5966,5967,5977],{},[367,5968,5969,5972,5974],{},[382,5970,5971],{},"All query methods from SessionStore",[382,5973,384],{},[382,5975,5976],{},"Query methods for IQ access",[367,5978,5979,5982,5984],{},[382,5980,5981],{},"containsSession(key, startTime, endTime)",[382,5983,424],{},[382,5985,5798],{},[887,5987,5989],{"id":5988},"stores-factory","Stores factory",[320,5991,5992,5993,5996,5997,6000,6001,6004,6005,6007,6008,6010,6011,783,6014,6017,6018,6020],{},"StoatFlow's suppliers implement the KS ",[478,5994,5995],{},"*BytesStoreSupplier"," interfaces and the ",[478,5998,5999],{},"*StoreBuilder(...)"," factories return a KS ",[478,6002,6003],{},"StoreBuilder\u003CT>",". Some signatures take a ",[478,6006,5193],{}," where KS takes ",[478,6009,5197],{}," (no serde registry); ",[478,6012,6013],{},"StoreBuilder.withCaching*",[478,6015,6016],{},"withLogging*"," are honored, and ",[478,6019,573],{}," throws (StoatFlow builds stores via the registry).",[361,6022,6023,6033],{},[364,6024,6025],{},[367,6026,6027,6029,6031],{},[370,6028,448],{},[370,6030,451],{},[370,6032,454],{},[377,6034,6035,6045,6055,6065,6075,6085,6095,6105,6122,6132,6142,6152,6166,6176,6186,6199,6209,6220,6229,6240,6250,6264],{},[367,6036,6037,6040,6042],{},[382,6038,6039],{},"persistentKeyValueStore(name)",[382,6041,384],{},[382,6043,6044],{},"RocksDB key-value store",[367,6046,6047,6050,6052],{},[382,6048,6049],{},"inMemoryKeyValueStore(name)",[382,6051,384],{},[382,6053,6054],{},"In-memory key-value store",[367,6056,6057,6060,6062],{},[382,6058,6059],{},"persistentWindowStore(name, retention, windowSize, retainDuplicates)",[382,6061,384],{},[382,6063,6064],{},"RocksDB window store",[367,6066,6067,6070,6072],{},[382,6068,6069],{},"inMemoryWindowStore(name, retention, windowSize, retainDuplicates)",[382,6071,384],{},[382,6073,6074],{},"In-memory window store",[367,6076,6077,6080,6082],{},[382,6078,6079],{},"persistentSessionStore(name, retentionPeriod)",[382,6081,384],{},[382,6083,6084],{},"RocksDB session store",[367,6086,6087,6090,6092],{},[382,6088,6089],{},"inMemorySessionStore(name, retentionPeriod)",[382,6091,384],{},[382,6093,6094],{},"In-memory session store",[367,6096,6097,6100,6102],{},[382,6098,6099],{},"persistentTimestampedKeyValueStore(name)",[382,6101,384],{},[382,6103,6104],{},"Timestamped KV store (KIP-258)",[367,6106,6107,6113,6115],{},[382,6108,6109,6110,1246],{},"persistentTimestampedWindowStore(name, retention, windowSize",[2241,6111,6112],{},", retainDuplicates",[382,6114,384],{},[382,6116,6117,6118,6121],{},"Timestamped window store (KIP-258); 4-arg ",[478,6119,6120],{},"retainDuplicates"," overload supported",[367,6123,6124,6127,6129],{},[382,6125,6126],{},"inMemoryTimestampedKeyValueStore(name)",[382,6128,384],{},[382,6130,6131],{},"In-memory timestamped KV store (KIP-258)",[367,6133,6134,6137,6139],{},[382,6135,6136],{},"inMemoryTimestampedWindowStore(name, ...)",[382,6138,384],{},[382,6140,6141],{},"In-memory timestamped window store (KIP-258)",[367,6143,6144,6147,6149],{},[382,6145,6146],{},"persistentVersionedKeyValueStore(name, historyRetention)",[382,6148,384],{},[382,6150,6151],{},"Versioned store — RocksDB (KIP-889)",[367,6153,6154,6157,6159],{},[382,6155,6156],{},"persistentVersionedKeyValueStore(name, historyRetention, segmentInterval)",[382,6158,384],{},[382,6160,6161,6162,6165],{},"3-arg KS overload; ",[478,6163,6164],{},"segmentInterval"," accepted but ignored (not segmented) — logs a warning",[367,6167,6168,6171,6173],{},[382,6169,6170],{},"inMemoryVersionedKeyValueStore(name, historyRetention)",[382,6172,384],{},[382,6174,6175],{},"Versioned store — in-memory (KIP-889)",[367,6177,6178,6181,6183],{},[382,6179,6180],{},"lruMap(name, maxCacheSize)",[382,6182,384],{},[382,6184,6185],{},"LRU cache store with bounded entries",[367,6187,6188,6191,6193],{},[382,6189,6190],{},"keyValueStoreBuilder(supplier, keySerde, valueSerde)",[382,6192,384],{},[382,6194,6195,6196],{},"Returns a KS ",[478,6197,6198],{},"StoreBuilder",[367,6200,6201,6204,6206],{},[382,6202,6203],{},"timestampedKeyValueStoreBuilder(supplier, keySerde, valueSerde)",[382,6205,384],{},[382,6207,6208],{},"KIP-258",[367,6210,6211,6214,6216],{},[382,6212,6213],{},"windowStoreBuilder(supplier, keySerde, valueSerde)",[382,6215,384],{},[382,6217,6195,6218],{},[478,6219,6198],{},[367,6221,6222,6225,6227],{},[382,6223,6224],{},"timestampedWindowStoreBuilder(supplier, keySerde, valueSerde)",[382,6226,384],{},[382,6228,6208],{},[367,6230,6231,6234,6236],{},[382,6232,6233],{},"sessionStoreBuilder(supplier, keySerde, aggSerde)",[382,6235,384],{},[382,6237,6195,6238],{},[478,6239,6198],{},[367,6241,6242,6245,6247],{},[382,6243,6244],{},"versionedKeyValueStoreBuilder(supplier, keySerde, valueSerde)",[382,6246,384],{},[382,6248,6249],{},"KIP-889",[367,6251,6252,6255,6257],{},[382,6253,6254],{},"timestamped{KeyValue,Window} \u002F sessionStoreWithHeadersBuilder(...)",[382,6256,384],{},[382,6258,6259,6260,6263],{},"Headers-aware builders (KIP-1271); pass a ",[478,6261,6262],{},"*WithHeaders"," supplier",[367,6265,6266,6269,6271],{},[382,6267,6268],{},"KeyValue\u002FWindow\u002FSession\u002FVersionedBytesStoreSupplier, StoreBuilder",[382,6270,384],{},[382,6272,6273],{},"KS supplier\u002Fbuilder interfaces are present",[887,6275,6277],{"id":6276},"keylockmanager-stoatflow-extension","KeyLockManager (StoatFlow extension)",[320,6279,6280],{},"Striped lock utility for multi-key atomic sections in user-defined Processors. Not in Kafka Streams.",[361,6282,6283,6293],{},[364,6284,6285],{},[367,6286,6287,6289,6291],{},[370,6288,448],{},[370,6290,451],{},[370,6292,454],{},[377,6294,6295,6305],{},[367,6296,6297,6300,6302],{},[382,6298,6299],{},"withLock(key, block)",[382,6301,424],{},[382,6303,6304],{},"Single-key lock scope",[367,6306,6307,6310,6312],{},[382,6308,6309],{},"withLocks(keys, block)",[382,6311,424],{},[382,6313,6314],{},"Multi-key lock scope with deadlock-free ordering",[356,6316,6318],{"id":6317},"record-headers-in-state-stores-kip-1271-kip-1285","Record headers in state stores (KIP-1271 \u002F KIP-1285)",[320,6320,6321,6322,6325],{},"Opt-in persistence of a record's ",[478,6323,6324],{},"Headers"," alongside key\u002Fvalue, across the timestamped KV, versioned, timestamped-window, and session store families.",[361,6327,6328,6339],{},[364,6329,6330],{},[367,6331,6332,6335,6337],{},[370,6333,6334],{},"Surface",[370,6336,451],{},[370,6338,454],{},[377,6340,6341,6351,6361,6371,6381,6391],{},[367,6342,6343,6346,6348],{},[382,6344,6345],{},"Materialized.withRecordHeaders()",[382,6347,432],{},[382,6349,6350],{},"Per-store opt-in (DSL)",[367,6352,6353,6356,6358],{},[382,6354,6355],{},"dsl.store.format = HEADERS",[382,6357,384],{},[382,6359,6360],{},"Global default to headers-aware stores",[367,6362,6363,6366,6368],{},[382,6364,6365],{},"Stores.*WithHeaders(...) suppliers + *WithHeadersBuilder(...)",[382,6367,384],{},[382,6369,6370],{},"Processor-API headers stores (all four families)",[367,6372,6373,6376,6378],{},[382,6374,6375],{},"QueryableStoreTypes.*WithHeaders()",[382,6377,384],{},[382,6379,6380],{},"Read stored headers back via IQ",[367,6382,6383,6386,6388],{},[382,6384,6385],{},"In-place upgrade (existing store → headers-aware)",[382,6387,384],{},[382,6389,6390],{},"Flip on, restart — no wipe, no changelog replay",[367,6392,6393,6396,6399],{},[382,6394,6395],{},"StreamJoined headers",[382,6397,6398],{},"❌ (matches KS)",[382,6400,6401],{},"KS does not persist headers on join buffers",[356,6403,6405],{"id":6404},"interactive-queries","Interactive Queries",[887,6407,6409],{"id":6408},"stoatflow-entry-point-methods","StoatFlow (entry point) methods",[361,6411,6412,6422],{},[364,6413,6414],{},[367,6415,6416,6418,6420],{},[370,6417,448],{},[370,6419,451],{},[370,6421,454],{},[377,6423,6424,6434,6444,6458,6468,6478,6498,6508,6518,6528],{},[367,6425,6426,6429,6431],{},[382,6427,6428],{},"store(StoreQueryParameters)",[382,6430,384],{},[382,6432,6433],{},"Returns read-only store view",[367,6435,6436,6439,6441],{},[382,6437,6438],{},"storeNames()",[382,6440,384],{},[382,6442,6443],{},"List available store names",[367,6445,6446,6449,6451],{},[382,6447,6448],{},"queryMetadataForKey(store, key, serializer)",[382,6450,384],{},[382,6452,6453,6454,6457],{},"Returns ",[478,6455,6456],{},"KeyQueryMetadata"," — single-instance: the local host, no standbys, the key's faithful Kafka partition",[367,6459,6460,6463,6465],{},[382,6461,6462],{},"streamsMetadataForStore(store)",[382,6464,384],{},[382,6466,6467],{},"The single local host materializing the store",[367,6469,6470,6473,6475],{},[382,6471,6472],{},"metadataForAllStreamsClients()",[382,6474,384],{},[382,6476,6477],{},"The one local instance",[367,6479,6480,6483,6485],{},[382,6481,6482],{},"setUncaughtExceptionHandler(handler)",[382,6484,384],{},[382,6486,3608,6487,6490,6491,6494,6495,1246],{},[478,6488,6489],{},"StreamsUncaughtExceptionHandler","; every response shuts the instance down (",[478,6492,6493],{},"REPLACE_THREAD"," ≡ ",[478,6496,6497],{},"SHUTDOWN_APPLICATION",[367,6499,6500,6503,6505],{},[382,6501,6502],{},"pause()",[382,6504,424],{},[382,6506,6507],{},"Pause processing with drain semantics",[367,6509,6510,6513,6515],{},[382,6511,6512],{},"unpause()",[382,6514,424],{},[382,6516,6517],{},"Resume processing after pause",[367,6519,6520,6523,6525],{},[382,6521,6522],{},"awaitState(state, timeout)",[382,6524,424],{},[382,6526,6527],{},"Wait for target state with timeout",[367,6529,6530,6533,6535],{},[382,6531,6532],{},"stateTransitionHistory()",[382,6534,424],{},[382,6536,6537],{},"Recent state transitions with timestamps",[887,6539,6541],{"id":6540},"storequeryparameters","StoreQueryParameters",[361,6543,6544,6554],{},[364,6545,6546],{},[367,6547,6548,6550,6552],{},[370,6549,448],{},[370,6551,451],{},[370,6553,454],{},[377,6555,6556,6566,6576],{},[367,6557,6558,6561,6563],{},[382,6559,6560],{},"fromNameAndType(name, type)",[382,6562,384],{},[382,6564,6565],{},"Factory method",[367,6567,6568,6571,6573],{},[382,6569,6570],{},"enableStaleStores()",[382,6572,384],{},[382,6574,6575],{},"Allow queries during RESTORING",[367,6577,6578,6581,6583],{},[382,6579,6580],{},"withPartition(partition)",[382,6582,408],{},[382,6584,6585],{},"N\u002FA for single-instance",[887,6587,6589],{"id":6588},"queryablestoretypes","QueryableStoreTypes",[361,6591,6592,6602],{},[364,6593,6594],{},[367,6595,6596,6598,6600],{},[370,6597,448],{},[370,6599,451],{},[370,6601,454],{},[377,6603,6604,6614,6624,6634,6644,6654],{},[367,6605,6606,6609,6611],{},[382,6607,6608],{},"keyValueStore()",[382,6610,384],{},[382,6612,6613],{},"Returns ReadOnlyKeyValueStore",[367,6615,6616,6619,6621],{},[382,6617,6618],{},"windowStore()",[382,6620,384],{},[382,6622,6623],{},"Returns ReadOnlyWindowStore",[367,6625,6626,6629,6631],{},[382,6627,6628],{},"sessionStore()",[382,6630,384],{},[382,6632,6633],{},"Returns ReadOnlySessionStore",[367,6635,6636,6639,6641],{},[382,6637,6638],{},"timestampedKeyValueStore()",[382,6640,384],{},[382,6642,6643],{},"Returns ReadOnlyKeyValueStore\u003CK, ValueAndTimestamp\u003CV>> (KIP-258)",[367,6645,6646,6649,6651],{},[382,6647,6648],{},"timestampedWindowStore()",[382,6650,384],{},[382,6652,6653],{},"Returns ReadOnlyWindowStore\u003CK, ValueAndTimestamp\u003CV>> (KIP-258)",[367,6655,6656,6659,6661],{},[382,6657,6658],{},"versionedKeyValueStore()",[382,6660,384],{},[382,6662,6663],{},"Returns ReadOnlyVersionedKeyValueStore\u003CK, V> (KIP-889)",[344,6665,6666],{"color":346,"icon":1571},[320,6667,6668,6669,6672],{},"The global state model eliminates partition routing — all state is locally accessible from a single process, so ",[478,6670,6671],{},"withPartition()"," and inter-instance RPC are unnecessary.",[887,6674,6676],{"id":6675},"iq-metadata-single-instance-always-local","IQ metadata (single-instance: always local)",[320,6678,6679,6680,6683],{},"Kafka Streams' host\u002Fpartition-distribution metadata types exist so cross-instance \"find the host, then query\" code compiles ",[324,6681,6682],{},"and runs",". Under StoatFlow's single-instance model the answer is always \"this host, locally.\"",[361,6685,6686,6696],{},[364,6687,6688],{},[367,6689,6690,6692,6694],{},[370,6691,2755],{},[370,6693,451],{},[370,6695,454],{},[377,6697,6698,6716,6735],{},[367,6699,6700,6703,6705],{},[382,6701,6702],{},"HostInfo(host, port)",[382,6704,384],{},[382,6706,6707,6708,6711,6712,6715],{},"The local host; sourced from ",[478,6709,6710],{},"application.server"," (synthetic ",[478,6713,6714],{},"localhost:0"," if unset)",[367,6717,6718,6721,6723],{},[382,6719,6720],{},"StreamsMetadata",[382,6722,384],{},[382,6724,6725,3339,6728,3339,6731,6734],{},[478,6726,6727],{},"hostInfo()",[478,6729,6730],{},"stateStoreNames()",[478,6732,6733],{},"topicPartitions()","; no standbys",[367,6736,6737,6739,6741],{},[382,6738,6456],{},[382,6740,384],{},[382,6742,6743,6746,6747,6750],{},[478,6744,6745],{},"activeHost()"," = local, no standby hosts, ",[478,6748,6749],{},"partition()"," = the key's faithful Kafka partition",[356,6752,6754],{"id":6753},"exception-handlers","Exception handlers",[361,6756,6757,6768],{},[364,6758,6759],{},[367,6760,6761,6764,6766],{},[370,6762,6763],{},"Handler",[370,6765,451],{},[370,6767,454],{},[377,6769,6770,6784,6796,6809,6839],{},[367,6771,6772,6775,6777],{},[382,6773,6774],{},"DeserializationExceptionHandler",[382,6776,384],{},[382,6778,6779,6780,6783],{},"KS-ordered ",[478,6781,6782],{},"handle(ErrorHandlerContext, ConsumerRecord, Exception)","; LogAndFail (default), LogAndContinue, DLQ",[367,6785,6786,6789,6791],{},[382,6787,6788],{},"ProcessingExceptionHandler",[382,6790,384],{},[382,6792,6779,6793,6783],{},[478,6794,6795],{},"handle(ErrorHandlerContext, Record, Exception)",[367,6797,6798,6801,6803],{},[382,6799,6800],{},"ProductionExceptionHandler",[382,6802,384],{},[382,6804,6779,6805,6808],{},[478,6806,6807],{},"handle(ErrorHandlerContext, ProducerRecord, Exception)","; intelligent retry",[367,6810,6811,6814,6816],{},[382,6812,6813],{},"ErrorHandlerContext",[382,6815,384],{},[382,6817,6818,6819,783,6822,783,6824,783,6827,783,6830,783,6833,783,6836],{},"KS interface: ",[478,6820,6821],{},"topic()",[478,6823,6749],{},[478,6825,6826],{},"offset()",[478,6828,6829],{},"timestamp()",[478,6831,6832],{},"headers()",[478,6834,6835],{},"processorNodeId()",[478,6837,6838],{},"taskId()",[367,6840,6841,6844,6846],{},[382,6842,6843],{},"StreamsException",[382,6845,384],{},[382,6847,6848,6849,6852,6853,6856],{},"Extends ",[478,6850,6851],{},"KafkaException","; StoatFlow's fatal failures extend it, so ",[478,6854,6855],{},"catch (StreamsException)"," works",[356,6858,6860],{"id":6859},"lifecycle","Lifecycle",[361,6862,6863,6874],{},[364,6864,6865],{},[367,6866,6867,6870,6872],{},[370,6868,6869],{},"Feature",[370,6871,451],{},[370,6873,454],{},[377,6875,6876,6936,6957,6967,6979,6989,7001,7042],{},[367,6877,6878,6881,6883],{},[382,6879,6880],{},"State enum",[382,6882,384],{},[382,6884,6885,6886,6889,6890,3339,6893,3339,6896,3339,6899,3339,6902,3339,6905,3339,6908,3339,6911,3339,6914,3339,6917,6920,6921,6924,6925,6928,6929,925,6932,6935],{},"StoatFlow keeps a ",[324,6887,6888],{},"richer"," set than KS's 7 — ",[478,6891,6892],{},"CREATED",[478,6894,6895],{},"STARTING",[478,6897,6898],{},"VALIDATING_STATE",[478,6900,6901],{},"RESTORING",[478,6903,6904],{},"RUNNING",[478,6906,6907],{},"DRAINING",[478,6909,6910],{},"PAUSED",[478,6912,6913],{},"STOPPING",[478,6915,6916],{},"STOPPED",[478,6918,6919],{},"ERROR",". For a KS-shaped ",[478,6922,6923],{},"KafkaStreams.State",", use the ",[478,6926,6927],{},"KafkaStreamsState"," mirror + ",[478,6930,6931],{},"State.toKafkaStreamsState()",[478,6933,6934],{},"kafkaStreamsState()"," (KSC-81)",[367,6937,6938,6941,6943],{},[382,6939,6940],{},"StateListener",[382,6942,384],{},[382,6944,6945,6946,6949,6950,6953,6954],{},"KS-exact single ",[478,6947,6948],{},"setStateListener(StateListener)"," — a Java method reference \u002F lambda resolves with no cast (KSC-82); an existing ",[478,6951,6952],{},"BiConsumer\u003CState,State>"," migrates via ",[478,6955,6956],{},"StateListener.of(...)",[367,6958,6959,6962,6964],{},[382,6960,6961],{},"StateRestoreListener",[382,6963,384],{},[382,6965,6966],{},"Full KS-compatible: onRestoreStart \u002F onBatchRestored \u002F onRestoreEnd",[367,6968,6969,6971,6973],{},[382,6970,6489],{},[382,6972,384],{},[382,6974,6975,6978],{},[478,6976,6977],{},"setUncaughtExceptionHandler()","; single-instance: every response shuts the instance down",[367,6980,6981,6984,6986],{},[382,6982,6983],{},"cleanUp()",[382,6985,384],{},[382,6987,6988],{},"Deletes all local state for the application id; valid only in CREATED\u002FSTOPPED; rebuilt from changelog on next start",[367,6990,6991,6993,6995],{},[382,6992,2893],{},[382,6994,384],{},[382,6996,6997,6998,7000],{},"Graceful shutdown; blocks until terminal. Every concurrent close caller now blocks until completion (a losing second ",[478,6999,2893],{}," no longer returns early mid-shutdown) — KSC-83",[367,7002,7003,7006,7008],{},[382,7004,7005],{},"close(Duration)",[382,7007,384],{},[382,7009,7010,7011,7014,7015,7018,7019,7022,7023,7026,7027,7030,7031,7034,7035,7037,7038,7041],{},"The timeout bounds only the ",[324,7012,7013],{},"caller's wait",", never the shutdown work (KS-exact). ",[478,7016,7017],{},"Duration.ZERO"," = async signal-and-return; negative → ",[478,7020,7021],{},"IllegalArgumentException","; shutdown continues after a ",[478,7024,7025],{},"false"," return. Returns ",[478,7028,7029],{},"true"," on ",[324,7032,7033],{},"any"," terminal state incl. ",[478,7036,6919],{}," (divergence — KS only ",[478,7039,7040],{},"NOT_RUNNING",") — KSC-83",[367,7043,7044,7047,7049],{},[382,7045,7046],{},"close(CloseOptions)",[382,7048,384],{},[382,7050,7051,7052,5042,7055,7058,7059,7062,7063,7066,7067,7070,7071,7074,7075,7078,7079,7082,7083,7086,7087,4173,7090,7093],{},"Mirrors the ",[324,7053,7054],{},"top-level KIP-1153",[478,7056,7057],{},"io.stoatflow.core.CloseOptions"," (KS-exact defaults + mutate-and-return-",[478,7060,7061],{},"this"," fluents + ",[478,7064,7065],{},"@JvmStatic"," factories). ",[478,7068,7069],{},"GroupMembershipOperation"," is a per-call override that ",[324,7072,7073],{},"always wins"," over the ",[478,7076,7077],{},"leaveGroupOnClose"," config (incl. its implicit ",[478,7080,7081],{},"REMAIN_IN_GROUP"," default); no-op under HA ",[478,7084,7085],{},"assign()",". The deprecated nested KIP-812 ",[478,7088,7089],{},"KafkaStreams.CloseOptions",[324,7091,7092],{},"not"," mirrored — a port rewrites one line to the factories — KSC-83",[356,7095,150],{"id":7096},"configuration",[361,7098,7099,7110],{},[364,7100,7101],{},[367,7102,7103,7106,7108],{},[370,7104,7105],{},"Aspect",[370,7107,451],{},[370,7109,454],{},[377,7111,7112,7126,7202,7260,7282,7305,7321,7331,7341,7351,7361,7377,7387,7399,7409],{},[367,7113,7114,7117,7119],{},[382,7115,7116],{},"StreamsConfig builder",[382,7118,384],{},[382,7120,7121,7122,7125],{},"Type-safe builder pattern (",[478,7123,7124],{},"StreamsConfig.builder(appId, bootstrap).…build()",") — the primary config model",[367,7127,7128,7136,7138],{},[382,7129,7130,925,7132,7135],{},[478,7131,591],{},[478,7133,7134],{},"*_CONFIG"," constants",[382,7137,384],{},[382,7139,7140,5042,7143,925,7146,7149,7150,783,7152,7155,7156,7159,7160,3339,7163,7166,7167,783,7170,783,7173,783,7176,783,7179,7182,7183,7186,7187,7190,7191,7193,7194,7197,7198,7201],{},[324,7141,7142],{},"Canonical KS adapter (ADR-124).",[478,7144,7145],{},"StreamsConfig.fromProperties(props)",[478,7147,7148],{},"fromMap(map)"," adapt a KS-keyed ",[478,7151,591],{},[478,7153,7154],{},"Map"," onto the typed builder with ",[324,7157,7158],{},"complete coverage of the KS-4.3.0 overlap surface"," (74 keys): typed mappings, class-name pluggables (serdes, the three exception handlers, ",[478,7161,7162],{},"default.client.supplier",[478,7164,7165],{},"rocksdb.config.setter","), client prefixes (",[478,7168,7169],{},"consumer.",[478,7171,7172],{},"main.consumer.",[478,7174,7175],{},"restore.consumer.",[478,7177,7178],{},"producer.",[478,7180,7181],{},"admin.","), and a ",[324,7184,7185],{},"lenient 3-tier unknown-key policy"," (mapped \u002F recognised-no-op \u002F unknown) + opt-in ",[478,7188,7189],{},"stoatflow.config.strict"," that throws only on truly-unknown keys. The typed builder\u002FYAML stays the recommended model; the adapter is the canonical KS-compat surface, not a stepping stone to a Map-backed swap (ADR-124). The KS ",[478,7192,7134],{}," symbol constants and prefix helpers (",[478,7195,7196],{},"consumerPrefix(...)"," … ",[478,7199,7200],{},"adminClientPrefix(...)",") are also shipped for symbol-level source compatibility (KSC-80).",[367,7203,7204,7212,7214],{},[382,7205,7206,925,7209,7211],{},[478,7207,7208],{},"StreamsConfig(Map)",[478,7210,606],{}," ctor",[382,7213,384],{},[382,7215,7216,7219,7220,925,7223,7226,7227,7229,7230,7233,7234,7237,7238,7241,7242,7245,7246,7248,7249,7252,7253,925,7256,7259],{},[324,7217,7218],{},"KSC-79."," The KS-faithful ",[478,7221,7222],{},"new StreamsConfig(props)",[478,7224,7225],{},"new StreamsConfig(map)"," bootstrap idiom compiles after the import-swap (",[478,7228,591],{}," binds the single ",[478,7231,7232],{},"Map\u003C*,*>"," ctor); it delegates to the same ",[478,7235,7236],{},"fromMap(...).build()"," adapter as ",[478,7239,7240],{},"fromProperties",". A missing ",[478,7243,7244],{},"application.id"," throws at construction (",[478,7247,7021],{},", where KS throws ",[478,7250,7251],{},"ConfigException","). The typed ",[478,7254,7255],{},"builder(...)",[478,7257,7258],{},"fromProperties(...)"," paths stay recommended.",[367,7261,7262,7267,7269],{},[382,7263,7264],{},[478,7265,7266],{},"toProperties()",[382,7268,432],{},[382,7270,7271,7274,7275,7277,7278,7281],{},[478,7272,7273],{},"StreamsConfig.toProperties()"," emits the config back to KS-keyed ",[478,7276,591],{}," (resolved-view, masked) — for ",[478,7279,7280],{},"\u002Fconfig",", diffing, inspect\u002Freconstruct",[367,7283,7284,7289,7291],{},[382,7285,7286],{},[478,7287,7288],{},"default.timestamp.extractor",[382,7290,384],{},[382,7292,7293,7296,7297,7299,7300,5042,7302,7304],{},[478,7294,7295],{},"StreamsConfig.defaultTimestampExtractor"," — a global fallback ",[478,7298,3611],{}," for sources with no per-",[478,7301,3528],{},[478,7303,3672],{}," (event-time basis only; the watermark default is unaffected)",[367,7306,7307,7310,7312],{},[382,7308,7309],{},"Admin client config",[382,7311,384],{},[382,7313,7314,925,7317,7320],{},[478,7315,7316],{},"StreamsConfig.adminConfig",[478,7318,7319],{},"admin.*"," prefix — passthrough merged at all AdminClient sites so a secured cluster authenticates",[367,7322,7323,7326,7328],{},[382,7324,7325],{},"KafkaClientSupplier",[382,7327,384],{},[382,7329,7330],{},"Custom client factory for instrumentation\u002Ftesting",[367,7332,7333,7336,7338],{},[382,7334,7335],{},"DefaultKafkaClientSupplier",[382,7337,384],{},[382,7339,7340],{},"Standard KafkaConsumer\u002FKafkaProducer\u002FAdmin factory",[367,7342,7343,7346,7348],{},[382,7344,7345],{},"RocksDB config",[382,7347,384],{},[382,7349,7350],{},"Bounded memory by default",[367,7352,7353,7356,7358],{},[382,7354,7355],{},"Serdes",[382,7357,384],{},[382,7359,7360],{},"Compatible",[367,7362,7363,7366,7368],{},[382,7364,7365],{},"Default key\u002Fvalue Serdes",[382,7367,384],{},[382,7369,7370,783,7373,7376],{},[478,7371,7372],{},"defaultKeySerde",[478,7374,7375],{},"defaultValueSerde"," propagate through the DSL",[367,7378,7379,7382,7384],{},[382,7380,7381],{},"Consumer\u002FProducer config",[382,7383,384],{},[382,7385,7386],{},"Pass-through maps",[367,7388,7389,7391,7393],{},[382,7390,6710],{},[382,7392,384],{},[382,7394,7395,7398],{},[478,7396,7397],{},"host:port"," for the local host reported by interactive-query metadata; defaults from the runtime HTTP host:port when unset",[367,7400,7401,7404,7406],{},[382,7402,7403],{},"state.cleanup.dir.max.age.ms (KIP-1259)",[382,7405,384],{},[382,7407,7408],{},"Age-gated purge of stale local state at startup (rebuilt from changelog); default disabled",[367,7410,7411,7414,7416],{},[382,7412,7413],{},"state.cleanup.delay.ms",[382,7415,384],{},[382,7417,7418],{},"Orphaned-store cleanup interval",[356,7420,7422],{"id":7421},"key-architectural-differences","Key architectural differences",[320,7424,7425,7426,7430],{},"The runtime-model deltas — single instance vs. rebalancing cluster, lanes vs. partition-bound tasks, in-memory re-keying vs. repartition topics, barrier-based exactly-once, global vs. partition-scoped state — are summarized in the canonical ",[329,7427,7429],{"href":7428},"\u002Fdocs\u002Fconcepts\u002Fhow-stoatflow-differs-from-ks#the-deltas-at-a-glance","deltas-at-a-glance table",", with the conceptual treatment on the same page. The rows below are the operational and time-semantics differences that surface while reading this matrix:",[361,7432,7433,7445],{},[364,7434,7435],{},[367,7436,7437,7439,7442],{},[370,7438,7105],{},[370,7440,7441],{},"Kafka Streams",[370,7443,7444],{},"StoatFlow",[377,7446,7447,7458,7469,7480,7491,7502,7512,7521],{},[367,7448,7449,7452,7455],{},[382,7450,7451],{},"RocksDB memory",[382,7453,7454],{},"Unbounded default",[382,7456,7457],{},"Bounded default (256 MB)",[367,7459,7460,7463,7466],{},[382,7461,7462],{},"Window closure",[382,7464,7465],{},"Stream-time based",[382,7467,7468],{},"Watermark-based",[367,7470,7471,7474,7477],{},[382,7472,7473],{},"Grace period",[382,7475,7476],{},"Retention after close",[382,7478,7479],{},"Extends acceptance window",[367,7481,7482,7485,7488],{},[382,7483,7484],{},"Watermark strategy",[382,7486,7487],{},"N\u002FA",[382,7489,7490],{},"Flink-style WatermarkStrategy",[367,7492,7493,7496,7499],{},[382,7494,7495],{},"Punctuators",[382,7497,7498],{},"Task-scoped, on the stream thread",[382,7500,7501],{},"Dedicated punctuation lane per sub-topology, full state access",[367,7503,7504,7507,7509],{},[382,7505,7506],{},"Key-based timers",[382,7508,7487],{},[382,7510,7511],{},"Flink-inspired TimerService",[367,7513,7514,7516,7518],{},[382,7515,140],{},[382,7517,7487],{},[382,7519,7520],{},"Interval & cron-based emission",[367,7522,7523,7526,7528],{},[382,7524,7525],{},"Runtime control",[382,7527,7487],{},[382,7529,7530,783,7532],{},[478,7531,6502],{},[478,7533,6512],{},[356,7535,7537],{"id":7536},"test-utilities","Test utilities",[320,7539,7540,7543,7544,7546],{},[478,7541,7542],{},"TopologyTestDriver"," drives a topology in-memory (no broker) for unit tests. All state stores — including RocksDB-",[478,7545,3793],{}," ones — run in-memory in the test driver; real-engine + RocksDB end-to-end coverage uses integration tests with an embedded broker.",[887,7548,7542],{"id":7549},"topologytestdriver",[361,7551,7552,7562],{},[364,7553,7554],{},[367,7555,7556,7558,7560],{},[370,7557,906],{},[370,7559,451],{},[370,7561,454],{},[377,7563,7564,7591,7614,7630,7645],{},[367,7565,7566,7580,7582],{},[382,7567,7568,925,7571,925,7574,925,7577],{},[478,7569,7570],{},"new TopologyTestDriver(topology)",[478,7572,7573],{},"(topology, Properties)",[478,7575,7576],{},"(topology, Instant)",[478,7578,7579],{},"(topology, Properties, Instant)",[382,7581,384],{},[382,7583,7584,7585,7587,7588],{},"KS-shaped constructors; ",[478,7586,591],{}," via ",[478,7589,7590],{},"StreamsConfig.fromProperties",[367,7592,7593,7598,7600],{},[382,7594,7595],{},[478,7596,7597],{},"createInputTopic(name, Serde\u002FSerializer, …)",[382,7599,384],{},[382,7601,7602,7605,7606,7609,7610,7613],{},[478,7603,7604],{},"Serde"," and ",[478,7607,7608],{},"Serializer"," overloads + 5-arg ",[478,7611,7612],{},"(…, Instant, Duration)"," start-time\u002Fauto-advance form (serdes accepted, ignored)",[367,7615,7616,7621,7623],{},[382,7617,7618],{},[478,7619,7620],{},"createOutputTopic(name, Serde\u002FDeserializer, …)",[382,7622,384],{},[382,7624,7625,7605,7627,1538],{},[478,7626,7604],{},[478,7628,7629],{},"Deserializer",[367,7631,7632,7640,7642],{},[382,7633,7634,925,7637],{},[478,7635,7636],{},"getAllStateStores()",[478,7638,7639],{},"producedTopicNames()",[382,7641,384],{},[382,7643,7644],{},"All stores by name; the set of produced topics",[367,7646,7647,7657,7659],{},[382,7648,7649,925,7652,925,7655],{},[478,7650,7651],{},"advanceWallClockTime(Duration)",[478,7653,7654],{},"get*Store(name)",[478,7656,2893],{},[382,7658,384],{},[382,7660],{},[887,7662,7664],{"id":7663},"testrecord","TestRecord",[320,7666,7667,7668,7671,7672,3339,7675,3339,7678,7681,7682,3339,7685,3339,7688,7691,7692,7695,7696,331],{},"KS positional order ",[478,7669,7670],{},"(key, value, headers, timestamp)","; ctors ",[478,7673,7674],{},"(K,V)",[478,7676,7677],{},"(K,V,Instant)",[478,7679,7680],{},"(K,V,Headers[,Instant])",", value-only ",[478,7683,7684],{},"(V)",[478,7686,7687],{},"(ConsumerRecord)",[478,7689,7690],{},"(ProducerRecord)","; bean getters ",[478,7693,7694],{},"getKey()\u002FgetValue()\u002FgetHeaders()\u002FgetRecordTime()"," + KS accessors ",[478,7697,7698],{},"key()\u002Fvalue()\u002Fheaders()\u002Ftimestamp()",[887,7700,7702],{"id":7701},"testinputtopic","TestInputTopic",[361,7704,7705,7715],{},[364,7706,7707],{},[367,7708,7709,7711,7713],{},[370,7710,448],{},[370,7712,451],{},[370,7714,454],{},[377,7716,7717,7740,7750,7774],{},[367,7718,7719,7725,7727],{},[382,7720,7721,7722,1246],{},"pipeInput(key, value ",[2241,7723,7724],{},", timestamp",[382,7726,384],{},[382,7728,7729,7732,7733,7736,7737],{},[478,7730,7731],{},"timestamp"," as ",[478,7734,7735],{},"long"," or ",[478,7738,7739],{},"Instant",[367,7741,7742,7745,7747],{},[382,7743,7744],{},"pipeInput(value) \u002F pipeInput(value, Instant)",[382,7746,384],{},[382,7748,7749],{},"Value-only (null key) — for value-centric \u002F Avro tests",[367,7751,7752,7755,7757],{},[382,7753,7754],{},"pipeKeyValueList \u002F pipeValueList \u002F pipeRecordList",[382,7756,384],{},[382,7758,7759,7760,7763,7764,7766,7767,4173,7770,7773],{},"Bulk piping; key-value lists use ",[478,7761,7762],{},"KeyValue","; timed ",[478,7765,7612],{}," overloads; ",[478,7768,7769],{},"pipeRecordList",[478,7771,7772],{},"out","-variant",[367,7775,7776,7779,7781],{},[382,7777,7778],{},"advanceTime(Duration)",[382,7780,384],{},[382,7782,7783],{},"Advance the input topic's record clock",[887,7785,7787],{"id":7786},"testoutputtopic","TestOutputTopic",[361,7789,7790,7800],{},[364,7791,7792],{},[367,7793,7794,7796,7798],{},[370,7795,448],{},[370,7797,451],{},[370,7799,454],{},[377,7801,7802,7825,7834],{},[367,7803,7804,7807,7809],{},[382,7805,7806],{},"readKeyValue() \u002F readKeyValuesToList()",[382,7808,384],{},[382,7810,7811,7812,2936,7815,925,7818,7821,7822],{},"Return ",[478,7813,7814],{},"KeyValue\u003CK, V>",[478,7816,7817],{},".key",[478,7819,7820],{},".value","), not ",[478,7823,7824],{},"Pair",[367,7826,7827,7830,7832],{},[382,7828,7829],{},"readKeyValuesToMap()",[382,7831,384],{},[382,7833],{},[367,7835,7836,7839,7841],{},[382,7837,7838],{},"readValue() \u002F readRecord()",[382,7840,384],{},[382,7842],{},[320,7844,7845,7847,7848,7850],{},[478,7846,7762],{}," is StoatFlow's KS-shaped key-value type (the same one the DSL uses); a KS port rewrites the ",[478,7849,7762],{}," import to match.",[356,7852,7854],{"id":7853},"high-availability-hot-standby","High availability (hot-standby)",[320,7856,7857],{},"Not a KS-parity surface — Kafka Streams scales out with standby tasks; StoatFlow's opt-in hot-standby pairs one active with one or more warm standbys. The surface, and the two deliberate gaps:",[361,7859,7860,7870],{},[364,7861,7862],{},[367,7863,7864,7866,7868],{},[370,7865,6334],{},[370,7867,451],{},[370,7869,454],{},[377,7871,7872,7894,7908,7918,7939,7959,7969,7982,7992],{},[367,7873,7874,7886,7888],{},[382,7875,7876,7879,7880,925,7883],{},[478,7877,7878],{},"stoatflow.ha.mode"," = ",[478,7881,7882],{},"off",[478,7884,7885],{},"active-standby",[382,7887,424],{},[382,7889,7890,7891,7893],{},"Deploy-time opt-in; ",[478,7892,7882],{}," (default) is byte-identical to single-instance",[367,7895,7896,7899,7901],{},[382,7897,7898],{},"Active\u002Fpassive failover",[382,7900,424],{},[382,7902,7903,7904,7907],{},"Crash failover in seconds; graceful deploys \u002F ",[478,7905,7906],{},"\u002Fha\u002Fswitch"," hand off cleanly",[367,7909,7910,7913,7915],{},[382,7911,7912],{},"Split-brain fencing",[382,7914,424],{},[382,7916,7917],{},"EOS: broker-enforced producer-epoch fence; ALO: metadata-topic lease",[367,7919,7920,7926,7928],{},[382,7921,7922,7925],{},[478,7923,7924],{},"\u002Fha\u002F{status,switch,promote,demote}"," endpoints",[382,7927,424],{},[382,7929,7930,7931,7934,7935,7938],{},"Operator shims; SWITCH\u002FPROMOTE\u002FDEMOTE return ",[478,7932,7933],{},"409"," unless a caught-up target exists (",[478,7936,7937],{},"?force=true"," override)",[367,7940,7941,7946,7948],{},[382,7942,7943],{},[478,7944,7945],{},"ha.acceptable-recovery-lag",[382,7947,424],{},[382,7949,7950,7951,7954,7955,7958],{},"A single ",[324,7952,7953],{},"total"," lag sum (default 50000) — not per-task like KS ",[478,7956,7957],{},"acceptable.recovery.lag"," (10000)",[367,7960,7961,7964,7966],{},[382,7962,7963],{},"Continuous changelog replication",[382,7965,424],{},[382,7967,7968],{},"The standby streams committed changelog deltas into local state in real time — like KS standby tasks' continuous restore, for the single-active pair",[367,7970,7971,7974,7976],{},[382,7972,7973],{},"Restore-before-process on promotion",[382,7975,424],{},[382,7977,7978,7979,7981],{},"A promoting pod restores local state to the committed changelog end ",[324,7980,4613],{}," processing",[367,7983,7984,7987,7989],{},[382,7985,7986],{},"Queryable standby (KIP-535 IQ from standby)",[382,7988,400],{},[382,7990,7991],{},"Standbys are non-queryable; store queries on a standby are rejected",[367,7993,7994,8000,8003],{},[382,7995,7996,7997],{},"KS standby tasks \u002F ",[478,7998,7999],{},"num.standby.replicas",[382,8001,8002],{},"❌ (different model)",[382,8004,8005],{},"Single-active with warm standbys — not N-instance standby tasks",[320,8007,8008,8009,8011],{},"See ",[329,8010,233],{"href":234}," for the operational guide.",[356,8013,8015],{"id":8014},"related","Related",[8017,8018,8019,8025,8030,8044],"ul",{},[8020,8021,8022,8024],"li",{},[329,8023,338],{"href":337}," — feature-by-feature against Kafka Streams and self-hosted \u002F managed Flink",[8020,8026,8027,8029],{},[329,8028,342],{"href":88}," — how-to guidance for the operators above",[8020,8031,8032,8035,8036,8035,8038,8035,8040,8035,8042],{},[329,8033,8034],{"href":116},"KStream and KTable"," · ",[329,8037,120],{"href":121},[329,8039,125],{"href":126},[329,8041,130],{"href":131},[329,8043,2598],{"href":136},[8020,8045,8046,8035,8048],{},[329,8047,100],{"href":101},[329,8049,140],{"href":141},{"title":8051,"searchDepth":8052,"depth":8052,"links":8053},"",2,[8054,8055,8056,8060,8061,8062,8063,8064,8065,8066,8067,8071,8076,8077,8078,8079,8080,8081,8086,8090,8091,8110,8122,8123,8129,8130,8131,8132,8133,8139,8140],{"id":358,"depth":8052,"text":359},{"id":438,"depth":8052,"text":439},{"id":740,"depth":8052,"text":741,"children":8057},[8058],{"id":889,"depth":8059,"text":778},3,{"id":986,"depth":8052,"text":987},{"id":1146,"depth":8052,"text":1147},{"id":1213,"depth":8052,"text":1214},{"id":1283,"depth":8052,"text":1284},{"id":1339,"depth":8052,"text":1340},{"id":1580,"depth":8052,"text":1581},{"id":1644,"depth":8052,"text":1645},{"id":1740,"depth":8052,"text":1741,"children":8068},[8069,8070],{"id":1744,"depth":8059,"text":1700},{"id":1808,"depth":8059,"text":1809},{"id":1861,"depth":8052,"text":1862,"children":8072},[8073,8074,8075],{"id":1865,"depth":8059,"text":1866},{"id":1929,"depth":8059,"text":1930},{"id":1963,"depth":8059,"text":1964},{"id":2003,"depth":8052,"text":2004},{"id":2256,"depth":8052,"text":2257},{"id":2374,"depth":8052,"text":2375},{"id":2476,"depth":8052,"text":2477},{"id":2555,"depth":8052,"text":2556},{"id":2597,"depth":8052,"text":2598,"children":8082},[8083,8084,8085],{"id":2601,"depth":8059,"text":2602},{"id":2745,"depth":8059,"text":2746},{"id":2956,"depth":8059,"text":2957},{"id":3108,"depth":8052,"text":3109,"children":8087},[8088,8089],{"id":3127,"depth":8059,"text":3123},{"id":3221,"depth":8059,"text":3222},{"id":3304,"depth":8052,"text":3305},{"id":3523,"depth":8052,"text":3524,"children":8092},[8093,8094,8095,8096,8097,8098,8099,8100,8101,8102,8103,8104,8105,8106,8107,8108,8109],{"id":3527,"depth":8059,"text":3528},{"id":3665,"depth":8059,"text":3666},{"id":3806,"depth":8059,"text":3778},{"id":3909,"depth":8059,"text":3781},{"id":3967,"depth":8059,"text":3793},{"id":4116,"depth":8059,"text":3796},{"id":4168,"depth":8059,"text":1537},{"id":4221,"depth":8059,"text":4222},{"id":4292,"depth":8059,"text":3787},{"id":4424,"depth":8059,"text":4425},{"id":4497,"depth":8059,"text":4498},{"id":4628,"depth":8059,"text":3790},{"id":4777,"depth":8059,"text":3784},{"id":4912,"depth":8059,"text":4913},{"id":4964,"depth":8059,"text":4965},{"id":5049,"depth":8059,"text":5050},{"id":5165,"depth":8059,"text":5166},{"id":5276,"depth":8052,"text":100,"children":8111},[8112,8113,8114,8115,8116,8117,8118,8119,8120,8121],{"id":5279,"depth":8059,"text":5280},{"id":5347,"depth":8059,"text":5348},{"id":5376,"depth":8059,"text":5377},{"id":5515,"depth":8059,"text":5516},{"id":5601,"depth":8059,"text":5602},{"id":5763,"depth":8059,"text":5764},{"id":5801,"depth":8059,"text":5802},{"id":5951,"depth":8059,"text":5952},{"id":5988,"depth":8059,"text":5989},{"id":6276,"depth":8059,"text":6277},{"id":6317,"depth":8052,"text":6318},{"id":6404,"depth":8052,"text":6405,"children":8124},[8125,8126,8127,8128],{"id":6408,"depth":8059,"text":6409},{"id":6540,"depth":8059,"text":6541},{"id":6588,"depth":8059,"text":6589},{"id":6675,"depth":8059,"text":6676},{"id":6753,"depth":8052,"text":6754},{"id":6859,"depth":8052,"text":6860},{"id":7096,"depth":8052,"text":150},{"id":7421,"depth":8052,"text":7422},{"id":7536,"depth":8052,"text":7537,"children":8134},[8135,8136,8137,8138],{"id":7549,"depth":8059,"text":7542},{"id":7663,"depth":8059,"text":7664},{"id":7701,"depth":8059,"text":7702},{"id":7786,"depth":8059,"text":7787},{"id":7853,"depth":8052,"text":7854},{"id":8014,"depth":8052,"text":8015},"Operator-by-operator parity between the StoatFlow DSL and the Kafka Streams DSL — implemented, partial, not yet implemented, deprecated, incompatible, and StoatFlow extensions.","md",{},{"icon":304},"reference",{"title":301,"description":8141},"PJV07uI1XdI1wcZePVtTtEzI9Hx5RS9zsl8KSCxVGiY",[8149,8151],{"title":296,"path":297,"stem":298,"description":8150,"icon":299,"children":-1},"StoatFlow's Maven support — the stoatflow-bom, the stoatflow-parent convention POM, and the stoatflow-maven-plugin. The three artifacts, every \u003Cproperties> key, the four goals, and the pinned plugin versions.",{"title":306,"path":307,"stem":308,"description":8152,"icon":170,"children":-1},"The full catalogue of Prometheus meters StoatFlow exposes on \u002Fmetrics — name, type, tags, and what each one measures, grouped by area.",1783713364883]