@bitsocial/wordfilter-challenge 0.1.2 → 0.3.0

package/AGENTS.md

@@ -10,21 +10,36 @@ Reference source files for this repository:
 Workflow:
 
 - Before every commit, run `npm run typecheck` and ensure it passes with no errors.
-- Before every commit, run `npm test` and ensure it passes.
+- Before every commit, run `npm test` (vitest) and ensure it passes.
+- Never push to a PR branch without first running `npm run typecheck` and `npm test` locally and seeing
+  them pass. CI runs the same checks, but a red PR is a round trip that a local run avoids.
 
 Conventions specific to this challenge:
 
 - `README.md` is the spec. Behaviour changes belong there first.
 - `src/apply-wordfilters.ts` imports nothing. It runs in a browser, in a publishing client, and its
   behaviour must stay identical to the snippet in the README, which is what most frontends will actually
-  copy. They discover the challenge through `community.challenges[i].publicOptions` and never install this
+  copy. They discover the contract through `community.challenges[i].publicOptions` and never install this
   package.
+- `WORDFILTER_V1_RULES_OPTION` and `WORDFILTER_V1_FIELD_NAMES_OPTION` are the wire contract, not internal
+  names. Clients recognise `wordfilter/v1` by the presence of the rules key in a community's
+  `publicOptions`, and most of them never install this package, so renaming either string silently stops
+  every such client from filtering. A rename is a new contract version, never an edit to v1. The literals
+  are pinned in `test/wordfilter-challenge.test.ts` so this fails a test rather than a live board.
+- The `wordfilter/v1` namespace covers exactly the options a publishing client must read. Anything a
+  client never reads, `error` today, keeps its plain name and stays free to differ between
+  implementations. This package is one implementation of the contract, not its owner.
 - `validateChallengeSettings` is sync and does no network. It runs on every community start, so an async
   validator would turn a third party's outage into a startup problem.
 - `ChallengeFileFactory` never throws. It runs on load as well as on edit, so a throw fails community
   startup rather than the offending edit.
 - Absent publication fields pass. `publication-match` treats a missing property as a failure, which would
   reject every vote. Do not copy that.
+- Test fixtures are typed against pkc-js's own challenge-time publication types
+  (`GetChallengeArgsInput["challengeRequestMessage"][K]`) through the `build*` helpers in
+  `test/wordfilter-challenge.test.ts`. Do not cast a publication through `as unknown as`: that is how a
+  `content` on a commentModeration, a field no client can send, once passed as a test. Each publication
+  type gets its own test, with the shape it actually has on the wire.
 
 Releasing:
 

package/README.md

@@ -1,6 +1,6 @@
 # @bitsocial/wordfilter-challenge
 
-A [pkc-js](https://github.com/pkcprotocol/pkc-js) challenge that makes community wordfilters a real rule instead of a cosmetic display filter.
+A [pkc-js](https://github.com/pkcprotocol/pkc-js) challenge that makes community wordfilters a real rule instead of a cosmetic display filter. It implements the [`wordfilter/v1` contract](#the-wordfilterv1-contract), which is what publishing clients actually code against.
 
 > **Status: implemented.** This README is the spec, and `src/` follows it. Tracked in [pkc-js#281](https://github.com/pkcprotocol/pkc-js/issues/281).
 
@@ -22,28 +22,72 @@ So the replacement has to happen on the side holding the signing key, which is t
 
 A client that does not implement the replacement cannot publish unfiltered text. It simply gets rejected, which is the intended failure mode.
 
+## The `wordfilter/v1` contract
+
+A publishing client has to recognise "this community wants word replacements applied before I sign" from the published community record alone. The record deliberately does not say which challenge produced it: `path`, `name` and `options` are all stripped when `community.settings.challenges[i]` becomes the public `community.challenges[i]`. Only `publicOptions`, the subset the owner opted into publishing, survives.
+
+So the signal a client keys off is an option key that names a **contract** rather than a package:
+
+| Public option | Required | Meaning |
+|---|---|---|
+| `wordfilter/v1/rules` | yes | JSON array of `{ src, dst }`. Its presence is what identifies the contract |
+| `wordfilter/v1/fieldNames` | no | JSON array of dot-notation paths, each starting with the publication type. Defaults to the list under [Default fields](#default-fields) |
+
+This package is one implementation. Anything that publishes `wordfilter/v1/rules` with the semantics below claims the contract, and a client written against it keeps working with implementations that did not exist when the client was written. Keying on a package name instead, whether through a hardcoded `@bitsocial/wordfilter-challenge` or a generic `wordfilters` option, would enshrine one implementation in every UI and lock out every fork, competitor and in-house variant that behaves identically. See [issue #1](https://github.com/bitsocialnet/wordfilter-challenge/issues/1).
+
+The namespace covers exactly what a publishing client must read, and nothing else. `error` is not in it, because no client reads `error`: the community returns it in the rejection. An implementation is free to name or shape that option however it likes.
+
+`wordfilter/v2/rules` would be a different key. A client that understands both reads both, and a community can publish both during a transition without either side guessing.
+
+### Default fields
+
+When a community does not publish `wordfilter/v1/fieldNames`, both sides check this list. Every path starts with the publication type, followed by the field's path inside that publication exactly as it is on the wire.
+
+| Publication type | Default paths |
+|---|---|
+| `comment` | `comment.content`, `comment.title`, `comment.author.displayName` |
+| `commentEdit` | `commentEdit.content`, `commentEdit.reason`, `commentEdit.author.displayName` |
+| `vote` | `vote.author.displayName` |
+
+The defaults cover what an ordinary author publishes. Moderator and owner text is not in them: a moderation's reason and a community edit's title and description can be filtered by naming their paths in `wordfilter/v1/fieldNames`, as `commentModeration.commentModeration.reason`, `communityEdit.communityEdit.title` and `communityEdit.communityEdit.description`. The doubled segment is the wire shape, not a typo: the publication type is `commentModeration`, and pkc-js puts the moderation's fields under a `commentModeration` property of it; likewise for `communityEdit`.
+
+Naming the publication type in every path is deliberate. `content` on a comment and `content` on a comment edit are the same field today, but nothing guarantees they stay that way, and a bare `content` could not tell them apart. A path whose first segment is not one of the five publication types is rejected by `validateChallengeSettings`, and by `getChallenge` for a config that predates that check, because it would match nothing on any request and the wordfilter would have quietly stopped filtering.
+
+
 ## For UI client developers
 
-This is the section that matters if you are building a frontend that publishes to communities using this challenge.
+This is the section that matters if you are building a frontend that publishes to communities using this contract.
 
 ### 1. Read the rules off the community
 
-The rules are published in the community record, in the challenge's `publicOptions`. Collect them from every wordfilter challenge the community has configured, in challenge order.
-
-The challenge's `name` is **not** in the published record: `path`, `name` and `options` are all stripped when `community.settings.challenges[i]` becomes `community.challenges[i]`. The presence of a `wordfilters` public option is the only thing a client can key off, which is exactly why the challenge requires it to be published.
+Collect the rules from every challenge on the community that publishes `wordfilter/v1/rules`, in challenge order. A community may have more than one.
 
 ```js
+const isRule = (rule) => typeof rule?.src === "string" && typeof rule?.dst === "string";
+const isFieldName = (name) => typeof name === "string";
+
 function getWordfilterConfigs(community) {
     return (community.challenges ?? [])
-        .filter((challenge) => challenge.publicOptions?.wordfilters)
+        .filter((challenge) => challenge.publicOptions?.["wordfilter/v1/rules"])
         .map((challenge) => {
             try {
-                return {
-                    rules: JSON.parse(challenge.publicOptions.wordfilters),
-                    fieldNames: challenge.publicOptions.fieldNames
-                        ? JSON.parse(challenge.publicOptions.fieldNames)
-                        : ["content", "title", "author.displayName"]
-                };
+                const rules = JSON.parse(challenge.publicOptions["wordfilter/v1/rules"]);
+                const fieldNames = challenge.publicOptions["wordfilter/v1/fieldNames"]
+                    ? JSON.parse(challenge.publicOptions["wordfilter/v1/fieldNames"])
+                    : [
+                          "comment.content",
+                          "comment.title",
+                          "comment.author.displayName",
+                          "commentEdit.content",
+                          "commentEdit.reason",
+                          "commentEdit.author.displayName",
+                          "vote.author.displayName"
+                      ];
+                // JSON.parse is happy to hand back null, an object or an array of numbers, and
+                // applyWordfilters would throw on any of them. Treat the wrong shape like bad JSON.
+                if (!Array.isArray(rules) || !rules.every(isRule)) return undefined;
+                if (!Array.isArray(fieldNames) || !fieldNames.every(isFieldName)) return undefined;
+                return { rules, fieldNames };
             } catch {
                 // A rule set you cannot parse is skipped, never fatal. Worst case the community
                 // rejects the publication with a readable error.
@@ -54,7 +98,9 @@ function getWordfilterConfigs(community) {
 }
 ```
 
-Skip anything you cannot parse. Never throw, and never refuse to load the community: a malformed rule set must cost the filter, not the whole board.
+Note what this function does not do: it never looks at which challenge implementation produced the options, because the record does not say and it does not need to.
+
+Skip anything you cannot parse, and anything that parses to the wrong shape. Never throw, and never refuse to load the community: a malformed rule set must cost the filter, not the whole board. This package's own `validateChallengeSettings` will not let a community publish a malformed rule set, but the contract is open to other implementations and your client cannot know which one it is talking to.
 
 ### 2. Apply the rules, looping until the text stops changing
 
@@ -91,15 +137,75 @@ Filter the text before it reaches `pkc.createComment()`, so the transformation h
 
 ```js
 const configs = getWordfilterConfigs(community);
-for (const { rules, fieldNames } of configs) {
-    if (fieldNames.includes("content") && content) content = applyWordfilters(content, rules);
-    if (fieldNames.includes("title") && title) title = applyWordfilters(title, rules);
-}
-const comment = await pkc.createComment({ content, title, communityAddress, signer });
+
+// One call per field, carrying the rules of every challenge that covers that field. Do not apply the
+// challenges one at a time: a later challenge's replacement can reintroduce an earlier challenge's
+// src, and the earlier challenge would then reject the publication. The loop inside applyWordfilters
+// only sees that interaction when both rule sets are in the same call.
+const rulesFor = (fieldName) =>
+    configs.filter(({ fieldNames }) => fieldNames.includes(fieldName)).flatMap(({ rules }) => rules);
+
+if (content) content = applyWordfilters(content, rulesFor("comment.content"));
+if (title) title = applyWordfilters(title, rulesFor("comment.title"));
+if (displayName) displayName = applyWordfilters(displayName, rulesFor("comment.author.displayName"));
+
+const comment = await pkc.createComment({ content, title, author: { displayName }, communityAddress, signer });
 await comment.publish();
 ```
 
-`fieldNames` entries are dot-notation paths on the publication, the same convention `publication-match` uses for `propertyName`. So `content` covers both a comment and a comment edit without the config naming publication types.
+The challenge runs on every publication type, not only new comments. The [default field list](#default-fields) also names the text of a comment edit and the display name on a vote, so the same `rulesFor` call applies before each of these, with the path prefixed by the publication type:
+
+```js
+// Comment edit: content and reason are top-level on the edit, displayName is under author.
+const edit = await pkc.createCommentEdit({
+    commentCid,
+    content: applyWordfilters(newContent, rulesFor("commentEdit.content")),
+    reason: applyWordfilters(reason, rulesFor("commentEdit.reason")),
+    author: { displayName: applyWordfilters(displayName, rulesFor("commentEdit.author.displayName")) },
+    communityAddress,
+    signer
+});
+
+// Vote: the only text on it is the display name.
+const vote = await pkc.createVote({
+    commentCid,
+    vote: 1,
+    author: { displayName: applyWordfilters(displayName, rulesFor("vote.author.displayName")) },
+    communityAddress,
+    signer
+});
+
+```
+
+Those paths are the defaults, so they are the minimum. If a community publishes other paths in `wordfilter/v1/fieldNames`, run the same call on whatever your client puts at those paths; the community checks exactly the configured paths and nothing else, so an unfiltered custom field is a rejection just like an unfiltered display name. The paths a community is most likely to add are moderator and owner text, which `rulesFor` returns empty for unless the community names them:
+
+```js
+// Comment moderation: the moderator's reason lives under the publication's commentModeration property,
+// hence the doubled segment.
+const moderation = await pkc.createCommentModeration({
+    commentCid,
+    commentModeration: {
+        removed: true,
+        reason: applyWordfilters(reason, rulesFor("commentModeration.commentModeration.reason"))
+    },
+    communityAddress,
+    signer
+});
+
+// Community edit: title and description live under the publication's communityEdit property.
+const communityEdit = await pkc.createCommunityEdit({
+    communityEdit: {
+        title: applyWordfilters(title, rulesFor("communityEdit.communityEdit.title")),
+        description: applyWordfilters(description, rulesFor("communityEdit.communityEdit.description"))
+    },
+    communityAddress,
+    signer
+});
+```
+
+The `wordfilter/v1/fieldNames` entries are dot-notation paths, the same convention `publication-match` uses for `propertyName`, resolved against the challenge request's publication map rather than the publication itself. So the first segment names the publication type, and a path is simply absent, and passes, on a request carrying a different type: `commentEdit.content` never sees a new comment, and `comment.content` never sees an edit.
+
+Two challenges on the same community whose rules undo each other, `foo → bar` in one and `bar → foo` in another, cannot be caught by either challenge's `validateChallengeSettings`, which sees only its own settings. The merged call then either throws `did not stabilise` or settles on text that one of the challenges still rejects, and the community returns that challenge's `error`. Both are the right outcome: no text containing either word can satisfy both challenges, so the board is misconfigured and the owner has to fix it. Handle it the same way as any other rejection, in step 5.
 
 ### 4. Show the user what happened
 
@@ -128,8 +234,8 @@ bitsocial challenge install @bitsocial/wordfilter-challenge
 ```bash
 bitsocial community edit your-community.bso \
   '--settings.challenges[0].name' @bitsocial/wordfilter-challenge \
-  '--settings.challenges[0].options.wordfilters' '[{"src":"cloud","dst":"butt"}]' \
-  '--settings.challenges[0].publicOptions[0]' wordfilters
+  '--settings.challenges[0].options.wordfilter/v1/rules' '[{"src":"cloud","dst":"butt"}]' \
+  '--settings.challenges[0].publicOptions[0]' wordfilter/v1/rules
 ```
 
 ### With pkc-js over RPC
@@ -166,49 +272,81 @@ await community.edit({
             {
                 name: "@bitsocial/wordfilter-challenge",
                 options: {
-                    wordfilters: JSON.stringify([
+                    "wordfilter/v1/rules": JSON.stringify([
                         { src: "cloud", dst: "butt" },
                         { src: "millennials", dst: "snake people" },
                         { src: "spamword", dst: "" }
                     ]),
-                    fieldNames: JSON.stringify(["content", "title", "author.displayName"]),
+                    "wordfilter/v1/fieldNames": JSON.stringify([
+                        "comment.content",
+                        "comment.title",
+                        "comment.author.displayName",
+                        "commentEdit.content",
+                        "commentEdit.reason",
+                        "commentEdit.author.displayName",
+                        "vote.author.displayName"
+                    ]),
                     error: "This board replaces certain words. Please repost with the replacements applied."
                 },
-                publicOptions: ["wordfilters", "fieldNames", "error"]
+                publicOptions: ["wordfilter/v1/rules", "wordfilter/v1/fieldNames", "error"]
             }
         ]
     }
 });
 ```
 
-`publicOptions` is **required**, not decorative. Options are private by default in pkc-js, and a client that cannot read the rules cannot satisfy them. The challenge's `validateChallengeSettings` hook rejects the edit if `wordfilters` is missing from `publicOptions`, so the failure surfaces when you save rather than when every author starts getting rejected.
+`publicOptions` is **required**, not decorative. Options are private by default in pkc-js, and a client that cannot read the rules cannot satisfy them. The challenge's `validateChallengeSettings` hook rejects the edit if `wordfilter/v1/rules` is missing from `publicOptions`, so the failure surfaces when you save rather than when every author starts getting rejected.
 
 ### Options
 
 | Option | Required | Must be in `publicOptions` | Description |
 |---|---|---|---|
-| `wordfilters` | yes | yes | JSON array of `{ src, dst }`, applied in array order, cascading |
-| `fieldNames` | no | when set | JSON array of dot-notation paths. Defaults to `content`, `title`, `author.displayName` |
+| `wordfilter/v1/rules` | yes | yes | JSON array of `{ src, dst }`, applied in array order, cascading |
+| `wordfilter/v1/fieldNames` | no | when set | JSON array of dot-notation paths, each starting with the publication type. Defaults to the list under [Default fields](#default-fields) |
 | `error` | no | owner's call | Message shown to the author when a publication is rejected |
 
-An option has to be public when a client cannot satisfy the challenge without reading it. That covers `wordfilters` always, and `fieldNames` whenever the owner sets it: a client filtering the three default fields cannot satisfy a community checking a different set, and nothing in the published record would explain the rejections. `error` is returned in the rejection itself, so publishing it is transparency rather than a requirement.
+An option has to be public when a client cannot satisfy the challenge without reading it. That covers `wordfilter/v1/rules` always, and `wordfilter/v1/fieldNames` whenever the owner sets it: a client filtering the default fields cannot satisfy a community checking a different set, and nothing in the published record would explain the rejections. Those two are also exactly the options the contract namespaces, for the same reason. `error` is returned in the rejection itself, so publishing it is transparency rather than a requirement, and it keeps its plain name.
 
 ### Validation
 
 `validateChallengeSettings` rejects at edit time:
 
-- `wordfilters` missing from `publicOptions`, or unparseable JSON, or not an array of `{ src, dst }` strings
+- `wordfilter/v1/rules` missing from `publicOptions`, or unparseable JSON, or not an array of `{ src, dst }` strings
 - an empty `src`
 - `src === dst`
 - the same `src` in more than one rule
 - any `dst` containing any `src`
 - more than 64 rules, or a `src` or `dst` longer than 128 characters
-- `fieldNames`, when set, unparseable, not an array of non-empty strings, or missing from `publicOptions`
+- `wordfilter/v1/fieldNames`, when set, unparseable, not an array of non-empty strings, containing a path whose first segment is not a publication type (`comment`, `vote`, `commentEdit`, `commentModeration`, `communityEdit`), or missing from `publicOptions`
 
 The `src === dst`, duplicate `src` and `dst`-contains-`src` checks all compare case-insensitively, because matching is case-insensitive: `{src: "LOL", dst: "lol"}` replaces nothing just as surely as `{src: "lol", dst: "lol"}` does.
 
 The `dst` containing `src` rule is what guarantees the client's loop terminates. Without it a rule like `lol` becomes `lolol` produces output that always contains a filtered word, making every post permanently unpublishable.
 
+## Migrating from 0.1.x and 0.2.0
+
+0.2.0 already uses the `wordfilter/v1` option keys; only the paths inside `wordfilter/v1/fieldNames` change for it, see below. 0.1.x used bare `wordfilters` and `fieldNames` option names, which made the package rather than the contract the thing clients keyed off. Rename both, in `options` and in `publicOptions`:
+
+| 0.1.x | Now |
+|---|---|
+| `wordfilters` | `wordfilter/v1/rules` |
+| `fieldNames` | `wordfilter/v1/fieldNames` |
+| `error` | `error`, unchanged |
+
+The paths inside `fieldNames` change too, for 0.2.0 as much as 0.1.x. Both resolved them against the publication, so `content` meant "content on whatever was published". `wordfilter/v1/fieldNames` now resolves them against the challenge request's publication map, so every path starts with the publication type, and a bare `content` is rejected rather than silently matching nothing:
+
+| 0.1.x / 0.2.0 path | Now |
+|---|---|
+| `content` | `comment.content`, and `commentEdit.content` if edits should be filtered too |
+| `title` | `comment.title` |
+| `author.displayName` | one entry per publication type: `comment.author.displayName`, `commentEdit.author.displayName`, `vote.author.displayName` |
+
+If 0.1.x or 0.2.0 ran with the default field list, dropping `fieldNames` entirely and taking the new defaults is the closest equivalent. A 0.2.0 community that set `wordfilter/v1/fieldNames` with bare paths fails loudly at the next start, `validateChallengeSettings` naming the offending path, until the paths are prefixed.
+
+There is no fallback to the old names, on purpose. A wordfilter that quietly stops filtering is the exact failure this package exists to prevent, so an unmigrated community fails loudly instead: pkc-js rejects the now-undeclared option at community start with `ERR_CHALLENGE_OPTION_NOT_DECLARED_IN_OPTION_INPUTS`, naming the offending option, and `validateChallengeSettings` rejects the edit if you try to save it.
+
+Clients written against 0.1.x need the same rename in whatever they copied from this README.
+
 ## Matching semantics
 
 - **Literal, never regex.** vichan supports arbitrary PCRE, but only because its config is a server-local file the operator wrote. Here the rules ship inside a signed record that every browser client downloads and executes, so patterns are literal strings.
@@ -243,7 +381,7 @@ npm run build
 | Path | What it is |
 |---|---|
 | `src/wordfilter-challenge.ts` | The `ChallengeFileFactory`: `optionInputs`, `getChallenge`, `validateChallengeSettings` |
-| `src/apply-wordfilters.ts` | The client-side replacement loop. Imports nothing, so it bundles for a browser |
+| `src/apply-wordfilters.ts` | The client-side replacement loop and the `wordfilter/v1` option keys. Imports nothing, so it bundles for a browser |
 | `src/types.ts` | Re-exports of the pkc-js challenge types |
 
 ## License

package/dist/apply-wordfilters.d.ts

@@ -1,3 +1,13 @@
+/**
+ * The option key carrying the rules, and the only thing a client keys off to recognise the contract.
+ *
+ * Namespaced by contract rather than by package on purpose. A client that matched on the package name,
+ * or on a generic `wordfilters` key, would lock every other implementation of the same behaviour out of
+ * every UI. Anything that publishes this key claims to implement `wordfilter/v1`, whoever wrote it.
+ */
+export declare const WORDFILTER_V1_RULES_OPTION = "wordfilter/v1/rules";
+/** The option key carrying the fields to filter. Optional, and defaults to {@link DEFAULT_FIELD_NAMES}. */
+export declare const WORDFILTER_V1_FIELD_NAMES_OPTION = "wordfilter/v1/fieldNames";
 export interface WordfilterRule {
     /** The literal string to look for. Never a regex, and matched case-insensitively. */
     src: string;
@@ -16,7 +26,12 @@ export declare const escapeRegExp: (str: string) => string;
  * the community checks for.
  *
  * @throws if the rules never stabilise. `validateChallengeSettings` rejects the rule sets that can cause
- * this (no `dst` may contain any `src`), so a community configured through pkc-js 0.0.85+ cannot produce
- * one, but a client should still not spin forever on a hostile record.
+ * this within one challenge (no `dst` may contain any `src`), so a single challenge configured through
+ * pkc-js 0.0.85+ cannot produce one, but a client should still not spin forever on a hostile record.
+ *
+ * Two challenges on the same community can undo each other, which no per-challenge validator can see.
+ * The README's client snippet merges the rules of every challenge covering a field into one call so the
+ * loop sees the interaction; the result is then either this throw or a fixed point one challenge still
+ * rejects, and either way the board is misconfigured.
  */
 export declare function applyWordfilters(text: string, rules: readonly WordfilterRule[], maxPasses?: number): string;

package/dist/apply-wordfilters.js

@@ -1,13 +1,39 @@
-// The client side of the challenge. A community can only accept or reject, so the replacement has to
-// happen on the side holding the signing key. This file is the loop that side has to run, kept free of
-// any pkc-js import so it can be pulled into a browser bundle on its own.
+// The client side of the `wordfilter/v1` contract. A community can only accept or reject, so the
+// replacement has to happen on the side holding the signing key. This file is the loop that side has to
+// run, kept free of any pkc-js import so it can be pulled into a browser bundle on its own.
 //
-// Most frontends will never install this package: they discover the challenge through
-// `community.challenges[i].publicOptions` and have no reason to know which package produced it. The
-// README carries this same loop as a copy-pasteable snippet for them, and that snippet is the contract.
-// This export exists for the minority that does bundle the package, and must stay behaviourally
-// identical to the README's version.
-export const DEFAULT_FIELD_NAMES = ["content", "title", "author.displayName"];
+// Most frontends will never install this package: they discover the contract through
+// `community.challenges[i].publicOptions` and have no reason to know which package produced it, or that
+// this one exists. The README carries this same loop as a copy-pasteable snippet for them, and that
+// snippet is the contract. This export exists for the minority that does bundle the package, and must
+// stay behaviourally identical to the README's version.
+/**
+ * The option key carrying the rules, and the only thing a client keys off to recognise the contract.
+ *
+ * Namespaced by contract rather than by package on purpose. A client that matched on the package name,
+ * or on a generic `wordfilters` key, would lock every other implementation of the same behaviour out of
+ * every UI. Anything that publishes this key claims to implement `wordfilter/v1`, whoever wrote it.
+ */
+export const WORDFILTER_V1_RULES_OPTION = "wordfilter/v1/rules";
+/** The option key carrying the fields to filter. Optional, and defaults to {@link DEFAULT_FIELD_NAMES}. */
+export const WORDFILTER_V1_FIELD_NAMES_OPTION = "wordfilter/v1/fieldNames";
+// The free-text fields an ordinary author publishes. Paths are rooted at the challenge request's
+// publication map, so the first segment is the publication type (comment, vote, commentEdit,
+// commentModeration, communityEdit) and the rest is the path inside that publication as it is on the wire.
+// Naming the type keeps `content` on a comment and `content` on a comment edit separately addressable, in
+// case they ever diverge. Moderator and owner text (commentModeration.commentModeration.reason,
+// communityEdit.communityEdit.title, ...) is opt-in through wordfilter/v1/fieldNames, not default. This
+// list is part of the wordfilter/v1 contract: a client filtering fewer fields than a community checks gets
+// rejected, so the README client snippet carries the same list.
+export const DEFAULT_FIELD_NAMES = [
+    "comment.content",
+    "comment.title",
+    "comment.author.displayName",
+    "commentEdit.content",
+    "commentEdit.reason",
+    "commentEdit.author.displayName",
+    "vote.author.displayName"
+];
 export const DEFAULT_MAX_PASSES = 8;
 export const escapeRegExp = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 const applyOnce = (text, rules) => rules.reduce((acc, { src, dst }) => acc.replace(new RegExp(escapeRegExp(src), "gi"), () => dst), text);
@@ -20,8 +46,13 @@ const applyOnce = (text, rules) => rules.reduce((acc, { src, dst }) => acc.repla
  * the community checks for.
  *
  * @throws if the rules never stabilise. `validateChallengeSettings` rejects the rule sets that can cause
- * this (no `dst` may contain any `src`), so a community configured through pkc-js 0.0.85+ cannot produce
- * one, but a client should still not spin forever on a hostile record.
+ * this within one challenge (no `dst` may contain any `src`), so a single challenge configured through
+ * pkc-js 0.0.85+ cannot produce one, but a client should still not spin forever on a hostile record.
+ *
+ * Two challenges on the same community can undo each other, which no per-challenge validator can see.
+ * The README's client snippet merges the rules of every challenge covering a field into one call so the
+ * loop sees the interaction; the result is then either this throw or a fixed point one challenge still
+ * rejects, and either way the board is misconfigured.
  */
 export function applyWordfilters(text, rules, maxPasses = DEFAULT_MAX_PASSES) {
     let out = text;

package/dist/apply-wordfilters.js.map

@@ -1 +1 @@
-{"version":3,"file":"apply-wordfilters.js","sourceRoot":"","sources":["../src/apply-wordfilters.ts"],"names":[],"mappings":"AAAA,qGAAqG;AACrG,uGAAuG;AACvG,0EAA0E;AAC1E,EAAE;AACF,sFAAsF;AACtF,oGAAoG;AACpG,wGAAwG;AACxG,gGAAgG;AAChG,qCAAqC;AASrC,MAAM,CAAC,MAAM,mBAAmB,GAAsB,CAAC,SAAS,EAAE,OAAO,EAAE,oBAAoB,CAAC,CAAC;AAEjG,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC;AAEpC,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,GAAW,EAAU,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC;AAEhG,MAAM,SAAS,GAAG,CAAC,IAAY,EAAE,KAAgC,EAAU,EAAE,CAC3E,KAAK,CAAC,MAAM,CACV,CAAC,GAAG,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAClF,IAAI,CACL,CAAC;AAEJ;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,gBAAgB,CAC9B,IAAY,EACZ,KAAgC,EAChC,YAAoB,kBAAkB;IAEtC,IAAI,GAAG,GAAG,IAAI,CAAC;IACf,KAAK,IAAI,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,SAAS,EAAE,IAAI,EAAE,EAAE,CAAC;QAC5C,MAAM,IAAI,GAAG,SAAS,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QACnC,IAAI,IAAI,KAAK,GAAG;YAAE,OAAO,GAAG,CAAC;QAC7B,GAAG,GAAG,IAAI,CAAC;IACb,CAAC;IACD,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;AACxD,CAAC"}
+{"version":3,"file":"apply-wordfilters.js","sourceRoot":"","sources":["../src/apply-wordfilters.ts"],"names":[],"mappings":"AAAA,iGAAiG;AACjG,wGAAwG;AACxG,4FAA4F;AAC5F,EAAE;AACF,qFAAqF;AACrF,wGAAwG;AACxG,oGAAoG;AACpG,sGAAsG;AACtG,wDAAwD;AAExD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,qBAAqB,CAAC;AAEhE,2GAA2G;AAC3G,MAAM,CAAC,MAAM,gCAAgC,GAAG,0BAA0B,CAAC;AAS3E,iGAAiG;AACjG,6FAA6F;AAC7F,2GAA2G;AAC3G,0GAA0G;AAC1G,gGAAgG;AAChG,wGAAwG;AACxG,2GAA2G;AAC3G,gEAAgE;AAChE,MAAM,CAAC,MAAM,mBAAmB,GAAsB;IACpD,iBAAiB;IACjB,eAAe;IACf,4BAA4B;IAC5B,qBAAqB;IACrB,oBAAoB;IACpB,gCAAgC;IAChC,yBAAyB;CAC1B,CAAC;AAEF,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC;AAEpC,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,GAAW,EAAU,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC;AAEhG,MAAM,SAAS,GAAG,CAAC,IAAY,EAAE,KAAgC,EAAU,EAAE,CAC3E,KAAK,CAAC,MAAM,CACV,CAAC,GAAG,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAClF,IAAI,CACL,CAAC;AAEJ;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,gBAAgB,CAC9B,IAAY,EACZ,KAAgC,EAChC,YAAoB,kBAAkB;IAEtC,IAAI,GAAG,GAAG,IAAI,CAAC;IACf,KAAK,IAAI,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,SAAS,EAAE,IAAI,EAAE,EAAE,CAAC;QAC5C,MAAM,IAAI,GAAG,SAAS,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QACnC,IAAI,IAAI,KAAK,GAAG;YAAE,OAAO,GAAG,CAAC;QAC7B,GAAG,GAAG,IAAI,CAAC;IACb,CAAC;IACD,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;AACxD,CAAC"}

package/dist/wordfilter-challenge.js

@@ -1,4 +1,4 @@
-import { DEFAULT_FIELD_NAMES } from "./apply-wordfilters.js";
+import { DEFAULT_FIELD_NAMES, WORDFILTER_V1_FIELD_NAMES_OPTION, WORDFILTER_V1_RULES_OPTION } from "./apply-wordfilters.js";
 const MAX_RULES = 64;
 const MAX_RULE_STRING_LENGTH = 128;
 const DEFAULT_ERROR = "This community replaces certain words. Please repost with the replacements applied.";
@@ -6,21 +6,24 @@ const description = "Publications must already have the community's word replace
 const type = "text/plain";
 const optionInputs = [
     {
-        option: "wordfilters",
+        option: WORDFILTER_V1_RULES_OPTION,
         label: "Wordfilters",
         default: "[]",
-        description: "JSON array of {src, dst} replacements, applied in array order, cascading. Matched literally and case-insensitively. Must be listed in publicOptions so publishing clients can read and apply it.",
+        description: "JSON array of {src, dst} replacements, applied in array order, cascading. Matched literally and case-insensitively. Must be listed in publicOptions so publishing clients can read and apply it. The key names the wordfilter/v1 contract rather than this package, so a client written against it works with any implementation.",
         placeholder: '[{"src":"cloud","dst":"butt"},{"src":"spamword","dst":""}]',
         required: true
     },
     {
-        option: "fieldNames",
+        option: WORDFILTER_V1_FIELD_NAMES_OPTION,
         label: "Field Names",
         default: JSON.stringify(DEFAULT_FIELD_NAMES),
-        description: "JSON array of dot-notation paths on the publication to check, the same convention publication-match uses for propertyName. Must be listed in publicOptions when set. Defaults to content, title and author.displayName.",
-        placeholder: '["content","title","author.displayName"]'
+        description: "JSON array of dot-notation paths to check, each starting with the publication type: comment.content, commentEdit.reason, commentModeration.commentModeration.reason and so on. Must be listed in publicOptions when set. Defaults to the text of comments and comment edits plus author.displayName on comments, comment edits and votes.",
+        placeholder: JSON.stringify(DEFAULT_FIELD_NAMES)
     },
     {
+        // Not namespaced, unlike the two above: the wordfilter/v1 namespace covers exactly what a publishing
+        // client has to read, and no client ever reads this. It comes back in the rejection itself, so an
+        // implementation is free to name or shape it differently.
         option: "error",
         label: "Error",
         default: DEFAULT_ERROR,
@@ -35,17 +38,20 @@ const publicationFieldNames = [
     "commentModeration",
     "communityEdit"
 ];
-const derivePublicationFromChallengeRequest = (challengeRequestMessage) => {
+// The object field paths are resolved against: the challenge request's publication map, keyed by type. A
+// request carries exactly one of these, so `comment.content` is absent, and passes, on a comment edit.
+const derivePublicationsFromChallengeRequest = (challengeRequestMessage) => {
+    const publications = {};
     for (const fieldName of publicationFieldNames) {
         const publication = challengeRequestMessage[fieldName];
         if (publication) {
-            return publication;
+            publications[fieldName] = publication;
         }
     }
-    return undefined;
+    return Object.keys(publications).length ? publications : undefined;
 };
-// Dot-notation lookup, the same convention publication-match uses for `propertyName`, so `content`
-// covers a comment and a comment edit without the config naming publication types.
+// Dot-notation lookup, the same convention publication-match uses for `propertyName`, except that the
+// first segment names the publication type.
 const getValueAtPath = (publication, path) => {
     let current = publication;
     for (const segment of path.split(".")) {
@@ -56,31 +62,31 @@ const getValueAtPath = (publication, path) => {
     }
     return current;
 };
-const parseRules = (wordfilters) => {
+const parseRules = (rules) => {
     // Only an absent option means "no rules". An empty string satisfies core's `required` check but is not
     // valid JSON, so it falls through to the parse error rather than silently disabling the filter.
-    if (wordfilters === undefined)
+    if (rules === undefined)
         return [];
     let parsed;
     try {
-        parsed = JSON.parse(wordfilters);
+        parsed = JSON.parse(rules);
     }
     catch (e) {
-        throw new Error(`wordfilters is not valid JSON: ${e.message}`);
+        throw new Error(`${WORDFILTER_V1_RULES_OPTION} is not valid JSON: ${e.message}`);
     }
     if (!Array.isArray(parsed)) {
-        throw new Error("wordfilters must be a JSON array of {src, dst} objects");
+        throw new Error(`${WORDFILTER_V1_RULES_OPTION} must be a JSON array of {src, dst} objects`);
     }
     return parsed.map((rule, index) => {
         if (typeof rule !== "object" || rule === null || Array.isArray(rule)) {
-            throw new Error(`wordfilters[${index}] must be an object with src and dst`);
+            throw new Error(`${WORDFILTER_V1_RULES_OPTION}[${index}] must be an object with src and dst`);
         }
         const { src, dst } = rule;
         if (typeof src !== "string") {
-            throw new Error(`wordfilters[${index}].src must be a string`);
+            throw new Error(`${WORDFILTER_V1_RULES_OPTION}[${index}].src must be a string`);
         }
         if (typeof dst !== "string") {
-            throw new Error(`wordfilters[${index}].dst must be a string`);
+            throw new Error(`${WORDFILTER_V1_RULES_OPTION}[${index}].dst must be a string`);
         }
         return { src, dst };
     });
@@ -93,21 +99,28 @@ const parseFieldNames = (fieldNames) => {
         parsed = JSON.parse(fieldNames);
     }
     catch (e) {
-        throw new Error(`fieldNames is not valid JSON: ${e.message}`);
+        throw new Error(`${WORDFILTER_V1_FIELD_NAMES_OPTION} is not valid JSON: ${e.message}`);
     }
     if (!Array.isArray(parsed)) {
-        throw new Error("fieldNames must be a JSON array of dot-notation property paths");
+        throw new Error(`${WORDFILTER_V1_FIELD_NAMES_OPTION} must be a JSON array of dot-notation property paths`);
     }
     return parsed.map((fieldName, index) => {
         if (typeof fieldName !== "string" || !fieldName) {
-            throw new Error(`fieldNames[${index}] must be a non-empty string`);
+            throw new Error(`${WORDFILTER_V1_FIELD_NAMES_OPTION}[${index}] must be a non-empty string`);
+        }
+        // A path that names no publication type resolves to nothing on every request, which is a wordfilter
+        // that has quietly stopped filtering. That is the failure this package exists to prevent, so it is
+        // rejected here and, for a config that predates this check, by getChallenge.
+        const publicationType = fieldName.split(".")[0] ?? "";
+        if (!publicationFieldNames.includes(publicationType)) {
+            throw new Error(`${WORDFILTER_V1_FIELD_NAMES_OPTION}[${index}] must start with a publication type (${publicationFieldNames.join(", ")}), got "${fieldName}"`);
         }
         return fieldName;
     });
 };
 const getChallenge = async ({ challengeSettings, challengeRequestMessage }) => {
-    const publication = derivePublicationFromChallengeRequest(challengeRequestMessage);
-    if (!publication) {
+    const publications = derivePublicationsFromChallengeRequest(challengeRequestMessage);
+    if (!publications) {
         return { success: false, error: "Could not derive publication from challenge request." };
     }
     // validateChallengeSettings rejects an unparseable config at edit time, so reaching this catch means a
@@ -116,8 +129,8 @@ const getChallenge = async ({ challengeSettings, challengeRequestMessage }) => {
     let rules;
     let fieldNames;
     try {
-        rules = parseRules(challengeSettings?.options?.["wordfilters"]);
-        fieldNames = parseFieldNames(challengeSettings?.options?.["fieldNames"]);
+        rules = parseRules(challengeSettings?.options?.[WORDFILTER_V1_RULES_OPTION]);
+        fieldNames = parseFieldNames(challengeSettings?.options?.[WORDFILTER_V1_FIELD_NAMES_OPTION]);
     }
     catch (e) {
         return { success: false, error: `Invalid wordfilter challenge settings: ${e.message}` };
@@ -127,9 +140,10 @@ const getChallenge = async ({ challengeSettings, challengeRequestMessage }) => {
     }
     const error = challengeSettings?.options?.["error"] || DEFAULT_ERROR;
     for (const fieldName of fieldNames) {
-        const value = getValueAtPath(publication, fieldName);
-        // Absent fields pass cleanly. A vote has no content, and that is not a failure. publication-match
-        // treats a missing property as a failure, which would reject every vote. Do not copy that.
+        const value = getValueAtPath(publications, fieldName);
+        // Absent fields pass cleanly. A vote has no content, and every path that names another publication
+        // type is absent on this request. Neither is a failure. publication-match treats a missing property as
+        // a failure, which would reject every vote. Do not copy that.
         if (typeof value !== "string") {
             continue;
         }
@@ -147,32 +161,32 @@ const getChallenge = async ({ challengeSettings, challengeRequestMessage }) => {
 const validateChallengeSettings = ({ challengeSettings }) => {
     // A client that cannot read the rules cannot satisfy them, so publication is required rather than the
     // owner's call. See "Require publication when clients need to read it" in challenge-authoring.md.
-    if (!challengeSettings.publicOptions?.includes("wordfilters")) {
-        throw new Error("wordfilters must be listed in publicOptions: publishing clients apply the replacements before signing, and a client that cannot read the rules cannot satisfy them");
+    if (!challengeSettings.publicOptions?.includes(WORDFILTER_V1_RULES_OPTION)) {
+        throw new Error(`${WORDFILTER_V1_RULES_OPTION} must be listed in publicOptions: publishing clients apply the replacements before signing, and a client that cannot read the rules cannot satisfy them`);
     }
-    const rules = parseRules(challengeSettings.options?.["wordfilters"]);
+    const rules = parseRules(challengeSettings.options?.[WORDFILTER_V1_RULES_OPTION]);
     if (rules.length > MAX_RULES) {
-        throw new Error(`wordfilters has ${rules.length} rules, the maximum is ${MAX_RULES}`);
+        throw new Error(`${WORDFILTER_V1_RULES_OPTION} has ${rules.length} rules, the maximum is ${MAX_RULES}`);
     }
     const seenSources = new Map();
     for (const [index, { src, dst }] of rules.entries()) {
         if (!src) {
-            throw new Error(`wordfilters[${index}].src must not be empty`);
+            throw new Error(`${WORDFILTER_V1_RULES_OPTION}[${index}].src must not be empty`);
         }
         if (src.length > MAX_RULE_STRING_LENGTH) {
-            throw new Error(`wordfilters[${index}].src is ${src.length} characters, the maximum is ${MAX_RULE_STRING_LENGTH}`);
+            throw new Error(`${WORDFILTER_V1_RULES_OPTION}[${index}].src is ${src.length} characters, the maximum is ${MAX_RULE_STRING_LENGTH}`);
         }
         if (dst.length > MAX_RULE_STRING_LENGTH) {
-            throw new Error(`wordfilters[${index}].dst is ${dst.length} characters, the maximum is ${MAX_RULE_STRING_LENGTH}`);
+            throw new Error(`${WORDFILTER_V1_RULES_OPTION}[${index}].dst is ${dst.length} characters, the maximum is ${MAX_RULE_STRING_LENGTH}`);
         }
         // Matching is case-insensitive, so "AB" and "ab" are the same rule and the same no-op.
         const lowerCasedSrc = src.toLowerCase();
         if (lowerCasedSrc === dst.toLowerCase()) {
-            throw new Error(`wordfilters[${index}].src and dst are both '${src}', which replaces nothing`);
+            throw new Error(`${WORDFILTER_V1_RULES_OPTION}[${index}].src and dst are both '${src}', which replaces nothing`);
         }
         const firstIndex = seenSources.get(lowerCasedSrc);
         if (firstIndex !== undefined) {
-            throw new Error(`wordfilters[${index}].src ('${src}') is already the src of wordfilters[${firstIndex}]: the second rule can never match`);
+            throw new Error(`${WORDFILTER_V1_RULES_OPTION}[${index}].src ('${src}') is already the src of rule ${firstIndex}: the second rule can never match`);
         }
         seenSources.set(lowerCasedSrc, index);
     }
@@ -183,16 +197,16 @@ const validateChallengeSettings = ({ challengeSettings }) => {
         const lowerCasedDst = dst.toLowerCase();
         for (const [otherIndex, { src }] of rules.entries()) {
             if (lowerCasedDst.includes(src.toLowerCase())) {
-                throw new Error(`wordfilters[${index}].dst ('${dst}') contains wordfilters[${otherIndex}].src ('${src}'): the replacement would itself be filtered, so no text could ever pass`);
+                throw new Error(`${WORDFILTER_V1_RULES_OPTION}[${index}].dst ('${dst}') contains rule ${otherIndex}'s src ('${src}'): the replacement would itself be filtered, so no text could ever pass`);
             }
         }
     }
-    // Same reasoning as wordfilters: a client that checks the default fields while the community checks a
+    // Same reasoning as the rules: a client that checks the default fields while the community checks a
     // different set rejects every author, with nothing in the record explaining why.
-    if (challengeSettings.options?.["fieldNames"] !== undefined) {
-        parseFieldNames(challengeSettings.options["fieldNames"]);
-        if (!challengeSettings.publicOptions?.includes("fieldNames")) {
-            throw new Error("fieldNames must be listed in publicOptions when it is set: a client filtering the default fields cannot satisfy a community checking different ones");
+    if (challengeSettings.options?.[WORDFILTER_V1_FIELD_NAMES_OPTION] !== undefined) {
+        parseFieldNames(challengeSettings.options[WORDFILTER_V1_FIELD_NAMES_OPTION]);
+        if (!challengeSettings.publicOptions?.includes(WORDFILTER_V1_FIELD_NAMES_OPTION)) {
+            throw new Error(`${WORDFILTER_V1_FIELD_NAMES_OPTION} must be listed in publicOptions when it is set: a client filtering the default fields cannot satisfy a community checking different ones`);
         }
     }
 };

package/dist/wordfilter-challenge.js.map

@@ -1 +1 @@
-{"version":3,"file":"wordfilter-challenge.js","sourceRoot":"","sources":["../src/wordfilter-challenge.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"wordfilter-challenge.js","sourceRoot":"","sources":["../src/wordfilter-challenge.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitsocial/wordfilter-challenge",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "Standalone wordfilter challenge for pkc-js: proof that a community's word replacements were applied before signing",
   "type": "module",
   "main": "./dist/index.js",