fix(spec): re-derive the banned-keys arm on the retired-arm slot

`#19084` collapsed `TraceSamplingConfig.composite[].condition` to a
record, so the ban lands on `condition` itself rather than on a union
arm, the ledger rows are spelled `composite.element.condition`, and a
CEL envelope is now refused by the runtime too. The live-seam pins and
the changeset's accept-set sentence are re-derived on that tree.

Also: the changeset declares `Clause-②: yes`, matching the corrected
claim and the ruling; and the empty-key-list branch records the real
reason it drops — `enum: []` is an invalid schema, not a vacuous rule.

Claude-Session: https://claude.ai/code/session_01AmH9bKvGoLjiY86Q4Z3og2
Co-authored-by: Claude <noreply@anthropic.com>

Author: claude

.changeset/18670-project-banned-keys.md

@@ -2,25 +2,25 @@
 "@objectstack/spec": minor
 ---
 
-**BREAKING (published artifact narrows)** — `packages/spec/json-schema/**` now states the banned-key rule the tracing sampling filter enforces, so a validator reading the published files stops answering PASS on `{ "dialect": "cel" }` at `TraceSamplingConfig.composite[].condition` — the card's own worked instance of a published file saying yes to metadata the runtime refuses (#18670 item 2, the fourth and last of the ruling's named arms).
+**BREAKING (published artifact narrows)** — `packages/spec/json-schema/**` now states the banned-key rule the tracing sampling filter enforces, so a validator reading the published files stops answering PASS on `{ "dialect": "cel" }` at `TraceSamplingConfig.composite[].condition` — the card's own worked instance of a published file saying yes to metadata the runtime refuses (#18670 item 2, the fourth of the ruling's named arms).
 
-Clause-②: no
+Clause-②: yes (narrowing)
 
 One named pattern joins the closed list, and only one:
 
-- **`banned-keys` — "no document may carry any of these keys"**, emitted as `propertyNames` with a `not` over the banned names. The structured-filter arm of `TraceSamplingConfig.composite[].condition` refuses an object carrying `dialect`, because an object that carries one is an expression attempt and belongs to the union's other arm. The published file now says so.
+- **`banned-keys` — "no document may carry any of these keys"**, emitted as `propertyNames` with a `not` over the banned names. `TraceSamplingConfig.composite[].condition` is a structured filter of match criteria that refuses an object carrying `dialect`, because such an object is an expression attempt and this slot's expression arm was retired in 17.5.0. The published file now says so.
 
 **The rows retired, by name.** `packages/spec/dropped-refinements.baseline.json` goes from 202 entries / 553 sites to **200 entries / 551 sites**:
 
 | row | before | after |
 |:---|:---|:---|
-| `system/TraceSamplingConfig` | `sites: ["composite.element.condition.options[0]"]` | **deleted** — the schema drops nothing now |
-| `system/TracingConfig` | `sites: ["sampling.composite.element.condition.options[0]"]` | **deleted** — same site, reached through the parent |
+| `system/TraceSamplingConfig` | `sites: ["composite.element.condition"]` | **deleted** — the schema drops nothing now |
+| `system/TracingConfig` | `sites: ["sampling.composite.element.condition"]` | **deleted** — the same node, reached through the parent |
 
-2 sites closed, **0 sites added anywhere**, and the ledger diff is deletions only. Generator census after: 551 dropped across 200 published schemas, **369 projected** — 232 `non-blank-string`, 133 `required-one-of`, 2 `dependent-required`, **2 `banned-keys`** — 9 undecidable.
+2 sites closed, **0 sites added anywhere**, and the ledger diff is deletions only. Generator census after: 551 dropped across 200 published schemas, **357 projected** — 224 `non-blank-string`, 129 `required-one-of`, 2 `dependent-required`, **2 `banned-keys`** — 9 undecidable.
 
-**⛔ Not a behaviour change, and no document the runtime accepts becomes refused.** The arm is EXACT rather than approximate: a JSON object's properties are exactly its own enumerable string-keyed ones and `propertyNames` judges exactly those names, so "none of the banned names is an own property" and "no property name is one of the banned names" are one sentence read from two ends. It is presence and never value — a banned key present with a `null` value is present on both sides. Across the published tree, **1528 of the 1530 per-schema files are byte-identical**; the two that move gain the ban and lose the matching `x-dropped-refinements` row, and nothing else in either file changes. A dialect-bearing document the runtime still accepts — `{ "dialect": "cel", "source": "record.amount > 10" }` — is still accepted by the file, through the union's expression arm, which is untouched.
+**⛔ Not a behaviour change, and no document the runtime accepts becomes refused.** The arm is EXACT rather than approximate: a JSON object's properties are exactly its own enumerable string-keyed ones and `propertyNames` judges exactly those names, so "none of the banned names is an own property" and "no property name is one of the banned names" are one sentence read from two ends. It is presence and never value — a banned key present with a `null` value is present on both sides. The accept set at the slot is **unchanged in both directions**: every document the runtime takes (`{}`, `{ "service": "api" }`, any filter carrying no `dialect` key) the file still takes, and every document the runtime refuses the file now refuses too — a `dialect`-bearing object of any shape, the CEL envelope included, since that arm is retired and nothing here revives it. Across the published tree, **1528 of the 1530 per-schema files are byte-identical**; the two that move gain the ban and lose the matching `x-dropped-refinements` row, and nothing else in either file changes.
 
-**The list stays CLOSED.** `packages/spec/src/shared/refinement-projection.ts` declares the vocabulary and builds each predicate from its own declaration — the key list is read once and used by both the published keyword and the enforced rule — so the two cannot name different keys. The predicate judges OWN properties and never `key in value`: `in` walks the prototype chain, so a ban on a name `Object.prototype` carries would refuse `{}` itself while `propertyNames` accepts it, and that is a disagreement about a JSON document rather than an edge outside the domain. A ban over an OPEN set of names — every key starting with `$`, which is what `data/filter.zod.ts`'s normalized field condition refuses — is deliberately not this arm: its keys are a finite list, and a list that merely sampled an open set would be wider than the rule, so that site stays unprojected and keeps its annotation.
+**The list stays CLOSED.** `packages/spec/src/shared/refinement-projection.ts` declares the vocabulary and builds each predicate from its own declaration — the key list is read once and used by both the published keyword and the enforced rule — so the two cannot name different keys. The predicate judges OWN properties and never `key in value`: `in` walks the prototype chain, so a ban on a name `Object.prototype` carries would refuse `{}` itself while `propertyNames` accepts it, and that is a disagreement about a JSON document rather than an edge outside the domain. A ban over an OPEN set of names — every key starting with `$`, which is what `data/filter.zod.ts`'s normalized field condition refuses — is deliberately not this arm: its keys are a finite list, and a list that merely sampled an open set would be wider than the rule, so those sites stay unprojected and keep their annotation.
 
 <!-- adr-0087: not-required (no-migration-prescription) Nothing an author can write is removed, renamed or re-spelled: no spec key, no export and no config field changes, and the accepted set of metadata documents is byte-for-byte what it was. What changed is a machine-readable DECLARATION catching up with the runtime it always described, so there is nothing for `objectstack migrate meta` to rewrite and no stored representation to convert. -->

.scratch/seam2.ts

@@ -0,0 +1,19 @@
+import { TraceSamplingConfigSchema } from '../packages/spec/src/system/tracing.zod';
+import { projectPublishedJsonSchema } from '../packages/spec/scripts/lib/refinement-projection';
+import { collectDroppedRefinements } from '../packages/spec/scripts/lib/dropped-refinements';
+
+for (const io of ['output', 'input'] as const) {
+  try {
+    const n = projectPublishedJsonSchema(TraceSamplingConfigSchema, { io }) as any;
+    console.log(io, 'OK ->', JSON.stringify(n.properties.composite.items.properties.condition.allOf));
+  } catch (e) { console.log(io, 'THREW', (e as Error).message.slice(0, 60)); }
+}
+const parses = (condition: unknown): boolean =>
+  TraceSamplingConfigSchema.safeParse({ type: 'composite', composite: [{ strategy: 'always_on', condition }] }).success;
+for (const doc of [{}, { amount: { $gt: 10 } }, { dialect: 'cel' }, { dialect: null }, { dialect: 'cel', source: 'record.amount > 10' }, 'record.amount > 10']) {
+  console.log(JSON.stringify(doc), 'runtime=', parses(doc));
+}
+const c = collectDroppedRefinements('system/TraceSamplingConfig', TraceSamplingConfigSchema as never);
+console.log('dropped', JSON.stringify(c.dropped.map((s) => s.path)));
+console.log('projected', c.projected.map((s) => s.path + ' ' + JSON.stringify(s.declaredPatterns)).join(' | '));
+console.log('undecidable', JSON.stringify(c.undecidable.map((s) => s.path)));

packages/spec/dropped-refinements.baseline.json

@@ -4,7 +4,7 @@
     "zod": "4.4.3",
     "publishedSchemasWithDroppedRefinements": 200,
     "droppedRefinementSites": 551,
-    "refinementSitesThatDidProject": 369,
+    "refinementSitesThatDidProject": 357,
     "refinementSitesWithNoJsonFormToCompare": 9
   },
   "entries": {

packages/spec/scripts/lib/refinement-projection.ts

@@ -174,6 +174,12 @@ function emitDependentRequired(
  * trade the rule this arm adds for the key-type rule the node already stated.
  * An identical rule already present is left alone rather than duplicated, so
  * the arm is idempotent the way `emitNonBlankString` is.
+ *
+ * An EMPTY key list emits nothing, and the reason is stronger than "it would
+ * ban nothing": `enum` is specified as a non-empty array, so `{ not: { enum:
+ * [] } }` is an INVALID SCHEMA rather than a vacuous one — ajv refuses it with
+ * "enum must have non-empty array", which would take the whole published file
+ * down with it instead of leaving a keyword nobody reads.
  */
 function emitBannedKeys(jsonSchema: JsonObject, keys: readonly string[]): void {
   if (keys.length === 0) return;

packages/spec/scripts/refinement-projection.test.ts

@@ -528,7 +528,11 @@ describe('banned-keys: one key list, read twice', () => {
     expect(node.allOf).toEqual([{ propertyNames: { not: { enum: ['dialect'] } } }]);
   });
 
-  it('drops an empty key list rather than publishing a rule that bans nothing', () => {
+  it('drops an empty key list \u2014 `enum: []` is an INVALID schema, not a vacuous one', () => {
+    // ⛔ Not "it would ban nothing": `enum` is specified as a non-empty array,
+    // so `{ not: { enum: [] } }` fails validator schema-compilation outright
+    // (ajv: "enum must have non-empty array") and would take the whole
+    // published file down rather than sit there unread.
     const node: Record<string, unknown> = { type: 'object' };
     emitProjectableRefinement(node, { pattern: 'banned-keys', keys: [] });
     expect(node).toEqual({ type: 'object' });
@@ -582,13 +586,21 @@ describe('banned-keys: one key list, read twice', () => {
 });
 
 describe("the LIVE seam: the card's own worked instance stops saying yes", () => {
-  /** The published structured-filter arm of `TraceSamplingConfig.composite[].condition`. */
-  const structuredFilterArm = (): Record<string, unknown> => {
-    const node = publish(TraceSamplingConfigSchema, 'input');
+  /**
+   * The published `TraceSamplingConfig.composite[].condition` node.
+   *
+   * ⭐ It is the node ITSELF, not a union arm. #18118 retired this slot's CEL
+   * expression arm (PR #19084), so the union collapsed to the structured-filter
+   * record it always had beside it — which is why the ban lands directly on
+   * `condition` and is still conjoined through `allOf`: a record states its own
+   * `propertyNames: { type: 'string' }`, and that key-TYPE rule is not the one
+   * this arm adds.
+   */
+  const conditionNode = (): Record<string, unknown> => {
+    const node = publish(TraceSamplingConfigSchema);
     const composite = (node.properties as Record<string, Record<string, unknown>>).composite;
     const item = composite.items as Record<string, Record<string, Record<string, unknown>>>;
-    const condition = item.properties.condition as unknown as Record<string, unknown>;
-    return (condition.anyOf as Record<string, unknown>[])[0];
+    return item.properties.condition as unknown as Record<string, unknown>;
   };
 
   /** A `TraceSamplingConfig` that parses, with only `condition` varying. */
@@ -599,65 +611,53 @@ describe("the LIVE seam: the card's own worked instance stops saying yes", () =>
     }).success;
 
   it('states the ban, and keeps the record shape it always stated', () => {
-    const arm = structuredFilterArm();
-    expect(arm.type).toBe('object');
-    expect(arm.propertyNames).toEqual({ type: 'string' });
-    expect(arm.allOf).toEqual([{ propertyNames: { not: { enum: ['dialect'] } } }]);
+    const node = conditionNode();
+    expect(node.type).toBe('object');
+    expect(node.propertyNames).toEqual({ type: 'string' });
+    expect(node.allOf).toEqual([{ propertyNames: { not: { enum: ['dialect'] } } }]);
   });
 
   it("the card's own specimen — `{ dialect: 'cel' }` — is refused by BOTH sides now", () => {
     const doc = JSON.parse('{"dialect":"cel"}') as Record<string, unknown>;
     expect(parses(doc)).toBe(false);
-    expect(bannedKeysSatisfied(structuredFilterArm(), doc)).toBe(false);
+    expect(bannedKeysSatisfied(conditionNode(), doc)).toBe(false);
   });
 
-  it('⛔ no document this arm ACCEPTS is refused by the emitted keywords', () => {
-    const arm = structuredFilterArm();
-    const rule = bannedKeys(['dialect']);
+  it('⛔ the runtime and the emitted keywords agree on every document in the corpus', () => {
+    const node = conditionNode();
     const corpus: Array<Record<string, unknown>> = [
       {},
       { amount: { $gt: 1 } },
-      { 'account.name': { $eq: 'acme' } },
+      { service: 'api', attributes: { 'http.route': '/v1/orders' } },
       { dialect: 'cel' },
       { dialect: null },
+      // Since #18118 retired the expression arm, a healthy CEL envelope is
+      // refused at this slot too — so the two sides agree here as well, where
+      // before the retirement the union's other arm accepted it.
       { dialect: 'cel', source: 'record.amount > 10' },
     ];
     for (const doc of corpus) {
       const asJson = JSON.parse(JSON.stringify(doc)) as Record<string, unknown>;
       // Equality, not implication: this arm is exact, so a one-sided pin would
       // pass a projection that had stopped narrowing at all.
       expect(
-        bannedKeysSatisfied(arm, asJson),
+        bannedKeysSatisfied(node, asJson),
         `disagreement on ${JSON.stringify(asJson)}`,
-      ).toBe(rule(asJson));
+      ).toBe(parses(asJson));
     }
   });
 
-  it('⛔ and the EXPRESSION the runtime still accepts is still accepted by the file', () => {
-    // The union's other arm is what carries a dialect-bearing document, so
-    // narrowing the structured-filter arm refuses nothing the runtime accepts.
-    const doc = { dialect: 'cel', source: 'record.amount > 10' };
-    expect(parses(doc)).toBe(true);
-    const node = publish(TraceSamplingConfigSchema, 'input');
-    const composite = (node.properties as Record<string, Record<string, unknown>>).composite;
-    const item = composite.items as Record<string, Record<string, Record<string, unknown>>>;
-    const condition = item.properties.condition as unknown as Record<string, unknown>;
-    const envelope = (condition.anyOf as Record<string, unknown>[])[1];
-    const objectArm = (envelope.anyOf as Record<string, unknown>[])[1];
-    expect(objectArm.required).toEqual(['dialect', 'source']);
-  });
-
   it('LIT CONTROL — a structured filter with no `dialect` is accepted by both', () => {
     const doc = JSON.parse('{"amount":{"$gt":10}}') as Record<string, unknown>;
     expect(parses(doc)).toBe(true);
-    expect(bannedKeysSatisfied(structuredFilterArm(), doc)).toBe(true);
+    expect(bannedKeysSatisfied(conditionNode(), doc)).toBe(true);
   });
 
   it('its ledger row is gone because the site now reads `projected`, naming the arm', () => {
     const census = collectDroppedRefinements('system/TraceSamplingConfig', TraceSamplingConfigSchema);
-    const site = census.projected.find((s) => s.path === 'composite.element.condition.options[0]');
+    const site = census.projected.find((s) => s.path === 'composite.element.condition');
     expect(site?.declaredPatterns).toEqual(['banned-keys']);
-    expect(census.dropped.map((s) => s.path)).not.toContain('composite.element.condition.options[0]');
+    expect(census.dropped).toEqual([]);
   });
 });