You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@iggy.apache.org by "numinnex (via GitHub)" <gi...@apache.org> on 2026/10/02 10:14:38 UTC

[PR] docs(repo): add the RFC process and template [iggy]

numinnex opened a new pull request, #4383:
URL: https://github.com/apache/iggy/pull/4383

   (no comment)


-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: commits-unsubscribe@iggy.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org


Re: [PR] docs(repo): add the RFC process and template [iggy]

Posted by "numinnex (via GitHub)" <gi...@apache.org>.
numinnex closed pull request #4383: docs(repo): add the RFC process and template
URL: https://github.com/apache/iggy/pull/4383


-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: commits-unsubscribe@iggy.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org


Re: [PR] docs(repo): add the RFC process and template [iggy]

Posted by "hubcio (via GitHub)" <gi...@apache.org>.
hubcio commented on code in PR #4383:
URL: https://github.com/apache/iggy/pull/4383#discussion_r4165472935


##########
rfcs/README.md:
##########
@@ -0,0 +1,266 @@
+<!-- markdownlint-disable MD053 -->
+
+# Iggy RFCs
+
+[Iggy RFCs]: #iggy-rfcs
+
+The "RFC" (request for comments) process is intended to provide a consistent
+and controlled path for changes to Iggy (such as new features) so that all
+stakeholders can be confident about the direction of the project.
+
+Many changes, including bug fixes and documentation improvements can be
+implemented and reviewed via the normal GitHub pull request workflow.
+
+Some changes though are "substantial", and we ask that these be put through a
+bit of a design process and produce a consensus among the Iggy community and
+the [maintainers].
+
+## Table of Contents
+
+[Table of Contents]: #table-of-contents
+
+- [Opening](#iggy-rfcs)
+- [Table of Contents]
+- [When you need to follow this process]
+- [Before creating an RFC]
+- [What the process is]
+- [RFC numbering]
+- [The RFC life-cycle]
+- [Reviewing RFCs]
+- [Implementing an RFC]
+- [RFC Postponement]

Review Comment:
   warning: the table of contents links "rfc postponement", but there is no such section and no link target. add the section or remove the entry and the postpone option.



##########
rfcs/README.md:
##########
@@ -0,0 +1,266 @@
+<!-- markdownlint-disable MD053 -->
+
+# Iggy RFCs
+
+[Iggy RFCs]: #iggy-rfcs
+
+The "RFC" (request for comments) process is intended to provide a consistent
+and controlled path for changes to Iggy (such as new features) so that all
+stakeholders can be confident about the direction of the project.
+
+Many changes, including bug fixes and documentation improvements can be
+implemented and reviewed via the normal GitHub pull request workflow.
+
+Some changes though are "substantial", and we ask that these be put through a
+bit of a design process and produce a consensus among the Iggy community and
+the [maintainers].
+
+## Table of Contents
+
+[Table of Contents]: #table-of-contents
+
+- [Opening](#iggy-rfcs)
+- [Table of Contents]
+- [When you need to follow this process]
+- [Before creating an RFC]
+- [What the process is]
+- [RFC numbering]
+- [The RFC life-cycle]
+- [Reviewing RFCs]
+- [Implementing an RFC]
+- [RFC Postponement]
+- [Help this is all too informal]
+- [License]
+- [Contributions]
+
+## When you need to follow this process
+
+[When you need to follow this process]: #when-you-need-to-follow-this-process
+
+You need to follow this process if you intend to make "substantial" changes to
+the Iggy server, the wire protocol, the SDKs, the connectors runtime, or the RFC
+process itself. What constitutes a "substantial" change is evolving based on
+community norms and varies depending on what part of the project you are
+proposing to change, but may include the following.
+
+- Any change to the wire protocol or the on-disk format that is not a bugfix.
+- A new storage, replication, or consumption model, or a change to how an
+  existing one behaves.
+- Removing features, including those behind a feature flag.
+- Large additions to the SDK surface that every SDK must then implement.
+
+Some changes do not require an RFC:
+
+- Rephrasing, reorganizing, refactoring, or otherwise "changing shape does
+  not change meaning".
+- Additions that strictly improve objective, numerical quality criteria
+  (warning removal, speedup, better platform coverage, more parallelism, trap
+  more errors, etc.)
+- Additions only likely to be *noticed by* other developers-of-iggy,
+  invisible to users-of-iggy.
+
+If you submit a pull request to implement a new feature without going through
+the RFC process, it may be closed with a polite request to submit an RFC first.
+
+## Before creating an RFC
+
+[Before creating an RFC]: #before-creating-an-rfc
+
+A hastily-proposed RFC can hurt its chances of acceptance. Low quality
+proposals, proposals for previously-rejected features, or those that don't fit
+into the near-term roadmap, may be quickly rejected, which can be demotivating
+for the unprepared contributor. Laying some groundwork ahead of the RFC can
+make the process smoother.
+
+Although there is no single way to prepare for submitting an RFC, it is
+generally a good idea to pursue feedback from other project developers
+beforehand, to ascertain that the RFC may be desirable; having a consistent
+impact on the project requires concerted effort toward consensus-building.
+
+The most common preparations for writing and submitting an RFC include talking
+the idea over on our [Discord server], discussing the topic in [GitHub
+Discussions], and occasionally posting "pre-RFCs" there. A pre-RFC thread is
+separate from the RFC's own Discussion, which is opened later, once the text
+exists and has had its initial review. You may file issues on this repo for
+discussion, but these are not actively looked at by the maintainers.
+
+As a rule of thumb, receiving encouraging feedback from long-standing project
+developers, and particularly from the [maintainers], is a good indication that
+the RFC is worth pursuing.
+
+## What the process is
+
+[What the process is]: #what-the-process-is
+
+In short, to get a major feature added to Iggy, one must first get the RFC
+merged into the `rfcs/` directory of this repository as a markdown file. At
+that point the RFC is "active" and may be implemented with the goal of eventual
+inclusion into Iggy.
+
+- Fork the [Iggy repository].
+- Copy `rfcs/rfc-template.md` to `rfcs/rfc-0-my-feature.md` (where
+  "my-feature" is descriptive). Don't assign an RFC number yet; `0` marks an
+  unassigned number, and one is assigned when the RFC is accepted and the file
+  is renamed accordingly. See [RFC numbering].
+- Fill in the RFC. Put care into the details: RFCs that do not present
+  convincing motivation, demonstrate lack of understanding of the design's
+  impact, or are disingenuous about the drawbacks or alternatives tend to
+  be poorly-received.
+- Submit a pull request titled `rfc(<scope>): <subject>`, where the scope is
+  one of those accepted by the PR title check. The pull request carries the
+  text. A maintainer gives it an initial review within a week: whether the
+  change needs an RFC at all, whether the text is complete enough to debate,
+  and editorial comments on the writing.
+- Now that your RFC has an open pull request, update the "RFC PR" link at the
+  top of the file to point at it.
+- Once a maintainer marks the RFC ready for discussion, open a GitHub
+  Discussion in the RFCs category titled `RFC: <feature>`, linking the pull

Review Comment:
   warning: authors are sent to an rfcs category for the design discussion, but apache/iggy has no such category. create it before merge, or name an existing one.



##########
rfcs/README.md:
##########
@@ -0,0 +1,266 @@
+<!-- markdownlint-disable MD053 -->
+
+# Iggy RFCs
+
+[Iggy RFCs]: #iggy-rfcs
+
+The "RFC" (request for comments) process is intended to provide a consistent
+and controlled path for changes to Iggy (such as new features) so that all
+stakeholders can be confident about the direction of the project.
+
+Many changes, including bug fixes and documentation improvements can be
+implemented and reviewed via the normal GitHub pull request workflow.
+
+Some changes though are "substantial", and we ask that these be put through a
+bit of a design process and produce a consensus among the Iggy community and
+the [maintainers].
+
+## Table of Contents
+
+[Table of Contents]: #table-of-contents
+
+- [Opening](#iggy-rfcs)
+- [Table of Contents]
+- [When you need to follow this process]
+- [Before creating an RFC]
+- [What the process is]
+- [RFC numbering]
+- [The RFC life-cycle]
+- [Reviewing RFCs]
+- [Implementing an RFC]
+- [RFC Postponement]
+- [Help this is all too informal]
+- [License]
+- [Contributions]
+
+## When you need to follow this process
+
+[When you need to follow this process]: #when-you-need-to-follow-this-process
+
+You need to follow this process if you intend to make "substantial" changes to
+the Iggy server, the wire protocol, the SDKs, the connectors runtime, or the RFC
+process itself. What constitutes a "substantial" change is evolving based on
+community norms and varies depending on what part of the project you are
+proposing to change, but may include the following.
+
+- Any change to the wire protocol or the on-disk format that is not a bugfix.
+- A new storage, replication, or consumption model, or a change to how an
+  existing one behaves.
+- Removing features, including those behind a feature flag.
+- Large additions to the SDK surface that every SDK must then implement.
+
+Some changes do not require an RFC:
+
+- Rephrasing, reorganizing, refactoring, or otherwise "changing shape does
+  not change meaning".
+- Additions that strictly improve objective, numerical quality criteria
+  (warning removal, speedup, better platform coverage, more parallelism, trap
+  more errors, etc.)
+- Additions only likely to be *noticed by* other developers-of-iggy,
+  invisible to users-of-iggy.
+
+If you submit a pull request to implement a new feature without going through
+the RFC process, it may be closed with a polite request to submit an RFC first.
+
+## Before creating an RFC
+
+[Before creating an RFC]: #before-creating-an-rfc
+
+A hastily-proposed RFC can hurt its chances of acceptance. Low quality
+proposals, proposals for previously-rejected features, or those that don't fit
+into the near-term roadmap, may be quickly rejected, which can be demotivating
+for the unprepared contributor. Laying some groundwork ahead of the RFC can
+make the process smoother.
+
+Although there is no single way to prepare for submitting an RFC, it is
+generally a good idea to pursue feedback from other project developers
+beforehand, to ascertain that the RFC may be desirable; having a consistent
+impact on the project requires concerted effort toward consensus-building.
+
+The most common preparations for writing and submitting an RFC include talking
+the idea over on our [Discord server], discussing the topic in [GitHub
+Discussions], and occasionally posting "pre-RFCs" there. A pre-RFC thread is
+separate from the RFC's own Discussion, which is opened later, once the text
+exists and has had its initial review. You may file issues on this repo for
+discussion, but these are not actively looked at by the maintainers.
+
+As a rule of thumb, receiving encouraging feedback from long-standing project
+developers, and particularly from the [maintainers], is a good indication that
+the RFC is worth pursuing.
+
+## What the process is
+
+[What the process is]: #what-the-process-is
+
+In short, to get a major feature added to Iggy, one must first get the RFC
+merged into the `rfcs/` directory of this repository as a markdown file. At
+that point the RFC is "active" and may be implemented with the goal of eventual
+inclusion into Iggy.
+
+- Fork the [Iggy repository].
+- Copy `rfcs/rfc-template.md` to `rfcs/rfc-0-my-feature.md` (where
+  "my-feature" is descriptive). Don't assign an RFC number yet; `0` marks an
+  unassigned number, and one is assigned when the RFC is accepted and the file
+  is renamed accordingly. See [RFC numbering].
+- Fill in the RFC. Put care into the details: RFCs that do not present
+  convincing motivation, demonstrate lack of understanding of the design's
+  impact, or are disingenuous about the drawbacks or alternatives tend to
+  be poorly-received.
+- Submit a pull request titled `rfc(<scope>): <subject>`, where the scope is
+  one of those accepted by the PR title check. The pull request carries the
+  text. A maintainer gives it an initial review within a week: whether the
+  change needs an RFC at all, whether the text is complete enough to debate,
+  and editorial comments on the writing.
+- Now that your RFC has an open pull request, update the "RFC PR" link at the
+  top of the file to point at it.
+- Once a maintainer marks the RFC ready for discussion, open a GitHub
+  Discussion in the RFCs category titled `RFC: <feature>`, linking the pull
+  request and quoting the summary, and update the "Discussion" link at the top
+  of the file to point at it. The Discussion is where the design is debated;

Review Comment:
   warning: the debate lives in the discussion, but the stale bot closes a pr after 14 days without pr activity. state that rfc prs stay pinned or carry `S-waiting-on-review` for their lifetime.



##########
rfcs/README.md:
##########
@@ -0,0 +1,266 @@
+<!-- markdownlint-disable MD053 -->
+
+# Iggy RFCs
+
+[Iggy RFCs]: #iggy-rfcs
+
+The "RFC" (request for comments) process is intended to provide a consistent
+and controlled path for changes to Iggy (such as new features) so that all
+stakeholders can be confident about the direction of the project.
+
+Many changes, including bug fixes and documentation improvements can be
+implemented and reviewed via the normal GitHub pull request workflow.
+
+Some changes though are "substantial", and we ask that these be put through a
+bit of a design process and produce a consensus among the Iggy community and
+the [maintainers].
+
+## Table of Contents
+
+[Table of Contents]: #table-of-contents
+
+- [Opening](#iggy-rfcs)
+- [Table of Contents]
+- [When you need to follow this process]
+- [Before creating an RFC]
+- [What the process is]
+- [RFC numbering]
+- [The RFC life-cycle]
+- [Reviewing RFCs]
+- [Implementing an RFC]
+- [RFC Postponement]
+- [Help this is all too informal]
+- [License]
+- [Contributions]
+
+## When you need to follow this process
+
+[When you need to follow this process]: #when-you-need-to-follow-this-process
+
+You need to follow this process if you intend to make "substantial" changes to
+the Iggy server, the wire protocol, the SDKs, the connectors runtime, or the RFC
+process itself. What constitutes a "substantial" change is evolving based on
+community norms and varies depending on what part of the project you are
+proposing to change, but may include the following.
+
+- Any change to the wire protocol or the on-disk format that is not a bugfix.
+- A new storage, replication, or consumption model, or a change to how an
+  existing one behaves.
+- Removing features, including those behind a feature flag.
+- Large additions to the SDK surface that every SDK must then implement.
+
+Some changes do not require an RFC:
+
+- Rephrasing, reorganizing, refactoring, or otherwise "changing shape does
+  not change meaning".
+- Additions that strictly improve objective, numerical quality criteria
+  (warning removal, speedup, better platform coverage, more parallelism, trap
+  more errors, etc.)
+- Additions only likely to be *noticed by* other developers-of-iggy,
+  invisible to users-of-iggy.
+
+If you submit a pull request to implement a new feature without going through
+the RFC process, it may be closed with a polite request to submit an RFC first.
+
+## Before creating an RFC
+
+[Before creating an RFC]: #before-creating-an-rfc
+
+A hastily-proposed RFC can hurt its chances of acceptance. Low quality
+proposals, proposals for previously-rejected features, or those that don't fit
+into the near-term roadmap, may be quickly rejected, which can be demotivating
+for the unprepared contributor. Laying some groundwork ahead of the RFC can
+make the process smoother.
+
+Although there is no single way to prepare for submitting an RFC, it is
+generally a good idea to pursue feedback from other project developers
+beforehand, to ascertain that the RFC may be desirable; having a consistent
+impact on the project requires concerted effort toward consensus-building.
+
+The most common preparations for writing and submitting an RFC include talking
+the idea over on our [Discord server], discussing the topic in [GitHub
+Discussions], and occasionally posting "pre-RFCs" there. A pre-RFC thread is
+separate from the RFC's own Discussion, which is opened later, once the text
+exists and has had its initial review. You may file issues on this repo for
+discussion, but these are not actively looked at by the maintainers.
+
+As a rule of thumb, receiving encouraging feedback from long-standing project
+developers, and particularly from the [maintainers], is a good indication that
+the RFC is worth pursuing.
+
+## What the process is
+
+[What the process is]: #what-the-process-is
+
+In short, to get a major feature added to Iggy, one must first get the RFC
+merged into the `rfcs/` directory of this repository as a markdown file. At
+that point the RFC is "active" and may be implemented with the goal of eventual
+inclusion into Iggy.
+
+- Fork the [Iggy repository].
+- Copy `rfcs/rfc-template.md` to `rfcs/rfc-0-my-feature.md` (where
+  "my-feature" is descriptive). Don't assign an RFC number yet; `0` marks an
+  unassigned number, and one is assigned when the RFC is accepted and the file
+  is renamed accordingly. See [RFC numbering].
+- Fill in the RFC. Put care into the details: RFCs that do not present
+  convincing motivation, demonstrate lack of understanding of the design's
+  impact, or are disingenuous about the drawbacks or alternatives tend to
+  be poorly-received.
+- Submit a pull request titled `rfc(<scope>): <subject>`, where the scope is
+  one of those accepted by the PR title check. The pull request carries the
+  text. A maintainer gives it an initial review within a week: whether the
+  change needs an RFC at all, whether the text is complete enough to debate,
+  and editorial comments on the writing.
+- Now that your RFC has an open pull request, update the "RFC PR" link at the
+  top of the file to point at it.
+- Once a maintainer marks the RFC ready for discussion, open a GitHub
+  Discussion in the RFCs category titled `RFC: <feature>`, linking the pull
+  request and quoting the summary, and update the "Discussion" link at the top
+  of the file to point at it. The Discussion is where the design is debated;
+  the pull request keeps editorial review.
+- Build consensus and integrate feedback. RFCs that have broad support are
+  much more likely to make progress than those that don't receive any
+  comments. Feel free to reach out to the maintainers in particular to get
+  help identifying stakeholders and obstacles.
+- The maintainers will discuss the RFC, as much as possible in the Discussion
+  itself. Offline discussion will be summarized in the Discussion.
+- RFCs rarely go through this process unchanged, especially as alternatives
+  and drawbacks are shown. You can make edits, big and small, to the RFC to
+  clarify or change the design, but make changes as new commits to the pull
+  request, and reply in the Discussion with the commit hash and permalinks to
+  the changed lines, explaining your changes. **Specifically, do not squash or
+  rebase commits after they are visible on the pull request.**
+- At some point, a maintainer will propose a "motion for final comment period"
+  (FCP) in the Discussion, along with a *disposition* for the RFC (merge,
+  close, or postpone).
+  - This step is taken when enough of the tradeoffs have been discussed that
+    the maintainers are in a position to make a decision. That does not require
+    consensus amongst all participants in the Discussion (which is usually
+    impossible). However, the argument supporting the disposition on the RFC
+    needs to have already been clearly articulated, and there should not be a
+    strong consensus *against* that position outside of the maintainers.
+    Maintainers use their best judgment in taking this step, and the FCP itself
+    ensures there is ample time and notification for stakeholders to push
+    back if it is made prematurely.
+  - For RFCs with lengthy discussion, the motion to FCP is usually preceded by
+    a *summary comment* trying to lay out the current state of the discussion
+    and major tradeoffs/points of disagreement.
+  - Before actually entering FCP, the maintainers must sign off; this is often
+    the point at which many of them first review the RFC in full depth.
+- The FCP lasts ten calendar days, so that it is open for at least 5 business
+  days. It is also advertised on the [dev mailing list]. This way all
+  stakeholders have a chance to lodge any final objections before a decision
+  is reached.
+- In most cases, the FCP period is quiet, and the RFC is either merged or
+  closed. However, sometimes substantial new arguments or ideas are raised,
+  the FCP is canceled, and the RFC goes back into development mode.
+
+## RFC numbering
+
+[RFC numbering]: #rfc-numbering
+
+RFC numbers are small sequential integers without zero padding, assigned when
+an RFC is accepted, so the first RFC is `rfc-1`. Whoever merges the pull request
+renames `rfcs/rfc-0-my-feature.md` to the next free number, for example
+`rfcs/rfc-7-my-feature.md`, fills in the "Iggy Issue" link with the tracking

Review Comment:
   nit: the merger fills the tracking issue link, but no step says who opens that issue. name the opener, or say the merger opens it at merge time.



##########
rfcs/README.md:
##########
@@ -0,0 +1,266 @@
+<!-- markdownlint-disable MD053 -->
+
+# Iggy RFCs
+
+[Iggy RFCs]: #iggy-rfcs
+
+The "RFC" (request for comments) process is intended to provide a consistent
+and controlled path for changes to Iggy (such as new features) so that all
+stakeholders can be confident about the direction of the project.
+
+Many changes, including bug fixes and documentation improvements can be
+implemented and reviewed via the normal GitHub pull request workflow.
+
+Some changes though are "substantial", and we ask that these be put through a
+bit of a design process and produce a consensus among the Iggy community and
+the [maintainers].
+
+## Table of Contents
+
+[Table of Contents]: #table-of-contents
+
+- [Opening](#iggy-rfcs)
+- [Table of Contents]
+- [When you need to follow this process]
+- [Before creating an RFC]
+- [What the process is]
+- [RFC numbering]
+- [The RFC life-cycle]
+- [Reviewing RFCs]
+- [Implementing an RFC]
+- [RFC Postponement]
+- [Help this is all too informal]
+- [License]
+- [Contributions]
+
+## When you need to follow this process
+
+[When you need to follow this process]: #when-you-need-to-follow-this-process
+
+You need to follow this process if you intend to make "substantial" changes to
+the Iggy server, the wire protocol, the SDKs, the connectors runtime, or the RFC
+process itself. What constitutes a "substantial" change is evolving based on
+community norms and varies depending on what part of the project you are
+proposing to change, but may include the following.
+
+- Any change to the wire protocol or the on-disk format that is not a bugfix.
+- A new storage, replication, or consumption model, or a change to how an
+  existing one behaves.
+- Removing features, including those behind a feature flag.
+- Large additions to the SDK surface that every SDK must then implement.
+
+Some changes do not require an RFC:
+
+- Rephrasing, reorganizing, refactoring, or otherwise "changing shape does
+  not change meaning".
+- Additions that strictly improve objective, numerical quality criteria
+  (warning removal, speedup, better platform coverage, more parallelism, trap
+  more errors, etc.)
+- Additions only likely to be *noticed by* other developers-of-iggy,
+  invisible to users-of-iggy.
+
+If you submit a pull request to implement a new feature without going through
+the RFC process, it may be closed with a polite request to submit an RFC first.
+
+## Before creating an RFC
+
+[Before creating an RFC]: #before-creating-an-rfc
+
+A hastily-proposed RFC can hurt its chances of acceptance. Low quality
+proposals, proposals for previously-rejected features, or those that don't fit
+into the near-term roadmap, may be quickly rejected, which can be demotivating
+for the unprepared contributor. Laying some groundwork ahead of the RFC can
+make the process smoother.
+
+Although there is no single way to prepare for submitting an RFC, it is
+generally a good idea to pursue feedback from other project developers
+beforehand, to ascertain that the RFC may be desirable; having a consistent
+impact on the project requires concerted effort toward consensus-building.
+
+The most common preparations for writing and submitting an RFC include talking
+the idea over on our [Discord server], discussing the topic in [GitHub
+Discussions], and occasionally posting "pre-RFCs" there. A pre-RFC thread is
+separate from the RFC's own Discussion, which is opened later, once the text
+exists and has had its initial review. You may file issues on this repo for
+discussion, but these are not actively looked at by the maintainers.
+
+As a rule of thumb, receiving encouraging feedback from long-standing project
+developers, and particularly from the [maintainers], is a good indication that
+the RFC is worth pursuing.
+
+## What the process is
+
+[What the process is]: #what-the-process-is
+
+In short, to get a major feature added to Iggy, one must first get the RFC
+merged into the `rfcs/` directory of this repository as a markdown file. At
+that point the RFC is "active" and may be implemented with the goal of eventual
+inclusion into Iggy.
+
+- Fork the [Iggy repository].
+- Copy `rfcs/rfc-template.md` to `rfcs/rfc-0-my-feature.md` (where
+  "my-feature" is descriptive). Don't assign an RFC number yet; `0` marks an
+  unassigned number, and one is assigned when the RFC is accepted and the file
+  is renamed accordingly. See [RFC numbering].
+- Fill in the RFC. Put care into the details: RFCs that do not present
+  convincing motivation, demonstrate lack of understanding of the design's
+  impact, or are disingenuous about the drawbacks or alternatives tend to
+  be poorly-received.
+- Submit a pull request titled `rfc(<scope>): <subject>`, where the scope is
+  one of those accepted by the PR title check. The pull request carries the
+  text. A maintainer gives it an initial review within a week: whether the
+  change needs an RFC at all, whether the text is complete enough to debate,
+  and editorial comments on the writing.
+- Now that your RFC has an open pull request, update the "RFC PR" link at the
+  top of the file to point at it.
+- Once a maintainer marks the RFC ready for discussion, open a GitHub
+  Discussion in the RFCs category titled `RFC: <feature>`, linking the pull
+  request and quoting the summary, and update the "Discussion" link at the top
+  of the file to point at it. The Discussion is where the design is debated;
+  the pull request keeps editorial review.
+- Build consensus and integrate feedback. RFCs that have broad support are
+  much more likely to make progress than those that don't receive any
+  comments. Feel free to reach out to the maintainers in particular to get
+  help identifying stakeholders and obstacles.
+- The maintainers will discuss the RFC, as much as possible in the Discussion
+  itself. Offline discussion will be summarized in the Discussion.
+- RFCs rarely go through this process unchanged, especially as alternatives
+  and drawbacks are shown. You can make edits, big and small, to the RFC to
+  clarify or change the design, but make changes as new commits to the pull
+  request, and reply in the Discussion with the commit hash and permalinks to
+  the changed lines, explaining your changes. **Specifically, do not squash or
+  rebase commits after they are visible on the pull request.**
+- At some point, a maintainer will propose a "motion for final comment period"
+  (FCP) in the Discussion, along with a *disposition* for the RFC (merge,
+  close, or postpone).
+  - This step is taken when enough of the tradeoffs have been discussed that
+    the maintainers are in a position to make a decision. That does not require
+    consensus amongst all participants in the Discussion (which is usually
+    impossible). However, the argument supporting the disposition on the RFC
+    needs to have already been clearly articulated, and there should not be a
+    strong consensus *against* that position outside of the maintainers.
+    Maintainers use their best judgment in taking this step, and the FCP itself
+    ensures there is ample time and notification for stakeholders to push
+    back if it is made prematurely.
+  - For RFCs with lengthy discussion, the motion to FCP is usually preceded by
+    a *summary comment* trying to lay out the current state of the discussion
+    and major tradeoffs/points of disagreement.
+  - Before actually entering FCP, the maintainers must sign off; this is often
+    the point at which many of them first review the RFC in full depth.
+- The FCP lasts ten calendar days, so that it is open for at least 5 business
+  days. It is also advertised on the [dev mailing list]. This way all
+  stakeholders have a chance to lodge any final objections before a decision
+  is reached.
+- In most cases, the FCP period is quiet, and the RFC is either merged or
+  closed. However, sometimes substantial new arguments or ideas are raised,
+  the FCP is canceled, and the RFC goes back into development mode.
+
+## RFC numbering
+
+[RFC numbering]: #rfc-numbering
+
+RFC numbers are small sequential integers without zero padding, assigned when
+an RFC is accepted, so the first RFC is `rfc-1`. Whoever merges the pull request
+renames `rfcs/rfc-0-my-feature.md` to the next free number, for example

Review Comment:
   warning: the merger renames the file at merge time, but a push after the approvals dismisses them, and the repo allows only squash merges. rename before the final approvals, or spell out how the rename lands.



##########
rfcs/README.md:
##########
@@ -0,0 +1,266 @@
+<!-- markdownlint-disable MD053 -->
+
+# Iggy RFCs
+
+[Iggy RFCs]: #iggy-rfcs
+
+The "RFC" (request for comments) process is intended to provide a consistent
+and controlled path for changes to Iggy (such as new features) so that all
+stakeholders can be confident about the direction of the project.
+
+Many changes, including bug fixes and documentation improvements can be
+implemented and reviewed via the normal GitHub pull request workflow.
+
+Some changes though are "substantial", and we ask that these be put through a
+bit of a design process and produce a consensus among the Iggy community and
+the [maintainers].
+
+## Table of Contents
+
+[Table of Contents]: #table-of-contents
+
+- [Opening](#iggy-rfcs)
+- [Table of Contents]
+- [When you need to follow this process]
+- [Before creating an RFC]
+- [What the process is]
+- [RFC numbering]
+- [The RFC life-cycle]
+- [Reviewing RFCs]
+- [Implementing an RFC]
+- [RFC Postponement]
+- [Help this is all too informal]
+- [License]
+- [Contributions]
+
+## When you need to follow this process
+
+[When you need to follow this process]: #when-you-need-to-follow-this-process
+
+You need to follow this process if you intend to make "substantial" changes to
+the Iggy server, the wire protocol, the SDKs, the connectors runtime, or the RFC
+process itself. What constitutes a "substantial" change is evolving based on
+community norms and varies depending on what part of the project you are
+proposing to change, but may include the following.
+
+- Any change to the wire protocol or the on-disk format that is not a bugfix.
+- A new storage, replication, or consumption model, or a change to how an
+  existing one behaves.
+- Removing features, including those behind a feature flag.
+- Large additions to the SDK surface that every SDK must then implement.
+
+Some changes do not require an RFC:
+
+- Rephrasing, reorganizing, refactoring, or otherwise "changing shape does
+  not change meaning".
+- Additions that strictly improve objective, numerical quality criteria
+  (warning removal, speedup, better platform coverage, more parallelism, trap
+  more errors, etc.)
+- Additions only likely to be *noticed by* other developers-of-iggy,
+  invisible to users-of-iggy.
+
+If you submit a pull request to implement a new feature without going through
+the RFC process, it may be closed with a polite request to submit an RFC first.
+
+## Before creating an RFC
+
+[Before creating an RFC]: #before-creating-an-rfc
+
+A hastily-proposed RFC can hurt its chances of acceptance. Low quality
+proposals, proposals for previously-rejected features, or those that don't fit
+into the near-term roadmap, may be quickly rejected, which can be demotivating
+for the unprepared contributor. Laying some groundwork ahead of the RFC can
+make the process smoother.
+
+Although there is no single way to prepare for submitting an RFC, it is
+generally a good idea to pursue feedback from other project developers
+beforehand, to ascertain that the RFC may be desirable; having a consistent
+impact on the project requires concerted effort toward consensus-building.
+
+The most common preparations for writing and submitting an RFC include talking
+the idea over on our [Discord server], discussing the topic in [GitHub
+Discussions], and occasionally posting "pre-RFCs" there. A pre-RFC thread is
+separate from the RFC's own Discussion, which is opened later, once the text
+exists and has had its initial review. You may file issues on this repo for
+discussion, but these are not actively looked at by the maintainers.
+
+As a rule of thumb, receiving encouraging feedback from long-standing project
+developers, and particularly from the [maintainers], is a good indication that
+the RFC is worth pursuing.
+
+## What the process is
+
+[What the process is]: #what-the-process-is
+
+In short, to get a major feature added to Iggy, one must first get the RFC
+merged into the `rfcs/` directory of this repository as a markdown file. At
+that point the RFC is "active" and may be implemented with the goal of eventual
+inclusion into Iggy.
+
+- Fork the [Iggy repository].
+- Copy `rfcs/rfc-template.md` to `rfcs/rfc-0-my-feature.md` (where
+  "my-feature" is descriptive). Don't assign an RFC number yet; `0` marks an
+  unassigned number, and one is assigned when the RFC is accepted and the file
+  is renamed accordingly. See [RFC numbering].
+- Fill in the RFC. Put care into the details: RFCs that do not present
+  convincing motivation, demonstrate lack of understanding of the design's
+  impact, or are disingenuous about the drawbacks or alternatives tend to
+  be poorly-received.
+- Submit a pull request titled `rfc(<scope>): <subject>`, where the scope is
+  one of those accepted by the PR title check. The pull request carries the
+  text. A maintainer gives it an initial review within a week: whether the
+  change needs an RFC at all, whether the text is complete enough to debate,
+  and editorial comments on the writing.
+- Now that your RFC has an open pull request, update the "RFC PR" link at the
+  top of the file to point at it.
+- Once a maintainer marks the RFC ready for discussion, open a GitHub
+  Discussion in the RFCs category titled `RFC: <feature>`, linking the pull
+  request and quoting the summary, and update the "Discussion" link at the top
+  of the file to point at it. The Discussion is where the design is debated;
+  the pull request keeps editorial review.
+- Build consensus and integrate feedback. RFCs that have broad support are
+  much more likely to make progress than those that don't receive any
+  comments. Feel free to reach out to the maintainers in particular to get
+  help identifying stakeholders and obstacles.
+- The maintainers will discuss the RFC, as much as possible in the Discussion
+  itself. Offline discussion will be summarized in the Discussion.
+- RFCs rarely go through this process unchanged, especially as alternatives
+  and drawbacks are shown. You can make edits, big and small, to the RFC to
+  clarify or change the design, but make changes as new commits to the pull
+  request, and reply in the Discussion with the commit hash and permalinks to
+  the changed lines, explaining your changes. **Specifically, do not squash or
+  rebase commits after they are visible on the pull request.**
+- At some point, a maintainer will propose a "motion for final comment period"
+  (FCP) in the Discussion, along with a *disposition* for the RFC (merge,
+  close, or postpone).
+  - This step is taken when enough of the tradeoffs have been discussed that
+    the maintainers are in a position to make a decision. That does not require
+    consensus amongst all participants in the Discussion (which is usually
+    impossible). However, the argument supporting the disposition on the RFC
+    needs to have already been clearly articulated, and there should not be a
+    strong consensus *against* that position outside of the maintainers.
+    Maintainers use their best judgment in taking this step, and the FCP itself
+    ensures there is ample time and notification for stakeholders to push
+    back if it is made prematurely.
+  - For RFCs with lengthy discussion, the motion to FCP is usually preceded by
+    a *summary comment* trying to lay out the current state of the discussion
+    and major tradeoffs/points of disagreement.
+  - Before actually entering FCP, the maintainers must sign off; this is often
+    the point at which many of them first review the RFC in full depth.
+- The FCP lasts ten calendar days, so that it is open for at least 5 business
+  days. It is also advertised on the [dev mailing list]. This way all

Review Comment:
   nit: the fcp is advertised on dev@ for final objections, but the mirror runs one way and replies to the list never reach the discussion. ask for objections in the discussion, or add a relay step.



##########
rfcs/README.md:
##########
@@ -0,0 +1,266 @@
+<!-- markdownlint-disable MD053 -->
+
+# Iggy RFCs
+
+[Iggy RFCs]: #iggy-rfcs
+
+The "RFC" (request for comments) process is intended to provide a consistent
+and controlled path for changes to Iggy (such as new features) so that all
+stakeholders can be confident about the direction of the project.
+
+Many changes, including bug fixes and documentation improvements can be
+implemented and reviewed via the normal GitHub pull request workflow.
+
+Some changes though are "substantial", and we ask that these be put through a
+bit of a design process and produce a consensus among the Iggy community and
+the [maintainers].
+
+## Table of Contents
+
+[Table of Contents]: #table-of-contents
+
+- [Opening](#iggy-rfcs)
+- [Table of Contents]
+- [When you need to follow this process]
+- [Before creating an RFC]
+- [What the process is]
+- [RFC numbering]
+- [The RFC life-cycle]
+- [Reviewing RFCs]
+- [Implementing an RFC]
+- [RFC Postponement]
+- [Help this is all too informal]
+- [License]
+- [Contributions]
+
+## When you need to follow this process
+
+[When you need to follow this process]: #when-you-need-to-follow-this-process
+
+You need to follow this process if you intend to make "substantial" changes to
+the Iggy server, the wire protocol, the SDKs, the connectors runtime, or the RFC
+process itself. What constitutes a "substantial" change is evolving based on
+community norms and varies depending on what part of the project you are
+proposing to change, but may include the following.
+
+- Any change to the wire protocol or the on-disk format that is not a bugfix.
+- A new storage, replication, or consumption model, or a change to how an
+  existing one behaves.
+- Removing features, including those behind a feature flag.
+- Large additions to the SDK surface that every SDK must then implement.
+
+Some changes do not require an RFC:
+
+- Rephrasing, reorganizing, refactoring, or otherwise "changing shape does
+  not change meaning".
+- Additions that strictly improve objective, numerical quality criteria
+  (warning removal, speedup, better platform coverage, more parallelism, trap
+  more errors, etc.)
+- Additions only likely to be *noticed by* other developers-of-iggy,
+  invisible to users-of-iggy.
+
+If you submit a pull request to implement a new feature without going through
+the RFC process, it may be closed with a polite request to submit an RFC first.
+
+## Before creating an RFC
+
+[Before creating an RFC]: #before-creating-an-rfc
+
+A hastily-proposed RFC can hurt its chances of acceptance. Low quality
+proposals, proposals for previously-rejected features, or those that don't fit
+into the near-term roadmap, may be quickly rejected, which can be demotivating
+for the unprepared contributor. Laying some groundwork ahead of the RFC can
+make the process smoother.
+
+Although there is no single way to prepare for submitting an RFC, it is
+generally a good idea to pursue feedback from other project developers
+beforehand, to ascertain that the RFC may be desirable; having a consistent
+impact on the project requires concerted effort toward consensus-building.
+
+The most common preparations for writing and submitting an RFC include talking
+the idea over on our [Discord server], discussing the topic in [GitHub
+Discussions], and occasionally posting "pre-RFCs" there. A pre-RFC thread is
+separate from the RFC's own Discussion, which is opened later, once the text
+exists and has had its initial review. You may file issues on this repo for
+discussion, but these are not actively looked at by the maintainers.
+
+As a rule of thumb, receiving encouraging feedback from long-standing project
+developers, and particularly from the [maintainers], is a good indication that
+the RFC is worth pursuing.
+
+## What the process is
+
+[What the process is]: #what-the-process-is
+
+In short, to get a major feature added to Iggy, one must first get the RFC
+merged into the `rfcs/` directory of this repository as a markdown file. At
+that point the RFC is "active" and may be implemented with the goal of eventual
+inclusion into Iggy.
+
+- Fork the [Iggy repository].
+- Copy `rfcs/rfc-template.md` to `rfcs/rfc-0-my-feature.md` (where
+  "my-feature" is descriptive). Don't assign an RFC number yet; `0` marks an
+  unassigned number, and one is assigned when the RFC is accepted and the file
+  is renamed accordingly. See [RFC numbering].
+- Fill in the RFC. Put care into the details: RFCs that do not present
+  convincing motivation, demonstrate lack of understanding of the design's
+  impact, or are disingenuous about the drawbacks or alternatives tend to
+  be poorly-received.
+- Submit a pull request titled `rfc(<scope>): <subject>`, where the scope is
+  one of those accepted by the PR title check. The pull request carries the
+  text. A maintainer gives it an initial review within a week: whether the
+  change needs an RFC at all, whether the text is complete enough to debate,
+  and editorial comments on the writing.
+- Now that your RFC has an open pull request, update the "RFC PR" link at the
+  top of the file to point at it.
+- Once a maintainer marks the RFC ready for discussion, open a GitHub
+  Discussion in the RFCs category titled `RFC: <feature>`, linking the pull
+  request and quoting the summary, and update the "Discussion" link at the top
+  of the file to point at it. The Discussion is where the design is debated;
+  the pull request keeps editorial review.
+- Build consensus and integrate feedback. RFCs that have broad support are
+  much more likely to make progress than those that don't receive any
+  comments. Feel free to reach out to the maintainers in particular to get
+  help identifying stakeholders and obstacles.
+- The maintainers will discuss the RFC, as much as possible in the Discussion
+  itself. Offline discussion will be summarized in the Discussion.
+- RFCs rarely go through this process unchanged, especially as alternatives
+  and drawbacks are shown. You can make edits, big and small, to the RFC to
+  clarify or change the design, but make changes as new commits to the pull
+  request, and reply in the Discussion with the commit hash and permalinks to
+  the changed lines, explaining your changes. **Specifically, do not squash or
+  rebase commits after they are visible on the pull request.**
+- At some point, a maintainer will propose a "motion for final comment period"
+  (FCP) in the Discussion, along with a *disposition* for the RFC (merge,
+  close, or postpone).
+  - This step is taken when enough of the tradeoffs have been discussed that
+    the maintainers are in a position to make a decision. That does not require
+    consensus amongst all participants in the Discussion (which is usually
+    impossible). However, the argument supporting the disposition on the RFC
+    needs to have already been clearly articulated, and there should not be a
+    strong consensus *against* that position outside of the maintainers.
+    Maintainers use their best judgment in taking this step, and the FCP itself
+    ensures there is ample time and notification for stakeholders to push
+    back if it is made prematurely.
+  - For RFCs with lengthy discussion, the motion to FCP is usually preceded by
+    a *summary comment* trying to lay out the current state of the discussion
+    and major tradeoffs/points of disagreement.
+  - Before actually entering FCP, the maintainers must sign off; this is often
+    the point at which many of them first review the RFC in full depth.
+- The FCP lasts ten calendar days, so that it is open for at least 5 business
+  days. It is also advertised on the [dev mailing list]. This way all
+  stakeholders have a chance to lodge any final objections before a decision
+  is reached.
+- In most cases, the FCP period is quiet, and the RFC is either merged or
+  closed. However, sometimes substantial new arguments or ideas are raised,
+  the FCP is canceled, and the RFC goes back into development mode.
+
+## RFC numbering
+
+[RFC numbering]: #rfc-numbering
+
+RFC numbers are small sequential integers without zero padding, assigned when
+an RFC is accepted, so the first RFC is `rfc-1`. Whoever merges the pull request
+renames `rfcs/rfc-0-my-feature.md` to the next free number, for example
+`rfcs/rfc-7-my-feature.md`, fills in the "Iggy Issue" link with the tracking
+issue opened for the implementation, and marks the Discussion as answered with
+links to the merged RFC and that issue.
+
+Pull request numbers are not used as RFC numbers because this repository's
+counter is shared with every other pull request, which would make RFC numbers
+large, sparse, and meaningless as a sequence. While an RFC is under review it
+is referred to by its feature name.
+
+## The RFC life-cycle
+
+[The RFC life-cycle]: #the-rfc-life-cycle
+
+Once an RFC becomes "active" then authors may implement it and submit the
+feature as a pull request to the Iggy repository. Being "active" is not a
+rubber stamp, and in particular still does not mean the feature will ultimately
+be merged; it does mean that in principle all the major stakeholders have
+agreed to the feature and are amenable to merging it.
+
+Furthermore, the fact that a given RFC has been accepted and is "active"
+implies nothing about what priority is assigned to its implementation, nor does
+it imply anything about whether an Iggy developer has been assigned the task of
+implementing the feature. While it is not *necessary* that the author of the
+RFC also write the implementation, it is by far the most effective way to see
+an RFC through to completion: authors should not expect that other project
+developers will take on responsibility for implementing their accepted feature.
+
+Modifications to "active" RFCs can be done in follow-up pull requests. We
+strive to write each RFC in a manner that it will reflect the final design of
+the feature; but the nature of the process means that we cannot expect every
+merged RFC to actually reflect what the end result will be at the time of the
+next major release.
+
+In general, once accepted, RFCs should not be substantially changed. Only very
+minor changes should be submitted as amendments. More substantial changes
+should be new RFCs, with a note added to the original RFC. Exactly what counts
+as a "very minor change" is up to the maintainers to decide.
+
+## Reviewing RFCs
+
+[Reviewing RFCs]: #reviewing-rfcs
+
+While the RFC is open, the maintainers may schedule a call with the author
+and/or relevant stakeholders to discuss the issues in greater detail, or
+discuss the topic on Discord. In either case a summary will be posted back to
+the RFC's Discussion.
+
+The maintainers make final decisions about RFCs after the benefits and
+drawbacks are well understood. These decisions can be made at any time, but the
+maintainers will regularly issue decisions. When a decision is made, the RFC
+pull request will either be merged or closed. In either case, if the reasoning
+is not clear from the Discussion, the maintainers will add a comment there
+describing the rationale for the decision.
+
+## Implementing an RFC
+
+[Implementing an RFC]: #implementing-an-rfc
+
+Some accepted RFCs represent vital features that need to be implemented right
+away. Other accepted RFCs can represent features that can wait until some
+arbitrary developer feels like doing the work. Every accepted RFC has an
+associated issue tracking its implementation in the Iggy repository; thus that
+associated issue can be assigned a priority via the triage process that the
+maintainers use for all issues in the Iggy repository.
+
+The author of an RFC is not obligated to implement it. Of course, the RFC
+author (like any other developer) is welcome to post an implementation for
+review after the RFC has been accepted.
+
+If you are interested in working on the implementation for an "active" RFC, but
+cannot determine if someone else is already working on it, feel free to ask
+(e.g. by leaving a comment on the associated issue).
+
+### Help this is all too informal

Review Comment:
   nit: "help this is all too informal" is an h3 under "implementing an rfc", but the flat toc lists it as a peer. promote it to h2 or nest the entry.



##########
rfcs/README.md:
##########
@@ -0,0 +1,266 @@
+<!-- markdownlint-disable MD053 -->
+
+# Iggy RFCs
+
+[Iggy RFCs]: #iggy-rfcs
+
+The "RFC" (request for comments) process is intended to provide a consistent
+and controlled path for changes to Iggy (such as new features) so that all
+stakeholders can be confident about the direction of the project.
+
+Many changes, including bug fixes and documentation improvements can be
+implemented and reviewed via the normal GitHub pull request workflow.
+
+Some changes though are "substantial", and we ask that these be put through a
+bit of a design process and produce a consensus among the Iggy community and
+the [maintainers].
+
+## Table of Contents
+
+[Table of Contents]: #table-of-contents
+
+- [Opening](#iggy-rfcs)
+- [Table of Contents]
+- [When you need to follow this process]
+- [Before creating an RFC]
+- [What the process is]
+- [RFC numbering]
+- [The RFC life-cycle]
+- [Reviewing RFCs]
+- [Implementing an RFC]
+- [RFC Postponement]
+- [Help this is all too informal]
+- [License]
+- [Contributions]
+
+## When you need to follow this process
+
+[When you need to follow this process]: #when-you-need-to-follow-this-process
+
+You need to follow this process if you intend to make "substantial" changes to
+the Iggy server, the wire protocol, the SDKs, the connectors runtime, or the RFC
+process itself. What constitutes a "substantial" change is evolving based on
+community norms and varies depending on what part of the project you are
+proposing to change, but may include the following.
+
+- Any change to the wire protocol or the on-disk format that is not a bugfix.
+- A new storage, replication, or consumption model, or a change to how an
+  existing one behaves.
+- Removing features, including those behind a feature flag.
+- Large additions to the SDK surface that every SDK must then implement.
+
+Some changes do not require an RFC:
+
+- Rephrasing, reorganizing, refactoring, or otherwise "changing shape does
+  not change meaning".
+- Additions that strictly improve objective, numerical quality criteria
+  (warning removal, speedup, better platform coverage, more parallelism, trap
+  more errors, etc.)
+- Additions only likely to be *noticed by* other developers-of-iggy,
+  invisible to users-of-iggy.
+
+If you submit a pull request to implement a new feature without going through
+the RFC process, it may be closed with a polite request to submit an RFC first.
+
+## Before creating an RFC
+
+[Before creating an RFC]: #before-creating-an-rfc
+
+A hastily-proposed RFC can hurt its chances of acceptance. Low quality
+proposals, proposals for previously-rejected features, or those that don't fit
+into the near-term roadmap, may be quickly rejected, which can be demotivating
+for the unprepared contributor. Laying some groundwork ahead of the RFC can
+make the process smoother.
+
+Although there is no single way to prepare for submitting an RFC, it is
+generally a good idea to pursue feedback from other project developers
+beforehand, to ascertain that the RFC may be desirable; having a consistent
+impact on the project requires concerted effort toward consensus-building.
+
+The most common preparations for writing and submitting an RFC include talking
+the idea over on our [Discord server], discussing the topic in [GitHub
+Discussions], and occasionally posting "pre-RFCs" there. A pre-RFC thread is
+separate from the RFC's own Discussion, which is opened later, once the text
+exists and has had its initial review. You may file issues on this repo for
+discussion, but these are not actively looked at by the maintainers.
+
+As a rule of thumb, receiving encouraging feedback from long-standing project
+developers, and particularly from the [maintainers], is a good indication that
+the RFC is worth pursuing.
+
+## What the process is
+
+[What the process is]: #what-the-process-is
+
+In short, to get a major feature added to Iggy, one must first get the RFC
+merged into the `rfcs/` directory of this repository as a markdown file. At
+that point the RFC is "active" and may be implemented with the goal of eventual
+inclusion into Iggy.
+
+- Fork the [Iggy repository].
+- Copy `rfcs/rfc-template.md` to `rfcs/rfc-0-my-feature.md` (where
+  "my-feature" is descriptive). Don't assign an RFC number yet; `0` marks an
+  unassigned number, and one is assigned when the RFC is accepted and the file
+  is renamed accordingly. See [RFC numbering].
+- Fill in the RFC. Put care into the details: RFCs that do not present
+  convincing motivation, demonstrate lack of understanding of the design's
+  impact, or are disingenuous about the drawbacks or alternatives tend to
+  be poorly-received.
+- Submit a pull request titled `rfc(<scope>): <subject>`, where the scope is
+  one of those accepted by the PR title check. The pull request carries the
+  text. A maintainer gives it an initial review within a week: whether the

Review Comment:
   nit: a negative answer to the review questions has no stated outcome, and no marker defines "ready for discussion". name the outcome and the marker.



##########
rfcs/README.md:
##########
@@ -0,0 +1,266 @@
+<!-- markdownlint-disable MD053 -->
+
+# Iggy RFCs
+
+[Iggy RFCs]: #iggy-rfcs
+
+The "RFC" (request for comments) process is intended to provide a consistent
+and controlled path for changes to Iggy (such as new features) so that all
+stakeholders can be confident about the direction of the project.
+
+Many changes, including bug fixes and documentation improvements can be
+implemented and reviewed via the normal GitHub pull request workflow.
+
+Some changes though are "substantial", and we ask that these be put through a
+bit of a design process and produce a consensus among the Iggy community and
+the [maintainers].
+
+## Table of Contents
+
+[Table of Contents]: #table-of-contents
+
+- [Opening](#iggy-rfcs)
+- [Table of Contents]
+- [When you need to follow this process]
+- [Before creating an RFC]
+- [What the process is]
+- [RFC numbering]
+- [The RFC life-cycle]
+- [Reviewing RFCs]
+- [Implementing an RFC]
+- [RFC Postponement]
+- [Help this is all too informal]
+- [License]
+- [Contributions]
+
+## When you need to follow this process
+
+[When you need to follow this process]: #when-you-need-to-follow-this-process
+
+You need to follow this process if you intend to make "substantial" changes to
+the Iggy server, the wire protocol, the SDKs, the connectors runtime, or the RFC
+process itself. What constitutes a "substantial" change is evolving based on
+community norms and varies depending on what part of the project you are
+proposing to change, but may include the following.
+
+- Any change to the wire protocol or the on-disk format that is not a bugfix.
+- A new storage, replication, or consumption model, or a change to how an
+  existing one behaves.
+- Removing features, including those behind a feature flag.
+- Large additions to the SDK surface that every SDK must then implement.
+
+Some changes do not require an RFC:
+
+- Rephrasing, reorganizing, refactoring, or otherwise "changing shape does
+  not change meaning".
+- Additions that strictly improve objective, numerical quality criteria
+  (warning removal, speedup, better platform coverage, more parallelism, trap
+  more errors, etc.)
+- Additions only likely to be *noticed by* other developers-of-iggy,
+  invisible to users-of-iggy.
+
+If you submit a pull request to implement a new feature without going through
+the RFC process, it may be closed with a polite request to submit an RFC first.
+
+## Before creating an RFC
+
+[Before creating an RFC]: #before-creating-an-rfc
+
+A hastily-proposed RFC can hurt its chances of acceptance. Low quality
+proposals, proposals for previously-rejected features, or those that don't fit
+into the near-term roadmap, may be quickly rejected, which can be demotivating
+for the unprepared contributor. Laying some groundwork ahead of the RFC can
+make the process smoother.
+
+Although there is no single way to prepare for submitting an RFC, it is
+generally a good idea to pursue feedback from other project developers
+beforehand, to ascertain that the RFC may be desirable; having a consistent
+impact on the project requires concerted effort toward consensus-building.
+
+The most common preparations for writing and submitting an RFC include talking
+the idea over on our [Discord server], discussing the topic in [GitHub
+Discussions], and occasionally posting "pre-RFCs" there. A pre-RFC thread is
+separate from the RFC's own Discussion, which is opened later, once the text
+exists and has had its initial review. You may file issues on this repo for
+discussion, but these are not actively looked at by the maintainers.
+
+As a rule of thumb, receiving encouraging feedback from long-standing project
+developers, and particularly from the [maintainers], is a good indication that
+the RFC is worth pursuing.
+
+## What the process is
+
+[What the process is]: #what-the-process-is
+
+In short, to get a major feature added to Iggy, one must first get the RFC
+merged into the `rfcs/` directory of this repository as a markdown file. At
+that point the RFC is "active" and may be implemented with the goal of eventual
+inclusion into Iggy.
+
+- Fork the [Iggy repository].
+- Copy `rfcs/rfc-template.md` to `rfcs/rfc-0-my-feature.md` (where
+  "my-feature" is descriptive). Don't assign an RFC number yet; `0` marks an
+  unassigned number, and one is assigned when the RFC is accepted and the file
+  is renamed accordingly. See [RFC numbering].
+- Fill in the RFC. Put care into the details: RFCs that do not present
+  convincing motivation, demonstrate lack of understanding of the design's
+  impact, or are disingenuous about the drawbacks or alternatives tend to
+  be poorly-received.
+- Submit a pull request titled `rfc(<scope>): <subject>`, where the scope is

Review Comment:
   nit: this names the pr title check but not the rule for a scope that matches nothing. point at the scope rule in CONTRIBUTING.md.



##########
rfcs/rfc-template.md:
##########
@@ -0,0 +1,91 @@
+<!-- markdownlint-disable MD053 -->

Review Comment:
   simplification: this md053 disable hides eight unused link definitions, and every rfc copied from the template inherits them. delete the definitions, their blank lines, and the disable.



##########
rfcs/README.md:
##########
@@ -0,0 +1,266 @@
+<!-- markdownlint-disable MD053 -->
+
+# Iggy RFCs
+
+[Iggy RFCs]: #iggy-rfcs
+
+The "RFC" (request for comments) process is intended to provide a consistent
+and controlled path for changes to Iggy (such as new features) so that all
+stakeholders can be confident about the direction of the project.
+
+Many changes, including bug fixes and documentation improvements can be
+implemented and reviewed via the normal GitHub pull request workflow.
+
+Some changes though are "substantial", and we ask that these be put through a
+bit of a design process and produce a consensus among the Iggy community and
+the [maintainers].
+
+## Table of Contents
+
+[Table of Contents]: #table-of-contents
+
+- [Opening](#iggy-rfcs)
+- [Table of Contents]
+- [When you need to follow this process]
+- [Before creating an RFC]
+- [What the process is]
+- [RFC numbering]
+- [The RFC life-cycle]
+- [Reviewing RFCs]
+- [Implementing an RFC]
+- [RFC Postponement]
+- [Help this is all too informal]
+- [License]
+- [Contributions]
+
+## When you need to follow this process
+
+[When you need to follow this process]: #when-you-need-to-follow-this-process
+
+You need to follow this process if you intend to make "substantial" changes to
+the Iggy server, the wire protocol, the SDKs, the connectors runtime, or the RFC
+process itself. What constitutes a "substantial" change is evolving based on
+community norms and varies depending on what part of the project you are
+proposing to change, but may include the following.
+
+- Any change to the wire protocol or the on-disk format that is not a bugfix.
+- A new storage, replication, or consumption model, or a change to how an
+  existing one behaves.
+- Removing features, including those behind a feature flag.
+- Large additions to the SDK surface that every SDK must then implement.
+
+Some changes do not require an RFC:
+
+- Rephrasing, reorganizing, refactoring, or otherwise "changing shape does
+  not change meaning".
+- Additions that strictly improve objective, numerical quality criteria
+  (warning removal, speedup, better platform coverage, more parallelism, trap
+  more errors, etc.)
+- Additions only likely to be *noticed by* other developers-of-iggy,
+  invisible to users-of-iggy.
+
+If you submit a pull request to implement a new feature without going through
+the RFC process, it may be closed with a polite request to submit an RFC first.
+
+## Before creating an RFC
+
+[Before creating an RFC]: #before-creating-an-rfc
+
+A hastily-proposed RFC can hurt its chances of acceptance. Low quality
+proposals, proposals for previously-rejected features, or those that don't fit
+into the near-term roadmap, may be quickly rejected, which can be demotivating
+for the unprepared contributor. Laying some groundwork ahead of the RFC can
+make the process smoother.
+
+Although there is no single way to prepare for submitting an RFC, it is
+generally a good idea to pursue feedback from other project developers
+beforehand, to ascertain that the RFC may be desirable; having a consistent
+impact on the project requires concerted effort toward consensus-building.
+
+The most common preparations for writing and submitting an RFC include talking
+the idea over on our [Discord server], discussing the topic in [GitHub
+Discussions], and occasionally posting "pre-RFCs" there. A pre-RFC thread is
+separate from the RFC's own Discussion, which is opened later, once the text
+exists and has had its initial review. You may file issues on this repo for
+discussion, but these are not actively looked at by the maintainers.
+
+As a rule of thumb, receiving encouraging feedback from long-standing project
+developers, and particularly from the [maintainers], is a good indication that
+the RFC is worth pursuing.
+
+## What the process is
+
+[What the process is]: #what-the-process-is
+
+In short, to get a major feature added to Iggy, one must first get the RFC
+merged into the `rfcs/` directory of this repository as a markdown file. At
+that point the RFC is "active" and may be implemented with the goal of eventual
+inclusion into Iggy.
+
+- Fork the [Iggy repository].
+- Copy `rfcs/rfc-template.md` to `rfcs/rfc-0-my-feature.md` (where
+  "my-feature" is descriptive). Don't assign an RFC number yet; `0` marks an
+  unassigned number, and one is assigned when the RFC is accepted and the file
+  is renamed accordingly. See [RFC numbering].
+- Fill in the RFC. Put care into the details: RFCs that do not present
+  convincing motivation, demonstrate lack of understanding of the design's
+  impact, or are disingenuous about the drawbacks or alternatives tend to
+  be poorly-received.
+- Submit a pull request titled `rfc(<scope>): <subject>`, where the scope is
+  one of those accepted by the PR title check. The pull request carries the
+  text. A maintainer gives it an initial review within a week: whether the
+  change needs an RFC at all, whether the text is complete enough to debate,
+  and editorial comments on the writing.
+- Now that your RFC has an open pull request, update the "RFC PR" link at the
+  top of the file to point at it.
+- Once a maintainer marks the RFC ready for discussion, open a GitHub
+  Discussion in the RFCs category titled `RFC: <feature>`, linking the pull
+  request and quoting the summary, and update the "Discussion" link at the top
+  of the file to point at it. The Discussion is where the design is debated;
+  the pull request keeps editorial review.
+- Build consensus and integrate feedback. RFCs that have broad support are
+  much more likely to make progress than those that don't receive any
+  comments. Feel free to reach out to the maintainers in particular to get
+  help identifying stakeholders and obstacles.
+- The maintainers will discuss the RFC, as much as possible in the Discussion
+  itself. Offline discussion will be summarized in the Discussion.
+- RFCs rarely go through this process unchanged, especially as alternatives
+  and drawbacks are shown. You can make edits, big and small, to the RFC to
+  clarify or change the design, but make changes as new commits to the pull
+  request, and reply in the Discussion with the commit hash and permalinks to
+  the changed lines, explaining your changes. **Specifically, do not squash or
+  rebase commits after they are visible on the pull request.**
+- At some point, a maintainer will propose a "motion for final comment period"
+  (FCP) in the Discussion, along with a *disposition* for the RFC (merge,
+  close, or postpone).
+  - This step is taken when enough of the tradeoffs have been discussed that
+    the maintainers are in a position to make a decision. That does not require
+    consensus amongst all participants in the Discussion (which is usually
+    impossible). However, the argument supporting the disposition on the RFC
+    needs to have already been clearly articulated, and there should not be a
+    strong consensus *against* that position outside of the maintainers.
+    Maintainers use their best judgment in taking this step, and the FCP itself
+    ensures there is ample time and notification for stakeholders to push
+    back if it is made prematurely.
+  - For RFCs with lengthy discussion, the motion to FCP is usually preceded by
+    a *summary comment* trying to lay out the current state of the discussion
+    and major tradeoffs/points of disagreement.
+  - Before actually entering FCP, the maintainers must sign off; this is often
+    the point at which many of them first review the RFC in full depth.
+- The FCP lasts ten calendar days, so that it is open for at least 5 business

Review Comment:
   simplification: the fcp post already reaches dev@ through the discussion mirror, so the separate announcement step is redundant. drop the sentence.



##########
CONTRIBUTING.md:
##########
@@ -162,6 +162,13 @@ chore(integration): remove streaming tests superseded by API-level coverage
 
 Keep subject under 72 chars. Use body for details if needed.
 
+A pull request that adds or amends an RFC under `rfcs/` uses the type `rfc`

Review Comment:
   simplification: this paragraph repeats the title rule and discussion timing from rfcs/README.md. keep a short pointer, and keep the scope-list rule at line 168.



##########
rfcs/rfc-template.md:
##########
@@ -0,0 +1,91 @@
+<!-- markdownlint-disable MD053 -->
+
+- Feature Name: (fill me in with a unique ident, `my_awesome_feature`)
+- Start Date: (fill me in with today's date, YYYY-MM-DD)
+- RFC PR: [apache/iggy#0000](https://github.com/apache/iggy/pull/0000)
+- Discussion: [apache/iggy#0000](https://github.com/apache/iggy/discussions/0000)
+- Iggy Issue: [apache/iggy#0000](https://github.com/apache/iggy/issues/0000)
+
+## Summary
+
+[summary]: #summary
+
+One paragraph explanation of the feature.
+
+## Motivation
+
+[motivation]: #motivation
+
+Any changes to Iggy should focus on solving a problem that users of Iggy are having.
+This section should explain this problem in detail, including necessary background.
+
+It should also contain several specific use cases where this feature can help a user, and explain how it helps.
+This can then be used to guide the design of the feature.
+
+This section is one of the most important sections of any RFC, and can be lengthy.
+
+## Guide-level explanation
+
+[guide-level-explanation]: #guide-level-explanation
+
+Explain the proposal as if it was already included in Iggy and you were teaching it to another Iggy user. That generally means:
+
+- Introducing new named concepts.
+- Explaining the feature largely in terms of examples.
+- Explaining how Iggy users should *think* about the feature, and how it should impact the way they use Iggy. It should explain the impact as concretely as possible.
+- If applicable, provide sample error messages, deprecation warnings, or migration guidance.
+- If applicable, describe the differences between teaching this to existing Iggy users and new Iggy users.
+- Discuss how this impacts the ability to read, understand, and maintain Iggy code. Code is read and modified far more often than written; will the proposed feature make code easier to maintain?
+
+For implementation-oriented RFCs (e.g. for server internals), this section should focus on how Iggy contributors should think about the change, and give examples of its concrete impact. For policy RFCs, this section should provide an example-driven introduction to the policy, and explain its impact in concrete terms.
+
+## Reference-level explanation
+
+[reference-level-explanation]: #reference-level-explanation
+
+This is the technical portion of the RFC. Explain the design in sufficient detail that:

Review Comment:
   nit: the reference-level section asks for corner cases but not failure behavior, crash recovery, or format compatibility. add one bullet for failure modes and compatibility.



##########
rfcs/README.md:
##########
@@ -0,0 +1,266 @@
+<!-- markdownlint-disable MD053 -->
+
+# Iggy RFCs
+
+[Iggy RFCs]: #iggy-rfcs
+
+The "RFC" (request for comments) process is intended to provide a consistent
+and controlled path for changes to Iggy (such as new features) so that all
+stakeholders can be confident about the direction of the project.
+
+Many changes, including bug fixes and documentation improvements can be
+implemented and reviewed via the normal GitHub pull request workflow.
+
+Some changes though are "substantial", and we ask that these be put through a
+bit of a design process and produce a consensus among the Iggy community and
+the [maintainers].
+
+## Table of Contents
+
+[Table of Contents]: #table-of-contents
+
+- [Opening](#iggy-rfcs)
+- [Table of Contents]
+- [When you need to follow this process]
+- [Before creating an RFC]
+- [What the process is]
+- [RFC numbering]
+- [The RFC life-cycle]
+- [Reviewing RFCs]
+- [Implementing an RFC]
+- [RFC Postponement]
+- [Help this is all too informal]
+- [License]
+- [Contributions]
+
+## When you need to follow this process
+
+[When you need to follow this process]: #when-you-need-to-follow-this-process
+
+You need to follow this process if you intend to make "substantial" changes to
+the Iggy server, the wire protocol, the SDKs, the connectors runtime, or the RFC
+process itself. What constitutes a "substantial" change is evolving based on
+community norms and varies depending on what part of the project you are
+proposing to change, but may include the following.
+
+- Any change to the wire protocol or the on-disk format that is not a bugfix.
+- A new storage, replication, or consumption model, or a change to how an
+  existing one behaves.
+- Removing features, including those behind a feature flag.
+- Large additions to the SDK surface that every SDK must then implement.
+
+Some changes do not require an RFC:
+
+- Rephrasing, reorganizing, refactoring, or otherwise "changing shape does
+  not change meaning".
+- Additions that strictly improve objective, numerical quality criteria
+  (warning removal, speedup, better platform coverage, more parallelism, trap
+  more errors, etc.)
+- Additions only likely to be *noticed by* other developers-of-iggy,
+  invisible to users-of-iggy.
+
+If you submit a pull request to implement a new feature without going through
+the RFC process, it may be closed with a polite request to submit an RFC first.
+
+## Before creating an RFC
+
+[Before creating an RFC]: #before-creating-an-rfc
+
+A hastily-proposed RFC can hurt its chances of acceptance. Low quality
+proposals, proposals for previously-rejected features, or those that don't fit
+into the near-term roadmap, may be quickly rejected, which can be demotivating
+for the unprepared contributor. Laying some groundwork ahead of the RFC can
+make the process smoother.
+
+Although there is no single way to prepare for submitting an RFC, it is
+generally a good idea to pursue feedback from other project developers
+beforehand, to ascertain that the RFC may be desirable; having a consistent
+impact on the project requires concerted effort toward consensus-building.
+
+The most common preparations for writing and submitting an RFC include talking
+the idea over on our [Discord server], discussing the topic in [GitHub
+Discussions], and occasionally posting "pre-RFCs" there. A pre-RFC thread is
+separate from the RFC's own Discussion, which is opened later, once the text
+exists and has had its initial review. You may file issues on this repo for
+discussion, but these are not actively looked at by the maintainers.
+
+As a rule of thumb, receiving encouraging feedback from long-standing project
+developers, and particularly from the [maintainers], is a good indication that
+the RFC is worth pursuing.
+
+## What the process is
+
+[What the process is]: #what-the-process-is
+
+In short, to get a major feature added to Iggy, one must first get the RFC
+merged into the `rfcs/` directory of this repository as a markdown file. At
+that point the RFC is "active" and may be implemented with the goal of eventual
+inclusion into Iggy.
+
+- Fork the [Iggy repository].
+- Copy `rfcs/rfc-template.md` to `rfcs/rfc-0-my-feature.md` (where
+  "my-feature" is descriptive). Don't assign an RFC number yet; `0` marks an
+  unassigned number, and one is assigned when the RFC is accepted and the file
+  is renamed accordingly. See [RFC numbering].
+- Fill in the RFC. Put care into the details: RFCs that do not present
+  convincing motivation, demonstrate lack of understanding of the design's
+  impact, or are disingenuous about the drawbacks or alternatives tend to
+  be poorly-received.
+- Submit a pull request titled `rfc(<scope>): <subject>`, where the scope is
+  one of those accepted by the PR title check. The pull request carries the
+  text. A maintainer gives it an initial review within a week: whether the
+  change needs an RFC at all, whether the text is complete enough to debate,
+  and editorial comments on the writing.
+- Now that your RFC has an open pull request, update the "RFC PR" link at the
+  top of the file to point at it.
+- Once a maintainer marks the RFC ready for discussion, open a GitHub
+  Discussion in the RFCs category titled `RFC: <feature>`, linking the pull
+  request and quoting the summary, and update the "Discussion" link at the top
+  of the file to point at it. The Discussion is where the design is debated;
+  the pull request keeps editorial review.
+- Build consensus and integrate feedback. RFCs that have broad support are
+  much more likely to make progress than those that don't receive any
+  comments. Feel free to reach out to the maintainers in particular to get
+  help identifying stakeholders and obstacles.
+- The maintainers will discuss the RFC, as much as possible in the Discussion
+  itself. Offline discussion will be summarized in the Discussion.
+- RFCs rarely go through this process unchanged, especially as alternatives
+  and drawbacks are shown. You can make edits, big and small, to the RFC to
+  clarify or change the design, but make changes as new commits to the pull
+  request, and reply in the Discussion with the commit hash and permalinks to
+  the changed lines, explaining your changes. **Specifically, do not squash or
+  rebase commits after they are visible on the pull request.**
+- At some point, a maintainer will propose a "motion for final comment period"
+  (FCP) in the Discussion, along with a *disposition* for the RFC (merge,
+  close, or postpone).
+  - This step is taken when enough of the tradeoffs have been discussed that
+    the maintainers are in a position to make a decision. That does not require
+    consensus amongst all participants in the Discussion (which is usually
+    impossible). However, the argument supporting the disposition on the RFC
+    needs to have already been clearly articulated, and there should not be a
+    strong consensus *against* that position outside of the maintainers.
+    Maintainers use their best judgment in taking this step, and the FCP itself
+    ensures there is ample time and notification for stakeholders to push
+    back if it is made prematurely.
+  - For RFCs with lengthy discussion, the motion to FCP is usually preceded by
+    a *summary comment* trying to lay out the current state of the discussion
+    and major tradeoffs/points of disagreement.
+  - Before actually entering FCP, the maintainers must sign off; this is often
+    the point at which many of them first review the RFC in full depth.
+- The FCP lasts ten calendar days, so that it is open for at least 5 business
+  days. It is also advertised on the [dev mailing list]. This way all
+  stakeholders have a chance to lodge any final objections before a decision
+  is reached.
+- In most cases, the FCP period is quiet, and the RFC is either merged or
+  closed. However, sometimes substantial new arguments or ideas are raised,
+  the FCP is canceled, and the RFC goes back into development mode.
+
+## RFC numbering
+
+[RFC numbering]: #rfc-numbering
+
+RFC numbers are small sequential integers without zero padding, assigned when
+an RFC is accepted, so the first RFC is `rfc-1`. Whoever merges the pull request
+renames `rfcs/rfc-0-my-feature.md` to the next free number, for example
+`rfcs/rfc-7-my-feature.md`, fills in the "Iggy Issue" link with the tracking
+issue opened for the implementation, and marks the Discussion as answered with

Review Comment:
   warning: github only allows answers in q&a format categories, so the answered step does not work in a normal category. make the rfc category q&a format, or replace this step with a summary comment.



##########
rfcs/README.md:
##########
@@ -0,0 +1,266 @@
+<!-- markdownlint-disable MD053 -->
+
+# Iggy RFCs
+
+[Iggy RFCs]: #iggy-rfcs
+
+The "RFC" (request for comments) process is intended to provide a consistent
+and controlled path for changes to Iggy (such as new features) so that all
+stakeholders can be confident about the direction of the project.
+
+Many changes, including bug fixes and documentation improvements can be
+implemented and reviewed via the normal GitHub pull request workflow.
+
+Some changes though are "substantial", and we ask that these be put through a
+bit of a design process and produce a consensus among the Iggy community and
+the [maintainers].
+
+## Table of Contents
+
+[Table of Contents]: #table-of-contents
+
+- [Opening](#iggy-rfcs)
+- [Table of Contents]
+- [When you need to follow this process]
+- [Before creating an RFC]
+- [What the process is]
+- [RFC numbering]
+- [The RFC life-cycle]
+- [Reviewing RFCs]
+- [Implementing an RFC]
+- [RFC Postponement]
+- [Help this is all too informal]
+- [License]
+- [Contributions]
+
+## When you need to follow this process
+
+[When you need to follow this process]: #when-you-need-to-follow-this-process
+
+You need to follow this process if you intend to make "substantial" changes to
+the Iggy server, the wire protocol, the SDKs, the connectors runtime, or the RFC
+process itself. What constitutes a "substantial" change is evolving based on
+community norms and varies depending on what part of the project you are
+proposing to change, but may include the following.
+
+- Any change to the wire protocol or the on-disk format that is not a bugfix.
+- A new storage, replication, or consumption model, or a change to how an
+  existing one behaves.
+- Removing features, including those behind a feature flag.
+- Large additions to the SDK surface that every SDK must then implement.
+
+Some changes do not require an RFC:
+
+- Rephrasing, reorganizing, refactoring, or otherwise "changing shape does
+  not change meaning".
+- Additions that strictly improve objective, numerical quality criteria
+  (warning removal, speedup, better platform coverage, more parallelism, trap
+  more errors, etc.)
+- Additions only likely to be *noticed by* other developers-of-iggy,
+  invisible to users-of-iggy.
+
+If you submit a pull request to implement a new feature without going through
+the RFC process, it may be closed with a polite request to submit an RFC first.
+
+## Before creating an RFC
+
+[Before creating an RFC]: #before-creating-an-rfc
+
+A hastily-proposed RFC can hurt its chances of acceptance. Low quality
+proposals, proposals for previously-rejected features, or those that don't fit
+into the near-term roadmap, may be quickly rejected, which can be demotivating
+for the unprepared contributor. Laying some groundwork ahead of the RFC can
+make the process smoother.
+
+Although there is no single way to prepare for submitting an RFC, it is
+generally a good idea to pursue feedback from other project developers
+beforehand, to ascertain that the RFC may be desirable; having a consistent
+impact on the project requires concerted effort toward consensus-building.
+
+The most common preparations for writing and submitting an RFC include talking
+the idea over on our [Discord server], discussing the topic in [GitHub
+Discussions], and occasionally posting "pre-RFCs" there. A pre-RFC thread is
+separate from the RFC's own Discussion, which is opened later, once the text
+exists and has had its initial review. You may file issues on this repo for
+discussion, but these are not actively looked at by the maintainers.
+
+As a rule of thumb, receiving encouraging feedback from long-standing project
+developers, and particularly from the [maintainers], is a good indication that
+the RFC is worth pursuing.
+
+## What the process is
+
+[What the process is]: #what-the-process-is
+
+In short, to get a major feature added to Iggy, one must first get the RFC
+merged into the `rfcs/` directory of this repository as a markdown file. At
+that point the RFC is "active" and may be implemented with the goal of eventual
+inclusion into Iggy.
+
+- Fork the [Iggy repository].
+- Copy `rfcs/rfc-template.md` to `rfcs/rfc-0-my-feature.md` (where
+  "my-feature" is descriptive). Don't assign an RFC number yet; `0` marks an
+  unassigned number, and one is assigned when the RFC is accepted and the file
+  is renamed accordingly. See [RFC numbering].
+- Fill in the RFC. Put care into the details: RFCs that do not present
+  convincing motivation, demonstrate lack of understanding of the design's
+  impact, or are disingenuous about the drawbacks or alternatives tend to
+  be poorly-received.
+- Submit a pull request titled `rfc(<scope>): <subject>`, where the scope is
+  one of those accepted by the PR title check. The pull request carries the
+  text. A maintainer gives it an initial review within a week: whether the
+  change needs an RFC at all, whether the text is complete enough to debate,
+  and editorial comments on the writing.
+- Now that your RFC has an open pull request, update the "RFC PR" link at the
+  top of the file to point at it.
+- Once a maintainer marks the RFC ready for discussion, open a GitHub
+  Discussion in the RFCs category titled `RFC: <feature>`, linking the pull
+  request and quoting the summary, and update the "Discussion" link at the top
+  of the file to point at it. The Discussion is where the design is debated;
+  the pull request keeps editorial review.
+- Build consensus and integrate feedback. RFCs that have broad support are
+  much more likely to make progress than those that don't receive any
+  comments. Feel free to reach out to the maintainers in particular to get
+  help identifying stakeholders and obstacles.
+- The maintainers will discuss the RFC, as much as possible in the Discussion
+  itself. Offline discussion will be summarized in the Discussion.
+- RFCs rarely go through this process unchanged, especially as alternatives
+  and drawbacks are shown. You can make edits, big and small, to the RFC to
+  clarify or change the design, but make changes as new commits to the pull
+  request, and reply in the Discussion with the commit hash and permalinks to
+  the changed lines, explaining your changes. **Specifically, do not squash or
+  rebase commits after they are visible on the pull request.**
+- At some point, a maintainer will propose a "motion for final comment period"
+  (FCP) in the Discussion, along with a *disposition* for the RFC (merge,
+  close, or postpone).
+  - This step is taken when enough of the tradeoffs have been discussed that
+    the maintainers are in a position to make a decision. That does not require
+    consensus amongst all participants in the Discussion (which is usually
+    impossible). However, the argument supporting the disposition on the RFC
+    needs to have already been clearly articulated, and there should not be a
+    strong consensus *against* that position outside of the maintainers.
+    Maintainers use their best judgment in taking this step, and the FCP itself
+    ensures there is ample time and notification for stakeholders to push
+    back if it is made prematurely.
+  - For RFCs with lengthy discussion, the motion to FCP is usually preceded by
+    a *summary comment* trying to lay out the current state of the discussion
+    and major tradeoffs/points of disagreement.
+  - Before actually entering FCP, the maintainers must sign off; this is often

Review Comment:
   nit: the fcp needs sign-offs and a ten-day clock, but nothing says who records sign-offs or who starts and ends the clock. name the owners.



##########
rfcs/README.md:
##########
@@ -0,0 +1,266 @@
+<!-- markdownlint-disable MD053 -->
+
+# Iggy RFCs
+
+[Iggy RFCs]: #iggy-rfcs
+
+The "RFC" (request for comments) process is intended to provide a consistent
+and controlled path for changes to Iggy (such as new features) so that all
+stakeholders can be confident about the direction of the project.
+
+Many changes, including bug fixes and documentation improvements can be
+implemented and reviewed via the normal GitHub pull request workflow.
+
+Some changes though are "substantial", and we ask that these be put through a
+bit of a design process and produce a consensus among the Iggy community and
+the [maintainers].
+
+## Table of Contents
+
+[Table of Contents]: #table-of-contents
+
+- [Opening](#iggy-rfcs)
+- [Table of Contents]
+- [When you need to follow this process]
+- [Before creating an RFC]
+- [What the process is]
+- [RFC numbering]
+- [The RFC life-cycle]
+- [Reviewing RFCs]
+- [Implementing an RFC]
+- [RFC Postponement]
+- [Help this is all too informal]
+- [License]
+- [Contributions]
+
+## When you need to follow this process
+
+[When you need to follow this process]: #when-you-need-to-follow-this-process
+
+You need to follow this process if you intend to make "substantial" changes to
+the Iggy server, the wire protocol, the SDKs, the connectors runtime, or the RFC
+process itself. What constitutes a "substantial" change is evolving based on
+community norms and varies depending on what part of the project you are
+proposing to change, but may include the following.
+
+- Any change to the wire protocol or the on-disk format that is not a bugfix.
+- A new storage, replication, or consumption model, or a change to how an
+  existing one behaves.
+- Removing features, including those behind a feature flag.
+- Large additions to the SDK surface that every SDK must then implement.
+
+Some changes do not require an RFC:
+
+- Rephrasing, reorganizing, refactoring, or otherwise "changing shape does
+  not change meaning".
+- Additions that strictly improve objective, numerical quality criteria
+  (warning removal, speedup, better platform coverage, more parallelism, trap
+  more errors, etc.)
+- Additions only likely to be *noticed by* other developers-of-iggy,
+  invisible to users-of-iggy.
+
+If you submit a pull request to implement a new feature without going through
+the RFC process, it may be closed with a polite request to submit an RFC first.
+
+## Before creating an RFC
+
+[Before creating an RFC]: #before-creating-an-rfc
+
+A hastily-proposed RFC can hurt its chances of acceptance. Low quality
+proposals, proposals for previously-rejected features, or those that don't fit
+into the near-term roadmap, may be quickly rejected, which can be demotivating
+for the unprepared contributor. Laying some groundwork ahead of the RFC can
+make the process smoother.
+
+Although there is no single way to prepare for submitting an RFC, it is
+generally a good idea to pursue feedback from other project developers
+beforehand, to ascertain that the RFC may be desirable; having a consistent
+impact on the project requires concerted effort toward consensus-building.
+
+The most common preparations for writing and submitting an RFC include talking
+the idea over on our [Discord server], discussing the topic in [GitHub
+Discussions], and occasionally posting "pre-RFCs" there. A pre-RFC thread is
+separate from the RFC's own Discussion, which is opened later, once the text
+exists and has had its initial review. You may file issues on this repo for
+discussion, but these are not actively looked at by the maintainers.
+
+As a rule of thumb, receiving encouraging feedback from long-standing project
+developers, and particularly from the [maintainers], is a good indication that
+the RFC is worth pursuing.
+
+## What the process is
+
+[What the process is]: #what-the-process-is
+
+In short, to get a major feature added to Iggy, one must first get the RFC
+merged into the `rfcs/` directory of this repository as a markdown file. At
+that point the RFC is "active" and may be implemented with the goal of eventual
+inclusion into Iggy.
+
+- Fork the [Iggy repository].
+- Copy `rfcs/rfc-template.md` to `rfcs/rfc-0-my-feature.md` (where
+  "my-feature" is descriptive). Don't assign an RFC number yet; `0` marks an
+  unassigned number, and one is assigned when the RFC is accepted and the file
+  is renamed accordingly. See [RFC numbering].
+- Fill in the RFC. Put care into the details: RFCs that do not present
+  convincing motivation, demonstrate lack of understanding of the design's
+  impact, or are disingenuous about the drawbacks or alternatives tend to
+  be poorly-received.
+- Submit a pull request titled `rfc(<scope>): <subject>`, where the scope is
+  one of those accepted by the PR title check. The pull request carries the
+  text. A maintainer gives it an initial review within a week: whether the
+  change needs an RFC at all, whether the text is complete enough to debate,
+  and editorial comments on the writing.
+- Now that your RFC has an open pull request, update the "RFC PR" link at the
+  top of the file to point at it.
+- Once a maintainer marks the RFC ready for discussion, open a GitHub
+  Discussion in the RFCs category titled `RFC: <feature>`, linking the pull
+  request and quoting the summary, and update the "Discussion" link at the top
+  of the file to point at it. The Discussion is where the design is debated;
+  the pull request keeps editorial review.
+- Build consensus and integrate feedback. RFCs that have broad support are
+  much more likely to make progress than those that don't receive any
+  comments. Feel free to reach out to the maintainers in particular to get
+  help identifying stakeholders and obstacles.
+- The maintainers will discuss the RFC, as much as possible in the Discussion
+  itself. Offline discussion will be summarized in the Discussion.
+- RFCs rarely go through this process unchanged, especially as alternatives
+  and drawbacks are shown. You can make edits, big and small, to the RFC to
+  clarify or change the design, but make changes as new commits to the pull
+  request, and reply in the Discussion with the commit hash and permalinks to
+  the changed lines, explaining your changes. **Specifically, do not squash or
+  rebase commits after they are visible on the pull request.**
+- At some point, a maintainer will propose a "motion for final comment period"
+  (FCP) in the Discussion, along with a *disposition* for the RFC (merge,
+  close, or postpone).
+  - This step is taken when enough of the tradeoffs have been discussed that
+    the maintainers are in a position to make a decision. That does not require
+    consensus amongst all participants in the Discussion (which is usually
+    impossible). However, the argument supporting the disposition on the RFC
+    needs to have already been clearly articulated, and there should not be a
+    strong consensus *against* that position outside of the maintainers.
+    Maintainers use their best judgment in taking this step, and the FCP itself
+    ensures there is ample time and notification for stakeholders to push
+    back if it is made prematurely.
+  - For RFCs with lengthy discussion, the motion to FCP is usually preceded by
+    a *summary comment* trying to lay out the current state of the discussion
+    and major tradeoffs/points of disagreement.
+  - Before actually entering FCP, the maintainers must sign off; this is often
+    the point at which many of them first review the RFC in full depth.
+- The FCP lasts ten calendar days, so that it is open for at least 5 business
+  days. It is also advertised on the [dev mailing list]. This way all
+  stakeholders have a chance to lodge any final objections before a decision
+  is reached.
+- In most cases, the FCP period is quiet, and the RFC is either merged or
+  closed. However, sometimes substantial new arguments or ideas are raised,
+  the FCP is canceled, and the RFC goes back into development mode.
+
+## RFC numbering
+
+[RFC numbering]: #rfc-numbering
+
+RFC numbers are small sequential integers without zero padding, assigned when
+an RFC is accepted, so the first RFC is `rfc-1`. Whoever merges the pull request
+renames `rfcs/rfc-0-my-feature.md` to the next free number, for example
+`rfcs/rfc-7-my-feature.md`, fills in the "Iggy Issue" link with the tracking
+issue opened for the implementation, and marks the Discussion as answered with
+links to the merged RFC and that issue.
+
+Pull request numbers are not used as RFC numbers because this repository's
+counter is shared with every other pull request, which would make RFC numbers
+large, sparse, and meaningless as a sequence. While an RFC is under review it
+is referred to by its feature name.
+
+## The RFC life-cycle
+
+[The RFC life-cycle]: #the-rfc-life-cycle
+
+Once an RFC becomes "active" then authors may implement it and submit the
+feature as a pull request to the Iggy repository. Being "active" is not a
+rubber stamp, and in particular still does not mean the feature will ultimately
+be merged; it does mean that in principle all the major stakeholders have
+agreed to the feature and are amenable to merging it.
+
+Furthermore, the fact that a given RFC has been accepted and is "active"
+implies nothing about what priority is assigned to its implementation, nor does
+it imply anything about whether an Iggy developer has been assigned the task of
+implementing the feature. While it is not *necessary* that the author of the
+RFC also write the implementation, it is by far the most effective way to see
+an RFC through to completion: authors should not expect that other project
+developers will take on responsibility for implementing their accepted feature.
+
+Modifications to "active" RFCs can be done in follow-up pull requests. We
+strive to write each RFC in a manner that it will reflect the final design of
+the feature; but the nature of the process means that we cannot expect every
+merged RFC to actually reflect what the end result will be at the time of the
+next major release.
+
+In general, once accepted, RFCs should not be substantially changed. Only very
+minor changes should be submitted as amendments. More substantial changes
+should be new RFCs, with a note added to the original RFC. Exactly what counts
+as a "very minor change" is up to the maintainers to decide.
+
+## Reviewing RFCs
+
+[Reviewing RFCs]: #reviewing-rfcs
+
+While the RFC is open, the maintainers may schedule a call with the author
+and/or relevant stakeholders to discuss the issues in greater detail, or
+discuss the topic on Discord. In either case a summary will be posted back to
+the RFC's Discussion.
+
+The maintainers make final decisions about RFCs after the benefits and
+drawbacks are well understood. These decisions can be made at any time, but the
+maintainers will regularly issue decisions. When a decision is made, the RFC
+pull request will either be merged or closed. In either case, if the reasoning
+is not clear from the Discussion, the maintainers will add a comment there
+describing the rationale for the decision.
+
+## Implementing an RFC
+
+[Implementing an RFC]: #implementing-an-rfc
+
+Some accepted RFCs represent vital features that need to be implemented right
+away. Other accepted RFCs can represent features that can wait until some
+arbitrary developer feels like doing the work. Every accepted RFC has an
+associated issue tracking its implementation in the Iggy repository; thus that
+associated issue can be assigned a priority via the triage process that the
+maintainers use for all issues in the Iggy repository.
+
+The author of an RFC is not obligated to implement it. Of course, the RFC
+author (like any other developer) is welcome to post an implementation for
+review after the RFC has been accepted.
+
+If you are interested in working on the implementation for an "active" RFC, but
+cannot determine if someone else is already working on it, feel free to ask
+(e.g. by leaving a comment on the associated issue).
+
+### Help this is all too informal
+
+[Help this is all too informal]: #help-this-is-all-too-informal
+
+The process is intended to be as lightweight as reasonable for the present
+circumstances. As usual, we are trying to let the process be driven by
+consensus and community norms, not impose more structure than necessary.
+
+## License
+
+[License]: #license
+
+The contents of this directory are licensed under the
+[Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0),
+like the rest of the repository.
+
+### Contributions
+
+[Contributions]: #contributions
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
+licensed as above, without any additional terms or conditions.
+
+[Discord server]: https://discord.gg/apache-iggy
+[GitHub Discussions]: https://github.com/apache/iggy/discussions
+[dev mailing list]: mailto:dev@iggy.apache.org
+[Iggy repository]: https://github.com/apache/iggy
+[maintainers]: https://github.com/apache/iggy/blob/master/.asf.yaml

Review Comment:
   warning: the maintainers link points at `.asf.yaml`, which holds repo configuration and one collaborator, not a maintainer list. point it at the team page or `.github/CODEOWNERS`.



##########
rfcs/README.md:
##########
@@ -0,0 +1,266 @@
+<!-- markdownlint-disable MD053 -->
+
+# Iggy RFCs
+
+[Iggy RFCs]: #iggy-rfcs
+
+The "RFC" (request for comments) process is intended to provide a consistent

Review Comment:
   warning: this file copies the rust-lang/rfcs readme nearly verbatim, and the template copies `0000-template.md`, with no attribution. add one line naming the source and its license.



##########
rfcs/README.md:
##########
@@ -0,0 +1,266 @@
+<!-- markdownlint-disable MD053 -->

Review Comment:
   simplification: this md053 disable hides one unused definition, `[Iggy RFCs]: #iggy-rfcs`. delete it, the disable line, and the extra blank line.



##########
rfcs/README.md:
##########
@@ -0,0 +1,266 @@
+<!-- markdownlint-disable MD053 -->
+
+# Iggy RFCs
+
+[Iggy RFCs]: #iggy-rfcs
+
+The "RFC" (request for comments) process is intended to provide a consistent
+and controlled path for changes to Iggy (such as new features) so that all
+stakeholders can be confident about the direction of the project.
+
+Many changes, including bug fixes and documentation improvements can be
+implemented and reviewed via the normal GitHub pull request workflow.
+
+Some changes though are "substantial", and we ask that these be put through a
+bit of a design process and produce a consensus among the Iggy community and
+the [maintainers].
+
+## Table of Contents
+
+[Table of Contents]: #table-of-contents
+
+- [Opening](#iggy-rfcs)
+- [Table of Contents]
+- [When you need to follow this process]
+- [Before creating an RFC]
+- [What the process is]
+- [RFC numbering]
+- [The RFC life-cycle]
+- [Reviewing RFCs]
+- [Implementing an RFC]
+- [RFC Postponement]
+- [Help this is all too informal]
+- [License]
+- [Contributions]
+
+## When you need to follow this process
+
+[When you need to follow this process]: #when-you-need-to-follow-this-process
+
+You need to follow this process if you intend to make "substantial" changes to
+the Iggy server, the wire protocol, the SDKs, the connectors runtime, or the RFC
+process itself. What constitutes a "substantial" change is evolving based on
+community norms and varies depending on what part of the project you are
+proposing to change, but may include the following.
+
+- Any change to the wire protocol or the on-disk format that is not a bugfix.
+- A new storage, replication, or consumption model, or a change to how an
+  existing one behaves.
+- Removing features, including those behind a feature flag.
+- Large additions to the SDK surface that every SDK must then implement.
+
+Some changes do not require an RFC:
+
+- Rephrasing, reorganizing, refactoring, or otherwise "changing shape does
+  not change meaning".
+- Additions that strictly improve objective, numerical quality criteria
+  (warning removal, speedup, better platform coverage, more parallelism, trap
+  more errors, etc.)
+- Additions only likely to be *noticed by* other developers-of-iggy,
+  invisible to users-of-iggy.
+
+If you submit a pull request to implement a new feature without going through
+the RFC process, it may be closed with a polite request to submit an RFC first.
+
+## Before creating an RFC
+
+[Before creating an RFC]: #before-creating-an-rfc
+
+A hastily-proposed RFC can hurt its chances of acceptance. Low quality
+proposals, proposals for previously-rejected features, or those that don't fit
+into the near-term roadmap, may be quickly rejected, which can be demotivating
+for the unprepared contributor. Laying some groundwork ahead of the RFC can
+make the process smoother.
+
+Although there is no single way to prepare for submitting an RFC, it is
+generally a good idea to pursue feedback from other project developers
+beforehand, to ascertain that the RFC may be desirable; having a consistent
+impact on the project requires concerted effort toward consensus-building.
+
+The most common preparations for writing and submitting an RFC include talking
+the idea over on our [Discord server], discussing the topic in [GitHub
+Discussions], and occasionally posting "pre-RFCs" there. A pre-RFC thread is
+separate from the RFC's own Discussion, which is opened later, once the text
+exists and has had its initial review. You may file issues on this repo for
+discussion, but these are not actively looked at by the maintainers.
+
+As a rule of thumb, receiving encouraging feedback from long-standing project
+developers, and particularly from the [maintainers], is a good indication that
+the RFC is worth pursuing.
+
+## What the process is
+
+[What the process is]: #what-the-process-is
+
+In short, to get a major feature added to Iggy, one must first get the RFC
+merged into the `rfcs/` directory of this repository as a markdown file. At
+that point the RFC is "active" and may be implemented with the goal of eventual
+inclusion into Iggy.
+
+- Fork the [Iggy repository].
+- Copy `rfcs/rfc-template.md` to `rfcs/rfc-0-my-feature.md` (where
+  "my-feature" is descriptive). Don't assign an RFC number yet; `0` marks an
+  unassigned number, and one is assigned when the RFC is accepted and the file
+  is renamed accordingly. See [RFC numbering].
+- Fill in the RFC. Put care into the details: RFCs that do not present
+  convincing motivation, demonstrate lack of understanding of the design's
+  impact, or are disingenuous about the drawbacks or alternatives tend to
+  be poorly-received.
+- Submit a pull request titled `rfc(<scope>): <subject>`, where the scope is
+  one of those accepted by the PR title check. The pull request carries the
+  text. A maintainer gives it an initial review within a week: whether the
+  change needs an RFC at all, whether the text is complete enough to debate,
+  and editorial comments on the writing.
+- Now that your RFC has an open pull request, update the "RFC PR" link at the
+  top of the file to point at it.
+- Once a maintainer marks the RFC ready for discussion, open a GitHub
+  Discussion in the RFCs category titled `RFC: <feature>`, linking the pull
+  request and quoting the summary, and update the "Discussion" link at the top
+  of the file to point at it. The Discussion is where the design is debated;
+  the pull request keeps editorial review.
+- Build consensus and integrate feedback. RFCs that have broad support are
+  much more likely to make progress than those that don't receive any
+  comments. Feel free to reach out to the maintainers in particular to get
+  help identifying stakeholders and obstacles.
+- The maintainers will discuss the RFC, as much as possible in the Discussion
+  itself. Offline discussion will be summarized in the Discussion.
+- RFCs rarely go through this process unchanged, especially as alternatives
+  and drawbacks are shown. You can make edits, big and small, to the RFC to
+  clarify or change the design, but make changes as new commits to the pull
+  request, and reply in the Discussion with the commit hash and permalinks to
+  the changed lines, explaining your changes. **Specifically, do not squash or
+  rebase commits after they are visible on the pull request.**
+- At some point, a maintainer will propose a "motion for final comment period"
+  (FCP) in the Discussion, along with a *disposition* for the RFC (merge,
+  close, or postpone).
+  - This step is taken when enough of the tradeoffs have been discussed that
+    the maintainers are in a position to make a decision. That does not require
+    consensus amongst all participants in the Discussion (which is usually
+    impossible). However, the argument supporting the disposition on the RFC
+    needs to have already been clearly articulated, and there should not be a
+    strong consensus *against* that position outside of the maintainers.
+    Maintainers use their best judgment in taking this step, and the FCP itself
+    ensures there is ample time and notification for stakeholders to push
+    back if it is made prematurely.
+  - For RFCs with lengthy discussion, the motion to FCP is usually preceded by
+    a *summary comment* trying to lay out the current state of the discussion
+    and major tradeoffs/points of disagreement.
+  - Before actually entering FCP, the maintainers must sign off; this is often
+    the point at which many of them first review the RFC in full depth.
+- The FCP lasts ten calendar days, so that it is open for at least 5 business
+  days. It is also advertised on the [dev mailing list]. This way all
+  stakeholders have a chance to lodge any final objections before a decision
+  is reached.
+- In most cases, the FCP period is quiet, and the RFC is either merged or
+  closed. However, sometimes substantial new arguments or ideas are raised,
+  the FCP is canceled, and the RFC goes back into development mode.
+
+## RFC numbering
+
+[RFC numbering]: #rfc-numbering
+
+RFC numbers are small sequential integers without zero padding, assigned when
+an RFC is accepted, so the first RFC is `rfc-1`. Whoever merges the pull request
+renames `rfcs/rfc-0-my-feature.md` to the next free number, for example
+`rfcs/rfc-7-my-feature.md`, fills in the "Iggy Issue" link with the tracking
+issue opened for the implementation, and marks the Discussion as answered with
+links to the merged RFC and that issue.
+
+Pull request numbers are not used as RFC numbers because this repository's
+counter is shared with every other pull request, which would make RFC numbers
+large, sparse, and meaningless as a sequence. While an RFC is under review it
+is referred to by its feature name.
+
+## The RFC life-cycle
+
+[The RFC life-cycle]: #the-rfc-life-cycle
+
+Once an RFC becomes "active" then authors may implement it and submit the
+feature as a pull request to the Iggy repository. Being "active" is not a
+rubber stamp, and in particular still does not mean the feature will ultimately
+be merged; it does mean that in principle all the major stakeholders have
+agreed to the feature and are amenable to merging it.
+
+Furthermore, the fact that a given RFC has been accepted and is "active"
+implies nothing about what priority is assigned to its implementation, nor does
+it imply anything about whether an Iggy developer has been assigned the task of
+implementing the feature. While it is not *necessary* that the author of the
+RFC also write the implementation, it is by far the most effective way to see
+an RFC through to completion: authors should not expect that other project
+developers will take on responsibility for implementing their accepted feature.
+
+Modifications to "active" RFCs can be done in follow-up pull requests. We
+strive to write each RFC in a manner that it will reflect the final design of
+the feature; but the nature of the process means that we cannot expect every
+merged RFC to actually reflect what the end result will be at the time of the
+next major release.
+
+In general, once accepted, RFCs should not be substantially changed. Only very
+minor changes should be submitted as amendments. More substantial changes
+should be new RFCs, with a note added to the original RFC. Exactly what counts
+as a "very minor change" is up to the maintainers to decide.
+
+## Reviewing RFCs

Review Comment:
   simplification: "reviewing rfcs" repeats the merge-or-close outcome from line 154, and "implementing an rfc" repeats lines 184-190. fold the unique sentences in and delete both sections.



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: commits-unsubscribe@iggy.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org


Re: [PR] docs(repo): add the RFC process and template [iggy]

Posted by "codecov[bot] (via GitHub)" <gi...@apache.org>.
codecov[bot] commented on PR #4383:
URL: https://github.com/apache/iggy/pull/4383#issuecomment-5950570043

   ## [Codecov](https://app.codecov.io/gh/apache/iggy/pull/4383?dropdown=coverage&src=pr&el=h1&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache) Report
   :white_check_mark: All modified and coverable lines are covered by tests.
   :white_check_mark: Project coverage is 87.85%. Comparing base ([`e4ff95b`](https://app.codecov.io/gh/apache/iggy/commit/e4ff95b8852ca0b86efaaa68d62c27d8a2c58fec?dropdown=coverage&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache)) to head ([`8229723`](https://app.codecov.io/gh/apache/iggy/commit/82297235bc837f3ab43e6a6caecbcb662bab589d?dropdown=coverage&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache)).
   
   <details><summary>Additional details and impacted files</summary>
   
   
   
   ```diff
   @@            Coverage Diff            @@
   ##             master    #4383   +/-   ##
   =========================================
     Coverage     87.85%   87.85%           
     Complexity     1577     1577           
   =========================================
     Files          1290     1290           
     Lines        228844   228844           
     Branches     192194   192194           
   =========================================
     Hits         201049   201049           
   + Misses        23071    23046   -25     
   - Partials       4724     4749   +25     
   ```
   
   | [Components](https://app.codecov.io/gh/apache/iggy/pull/4383/components?src=pr&el=components&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache) | Coverage Δ | |
   |---|---|---|
   | [Rust Core](https://app.codecov.io/gh/apache/iggy/pull/4383/components?src=pr&el=component&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache) | `88.94% <ø> (-0.02%)` | :arrow_down: |
   | [Java SDK](https://app.codecov.io/gh/apache/iggy/pull/4383/components?src=pr&el=component&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache) | `68.73% <ø> (ø)` | |
   | [C# SDK](https://app.codecov.io/gh/apache/iggy/pull/4383/components?src=pr&el=component&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache) | `77.55% <ø> (+0.11%)` | :arrow_up: |
   | [Python SDK](https://app.codecov.io/gh/apache/iggy/pull/4383/components?src=pr&el=component&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache) | `91.24% <ø> (ø)` | |
   | [PHP SDK](https://app.codecov.io/gh/apache/iggy/pull/4383/components?src=pr&el=component&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache) | `85.67% <ø> (ø)` | |
   | [Node SDK](https://app.codecov.io/gh/apache/iggy/pull/4383/components?src=pr&el=component&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache) | `96.59% <ø> (+0.08%)` | :arrow_up: |
   | [Go SDK](https://app.codecov.io/gh/apache/iggy/pull/4383/components?src=pr&el=component&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache) | `70.32% <ø> (+0.02%)` | :arrow_up: |
   [see 48 files with indirect coverage changes](https://app.codecov.io/gh/apache/iggy/pull/4383/indirect-changes?src=pr&el=tree-more&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache)
   </details>
   <details><summary> :rocket: New features to boost your workflow: </summary>
   
   - :snowflake: [Test Analytics](https://docs.codecov.com/docs/test-analytics): Detect flaky tests, report on failures, and find test suite problems.
   - :package: [JS Bundle Analysis](https://docs.codecov.com/docs/javascript-bundle-analysis): Save yourself from yourself by tracking and limiting bundle sizes in JS merges.
   </details>


-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: commits-unsubscribe@iggy.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org