diff --git a/index.bs b/index.bs
index e894e7c606..df0cc49763 100644
--- a/index.bs
+++ b/index.bs
@@ -691,38 +691,6 @@ a [=report window=] [=struct=] with the following fields:
 [=report windows=], because there are no gaps in time between any of the
 [=report windows|windows=].
 
-<h3 id="summary-operator-header">Summary operator</h3>
-
-A <dfn>summary operator</dfn> summarizes the triggers attributed to an
-[=attribution source=]. Its value is one of the following:
-
-<dl dfn-for="summary operator">
-: "<dfn><code>count</code></dfn>"
-:: Number of triggers attributed.
-: "<dfn><code>value_sum</code></dfn>"
-:: Sum of the value of triggers.
-
-</dl>
-
-<h3 id="summary-bucket-header">Summary bucket</h3>
-
-A <dfn>summary bucket</dfn> is a [=struct=] with the following items:
-
-<dl dfn-for="summary bucket">
-: <dfn>start</dfn>
-:: An unsigned 32-bit integer.
-: <dfn>end</dfn>
-:: An unsigned 32-bit integer.
-
-</dl>
-
-A <dfn>summary bucket list</dfn> is a [=list=] of [=summary buckets=].
-It has the following constraints:
-
-* Elements are strictly in ascending order based on their [=summary bucket/start=].
-* Every element's [=summary bucket/end=] is equal to the next element's [=summary bucket/start=] - 1, if it exists.
-* There is at least one element in the list.
-
 <h3 id="trigger-data-matching-mode-header">Trigger-data matching mode</h3>
 
 A <dfn>trigger-data matching mode</dfn> is one of the following:
@@ -969,8 +937,6 @@ An event-level trigger configuration is a [=struct=] with the following items:
 :: A [=list=] of [=filter configs=].
 : <dfn>negated filters</dfn>
 :: A [=list=] of [=filter configs=].
-: <dfn>value</dfn>
-:: A positive unsigned 32-bit integer.
 
 </dl>
 
@@ -2437,11 +2403,8 @@ A <dfn>source-registration JSON key</dfn> is one of the following:
 <li>"<dfn><code>priority</code></dfn>"
 <li>"<dfn><code>source_event_id</code></dfn>"
 <li>"<dfn><code>start_time</code></dfn>"
-<li>"<dfn><code>summary_buckets</code></dfn>"
-<li>"<dfn><code>summary_operator</code></dfn>"
 <li>"<dfn><code>trigger_data</code></dfn>"
 <li>"<dfn><code>trigger_data_matching</code></dfn>"
-<li>"<dfn><code>trigger_specs</code></dfn>"
 <li>"<dfn><code>values</code></dfn>"
 </ul>
 
@@ -2594,56 +2557,12 @@ To <dfn>parse report windows</dfn> given a |value|, a
     1. Set |startDuration| to |endDuration|.
 1. Return |windows|.
 
-The user-agent has an associated boolean
-<dfn>experimental Flexible Event support</dfn> (default false) that exposes
-non-normative behavior described in the
-<a href="https://github.com/WICG/attribution-reporting-api/blob/main/flexible_event_config.md">Flexible event-level configurations</a>
-proposal.
-
-To <dfn>parse summary operator</dfn> given a [=map=] |map|:
-
-1. Let |value| be "<code>[=summary operator/count=]</code>".
-1. If |map|["<code>[=source-registration JSON key/summary_operator=]</code>"] [=map/exists=]:
-    1. If |map|["<code>[=source-registration JSON key/summary_operator=]</code>"] is not a [=string=], return an
-        error.
-    1. If |map|["<code>[=source-registration JSON key/summary_operator=]</code>"] is not a
-        [=summary operator=], return an error.
-    1. Set |value| to |map|["<code>[=source-registration JSON key/summary_operator=]</code>"].
-1. Return |value|.
-
-To <dfn>parse summary buckets</dfn> given a [=map=] |map| and an integer |maxEventLevelReports|:
-
-1. Let |values| be [=the inclusive range|the range=] 1 to
-    |maxEventLevelReports|, inclusive.
-1. If |map|["<code>[=source-registration JSON key/summary_buckets=]</code>"] [=map/exists=]:
-    1. If |map|["<code>[=source-registration JSON key/summary_buckets=]</code>"] is not a [=list=], [=list/is empty=], or
-        its [=list/size=] is greater than |maxEventLevelReports|, return an
-        error.
-    1. Set |values| to |map|["<code>[=source-registration JSON key/summary_buckets=]</code>"].
-1. Let |prev| be 0.
-1. Let |summaryBuckets| be a new [=list=].
-1. [=list/iterate|For each=] |item| of |values|:
-    1. If |item| is not an integer or cannot be represented by an unsigned
-        32-bit integer, or is less than or equal to |prev|, return an error.
-    1. Let |summaryBucket| be a new [=summary bucket=] whose items are
-
-        : [=summary bucket/start=]
-        :: |prev|
-        : [=summary bucket/end=]
-        :: |item| - 1
-
-    1. [=list/Append=] |summaryBucket| to |summaryBuckets|.
-    1. Set |prev| to |item|.
-1. Return |summaryBuckets|.
-
 To <dfn>parse trigger data into a trigger spec map</dfn> given a
-|triggerDataList|, a [=trigger spec=] |spec|, a [=trigger spec map=]
-|specs|, and a [=boolean=] |allowEmpty|:
+|triggerDataList|, a [=trigger spec=] |spec|, and a [=trigger spec map=]
+|specs|:
 
 1. If |triggerDataList| is not a [=list=] or its [=list/size=] is greater than
     [=max distinct trigger data per source=], return false.
-1. If |allowEmpty| is false and |triggerDataList| [=list/is empty=], return
-    false.
 1. [=list/iterate|For each=] |triggerData| of |triggerDataList|:
     1. If |triggerData| is not an integer or cannot be represented by an
         unsigned 32-bit integer, or |specs|[|triggerData|] [=map/exists=],
@@ -2662,45 +2581,19 @@ To <dfn>parse trigger specs</dfn> given a [=map=] |map|, a [=moment=]
     and |expiry|.
 1. If |defaultReportWindows| is an error, return an error.
 1. Let |specs| be a new [=trigger spec map=].
-1. If [=experimental Flexible Event support=] is true and
-    |map|["<code>[=source-registration JSON key/trigger_specs=]</code>"] [=map/exists=]:
-    1. If |map|["<code>[=source-registration JSON key/trigger_data=]</code>"] [=map/exists=], return an error.
-    1. If |map|["<code>[=source-registration JSON key/trigger_specs=]</code>"] is not a [=list=] or its
-        [=list/size=] is greater than [=max distinct trigger data per source=],
+1. Let |spec| be a new [=trigger spec=] with the following items:
+    : [=trigger spec/event-level report windows=]
+    :: |defaultReportWindows|
+1. If |map|["<code>[=source-registration JSON key/trigger_data=]</code>"] [=map/exists=]:
+    1. If the result of running
+        [=parse trigger data into a trigger spec map=] with
+        |map|["<code>[=source-registration JSON key/trigger_data=]</code>"], |spec|, and |specs| is false,
         return an error.
-    1. [=list/iterate|For each=] |item| of |map|["<code>[=source-registration JSON key/trigger_specs=]</code>"]:
-        1. If |item| is not a [=map=], return an error.
-        1. Let |spec| be a new [=trigger spec=] with the following items:
-            : [=trigger spec/event-level report windows=]
-            :: |defaultReportWindows|
-        1. If |item|["<code>[=source-registration JSON key/event_report_windows=]</code>"] [=map/exists=]:
-            1. Let |reportWindows| be the result of
-                [=parsing report windows=] with |item|["<code>[=source-registration JSON key/event_report_windows=]</code>"],
-                |sourceTime|, and |expiry|.
-            1. If |reportWindows| is an error, return it.
-            1. Set |spec|'s [=trigger spec/event-level report windows=] to
-                |reportWindows|.
-        1. If |item|["<code>[=source-registration JSON key/trigger_data=]</code>"] does not [=map/exist=], return an error.
-        1. Let |allowEmpty| be false.
-        1. If the result of running
-            [=parse trigger data into a trigger spec map=] with
-            |item|["<code>[=source-registration JSON key/trigger_data=]</code>"], |spec|, |specs|, and |allowEmpty| is
-            false, return an error.
 1. Otherwise:
-    1. Let |spec| be a new [=trigger spec=] with the following items:
-        : [=trigger spec/event-level report windows=]
-        :: |defaultReportWindows|
-    1. If |map|["<code>[=source-registration JSON key/trigger_data=]</code>"] [=map/exists=]:
-        1. Let |allowEmpty| be true.
-        1. If the result of running
-            [=parse trigger data into a trigger spec map=] with
-            |map|["<code>[=source-registration JSON key/trigger_data=]</code>"], |spec|, |specs|, and |allowEmpty| is false,
-            return an error.
-    1. Otherwise:
-        1. [=set/iterate|For each=] integer |triggerData| of
-            [=the exclusive range|the range=] 0 to
-            [=default trigger data cardinality=][|sourceType|], exclusive:
-            1. [=map/Set=] |specs|[|triggerData|] to |spec|.
+    1. [=set/iterate|For each=] integer |triggerData| of
+        [=the exclusive range|the range=] 0 to
+        [=default trigger data cardinality=][|sourceType|], exclusive:
+        1. [=map/Set=] |specs|[|triggerData|] to |spec|.
 1. If |matchingMode| is "<code>[=trigger-data matching mode/modulus=]</code>":
     1. Let |i| be 0.
     1. [=map/iterate|For each=] |triggerData| of |specs|'s [=map/get the keys|keys=]:
@@ -2708,9 +2601,6 @@ To <dfn>parse trigger specs</dfn> given a [=map=] |map|, a [=moment=]
         1. Set |i| to |i| + 1.
 1. Return |specs|.
 
-Issue: Invoke [=parse summary buckets=] and [=parse summary operator=]
-from this algorithm.
-
 To <dfn>parse a source aggregatable debug reporting config</dfn> given |value|, a
 non-negative integer |defaultBudget|, and an [=aggregatable debug reporting config=]
 |defaultConfig|:
@@ -3471,15 +3361,6 @@ A <dfn>trigger-registration JSON key</dfn> is one of the following:
 
 <h3 algorithm id="attribution-trigger-creation">Creating an attribution trigger</h3>
 
-To <dfn>parse an event-trigger value</dfn> given a [=map=] |map|:
-
-1. If [=experimental Flexible Event support=] is false or |map|["<code>[=trigger-registration JSON key/value=]</code>"] does
-    not [=map/exists|exist=], return 1.
-1. Let |value| be |map|["<code>[=trigger-registration JSON key/value=]</code>"].
-1. If |value| is not an integer, cannot be represented by an unsigned 32-bit
-    integer, or is less than or equal to zero, return an error.
-1. Return |value|.
-
 To <dfn>parse event triggers</dfn> given a [=map=] |map|:
 
 1. Let |eventTriggers| be a new [=set=].
@@ -3504,9 +3385,6 @@ To <dfn>parse event triggers</dfn> given a [=map=] |map|:
     1. Let |filterPair| be the result of running [=parse a filter pair=] with
         |value|.
     1. If |filterPair| is an error, return it.
-    1. Let |triggerValue| be the result of running
-        [=parse an event-trigger value=] with |value|.
-    1. If |triggerValue| is an error, return it.
     1. Let |eventTrigger| be a new [=event-level trigger configuration=] with
         the items:
         : [=event-level trigger configuration/trigger data=]
@@ -3519,8 +3397,6 @@ To <dfn>parse event triggers</dfn> given a [=map=] |map|:
         :: |filterPair|[0]
         : [=event-level trigger configuration/negated filters=]
         :: |filterPair|[1]
-        : [=event-level trigger configuration/value=]
-        :: |triggerValue|
     1. [=set/Append=] |eventTrigger| to |eventTriggers|.
 1. Return |eventTriggers|.
 
@@ -4107,10 +3983,6 @@ To <dfn>maybe replace event-level report</dfn> given an [=attribution source=]
 1. [=set/Remove=] |rateLimitRecord| from the [=attribution rate-limit cache=].
 1. Return "<code>[=event-level-report-replacement result/add-new-report=]</code>".
 
-Issue: This algorithm is not compatible with the behavior proposed for
-[=experimental Flexible Event support=] with differing
-[=trigger spec/event-level report windows=] for a given source.
-
 To <dfn>trigger event-level attribution</dfn> given an [=attribution trigger=] |trigger| and an
 [=attribution source=] |sourceToAttribute|, run the following steps:
 
diff --git a/ts/src/flexible-event/main.ts b/ts/src/flexible-event/main.ts
index 9cbc3df330..53ca3ab039 100644
--- a/ts/src/flexible-event/main.ts
+++ b/ts/src/flexible-event/main.ts
@@ -101,7 +101,6 @@ if (options.json_file !== undefined) {
   const [{ errors, warnings }, source] = validateSource(json, {
     vsv: vsv.Chromium,
     sourceType: options.source_type,
-    fullFlex: true,
   })
   warnings.forEach((i) => logIssue('W', i))
   if (errors.length > 0) {
@@ -114,12 +113,10 @@ if (options.json_file !== undefined) {
       new Config(
         source.maxEventLevelReports,
         source.attributionScopes,
-        source.triggerSpecs.flatMap((spec) =>
-          new Array<PerTriggerDataConfig>(spec.triggerData.size).fill(
-            new PerTriggerDataConfig(
-              spec.eventReportWindows.endTimes.length,
-              spec.summaryBuckets.length
-            )
+        new Array<PerTriggerDataConfig>(source.triggerData.size).fill(
+          new PerTriggerDataConfig(
+            source.eventReportWindows.endTimes.length,
+            source.maxEventLevelReports
           )
         )
       )
diff --git a/ts/src/header-validator/index.html b/ts/src/header-validator/index.html
index 8494790117..a17b5bbd19 100644
--- a/ts/src/header-validator/index.html
+++ b/ts/src/header-validator/index.html
@@ -84,7 +84,6 @@ <h1>Attribution Reporting Header Validation</h1>
       <p><label><input type=radio name=header value=eligible><code>Attribution-Reporting-Eligible</code></label>
       <p><label><input type=radio name=header value=info><code>Attribution-Reporting-Info</code></label>
       <p><label><input type=checkbox checked disabled>Use Chromium's vendor-specific values</label> <a href="https://github.com/WICG/attribution-reporting-api/blob/main/params/chromium-params.md" target=_blank>(details)</a>
-      <p><label><input type=checkbox name=flex>Enable experimental Flexible Event fields</label> <a href="https://github.com/WICG/attribution-reporting-api/blob/main/flexible_event_config.md" target=_blank>(details)</a>
     </fieldset>
     <fieldset id=output>
       <legend>Validation Result</legend>
diff --git a/ts/src/header-validator/index.ts b/ts/src/header-validator/index.ts
index aad868ce64..8358e550d9 100644
--- a/ts/src/header-validator/index.ts
+++ b/ts/src/header-validator/index.ts
@@ -22,34 +22,27 @@ const sourceTypeFieldset =
   document.querySelector<HTMLFieldSetElement>('#source-type')!
 const effective = document.querySelector('#effective')!
 
-const flexCheckbox = form.elements.namedItem('flex') as HTMLInputElement
-
 function sourceType(): SourceType {
   return parseSourceType(sourceTypeRadios.value)
 }
 
 function validate(): void {
   sourceTypeFieldset.disabled = true
-  flexCheckbox.disabled = true
 
   let v: validator.Validator<unknown>
 
   switch (headerRadios.value) {
     case 'source':
       sourceTypeFieldset.disabled = false
-      flexCheckbox.disabled = false
       v = source.validator({
         vsv: vsv.Chromium,
         sourceType: sourceType(),
-        fullFlex: flexCheckbox.checked,
         noteInfoGain: true,
       })
       break
     case 'trigger':
-      flexCheckbox.disabled = false
       v = trigger.validator({
         vsv: vsv.Chromium,
-        fullFlex: flexCheckbox.checked,
       })
       break
     case 'os-source':
@@ -99,8 +92,6 @@ document.querySelector('#linkify')!.addEventListener('click', () => {
     url.searchParams.set('source-type', sourceType())
   }
 
-  url.searchParams.set('flex', flexCheckbox.checked.toString())
-
   void navigator.clipboard.writeText(url.toString())
 })
 
@@ -136,6 +127,4 @@ if (st !== null && st in SourceType) {
 }
 sourceTypeRadios.value = st
 
-flexCheckbox.checked = params.get('flex') === 'true'
-
 validate()
diff --git a/ts/src/header-validator/main.ts b/ts/src/header-validator/main.ts
index 7ce094432f..d9d3e45f1b 100644
--- a/ts/src/header-validator/main.ts
+++ b/ts/src/header-validator/main.ts
@@ -11,7 +11,6 @@ interface Arguments {
   input?: string
   file?: string
 
-  fullFlex: boolean
   sourceType?: SourceType
 
   silent: boolean
@@ -43,11 +42,6 @@ const options = parse<Arguments>(
         'If present, parse input as a source. Otherwise, parse as a trigger.',
     },
 
-    fullFlex: {
-      type: Boolean,
-      description: 'If true, parse experimental Full Flexible Event fields.',
-    },
-
     silent: {
       type: Boolean,
       description: 'If true, suppress output.',
@@ -94,11 +88,9 @@ const out = validate<unknown>(
   options.sourceType === undefined
     ? trigger.validator({
         vsv: vsv.Chromium,
-        fullFlex: options.fullFlex,
       })
     : source.validator({
         vsv: vsv.Chromium,
-        fullFlex: options.fullFlex,
         sourceType: options.sourceType,
       })
 )
diff --git a/ts/src/header-validator/source.test.ts b/ts/src/header-validator/source.test.ts
index 9d75a45e14..bc0144d0c2 100644
--- a/ts/src/header-validator/source.test.ts
+++ b/ts/src/header-validator/source.test.ts
@@ -1,7 +1,7 @@
 import { SourceType } from '../source-type'
 import * as vsv from '../vendor-specific-values'
 import { Maybe } from './maybe'
-import { Source, SummaryOperator, TriggerDataMatching } from './source'
+import { Source, TriggerDataMatching } from './source'
 import * as testutil from './util.test'
 import * as jsontest from './validate-json.test'
 import * as source from './validate-source'
@@ -69,17 +69,11 @@ const testCases: TestCase[] = [
       priority: 2n,
       sourceEventId: 3n,
       maxEventLevelReports: 2,
-      triggerSpecs: [
-        {
-          eventReportWindows: {
-            startTime: 0,
-            endTimes: [3601],
-          },
-          summaryBuckets: [1, 2],
-          summaryOperator: SummaryOperator.count,
-          triggerData: new Set([0, 1, 2, 3, 4, 5, 6, 7]),
-        },
-      ],
+      eventReportWindows: {
+        startTime: 0,
+        endTimes: [3601],
+      },
+      triggerData: new Set([0, 1, 2, 3, 4, 5, 6, 7]),
       triggerDataMatching: TriggerDataMatching.modulus,
       aggregatableDebugReporting: {
         budget: 1234,
@@ -2109,97 +2103,6 @@ const testCases: TestCase[] = [
     ],
   },
 
-  // Flex
-  // TODO: compare returned trigger specs against expected values
-
-  {
-    name: 'trigger-specs-wrong-type',
-    input: `{
-      "destination": "https://a.test",
-      "trigger_specs": {}
-    }`,
-    parseFullFlex: true,
-    expectedErrors: [
-      {
-        path: ['trigger_specs'],
-        msg: 'must be a list',
-      },
-    ],
-  },
-  {
-    name: 'trigger-specs-too-long',
-    input: JSON.stringify({
-      destination: 'https://a.test',
-      trigger_specs: Array(33)
-        .fill(null)
-        .map((_, i) => ({ trigger_data: [i] })),
-    }),
-    parseFullFlex: true,
-    expectedErrors: [
-      {
-        path: ['trigger_specs'],
-        msg: 'length must be in the range [0, 32]',
-      },
-    ],
-  },
-  {
-    name: 'trigger-specs-value-wrong-type',
-    input: `{
-      "destination": "https://a.test",
-      "trigger_specs": [false]
-    }`,
-    parseFullFlex: true,
-    expectedErrors: [
-      {
-        path: ['trigger_specs', 0],
-        msg: 'must be an object',
-      },
-    ],
-  },
-  {
-    name: 'top-level-trigger-data-and-trigger-specs',
-    input: `{
-      "destination": "https://a.test",
-      "trigger_data": [],
-      "trigger_specs": []
-    }`,
-    parseFullFlex: true,
-    expectedErrors: [
-      {
-        path: [],
-        msg: 'mutually exclusive fields: trigger_data, trigger_specs',
-      },
-    ],
-  },
-  {
-    name: 'top-level-trigger-data-and-trigger-specs-ignored',
-    input: `{
-      "destination": "https://a.test",
-      "max_event_level_reports": 0,
-      "trigger_data": [],
-      "trigger_specs": []
-    }`,
-    expectedWarnings: [
-      {
-        path: ['trigger_specs'],
-        msg: 'unknown field',
-      },
-    ],
-  },
-  {
-    name: 'trigger-data-missing',
-    input: `{
-      "destination": "https://a.test",
-      "trigger_specs": [{}]
-    }`,
-    parseFullFlex: true,
-    expectedErrors: [
-      {
-        path: ['trigger_specs', 0, 'trigger_data'],
-        msg: 'required',
-      },
-    ],
-  },
   {
     name: 'trigger-data-wrong-type',
     input: `{
@@ -2291,270 +2194,6 @@ const testCases: TestCase[] = [
       },
     ],
   },
-  {
-    name: 'trigger-data-duplicated-across',
-    input: `{
-      "destination": "https://a.test",
-      "trigger_specs": [
-        { "trigger_data": [1, 2] },
-        { "trigger_data": [3, 2] }
-      ]
-    }`,
-    parseFullFlex: true,
-    expectedErrors: [
-      {
-        path: ['trigger_specs'],
-        msg: 'duplicate trigger_data: 2',
-      },
-    ],
-  },
-  {
-    name: 'trigger-spec-trigger-data-empty',
-    input: `{
-      "destination": "https://a.test",
-      "trigger_specs": [{"trigger_data": []}]
-    }`,
-    parseFullFlex: true,
-    expectedErrors: [
-      {
-        path: ['trigger_specs', 0, 'trigger_data'],
-        msg: 'length must be in the range [1, 32]',
-      },
-    ],
-  },
-  {
-    name: 'trigger-data-too-many-across',
-    input: JSON.stringify({
-      destination: 'https://a.test',
-      trigger_specs: [
-        { trigger_data: [0] },
-        {
-          trigger_data: Array(32)
-            .fill(0)
-            .map((_, i) => i + 1),
-        },
-      ],
-    }),
-    parseFullFlex: true,
-    expectedErrors: [
-      {
-        path: ['trigger_specs'],
-        msg: 'exceeds maximum number of distinct trigger_data (33 > 32)',
-      },
-    ],
-  },
-  {
-    name: 'summary-buckets-wrong-type',
-    input: `{
-      "destination": "https://a.test",
-      "trigger_specs": [{
-        "trigger_data": [3],
-        "summary_buckets": 1
-      }]
-    }`,
-    parseFullFlex: true,
-    expectedErrors: [
-      {
-        path: ['trigger_specs', 0, 'summary_buckets'],
-        msg: 'must be a list',
-      },
-    ],
-  },
-  {
-    name: 'summary-buckets-empty',
-    input: `{
-      "destination": "https://a.test",
-      "trigger_specs": [{
-        "trigger_data": [3],
-        "summary_buckets": []
-      }]
-    }`,
-    parseFullFlex: true,
-    expectedErrors: [
-      {
-        path: ['trigger_specs', 0, 'summary_buckets'],
-        msg: 'length must be in the range [1, 3 (max_event_level_reports)]',
-      },
-    ],
-  },
-  {
-    name: 'summary-buckets-too-long',
-    input: `{
-      "destination": "https://a.test",
-      "max_event_level_reports": 4,
-      "trigger_specs": [{
-        "trigger_data": [3],
-        "summary_buckets": [1, 2, 3, 4, 5]
-      }]
-    }`,
-    parseFullFlex: true,
-    expectedErrors: [
-      {
-        path: ['trigger_specs', 0, 'summary_buckets'],
-        msg: 'length must be in the range [1, 4 (max_event_level_reports)]',
-      },
-    ],
-  },
-  {
-    name: 'summary-buckets-cannot-validate-length',
-    input: `{
-      "destination": "https://a.test",
-      "max_event_level_reports": null,
-      "trigger_specs": [{
-        "trigger_data": [3],
-        "summary_buckets": [1, 2, 3, 4, 5]
-      }]
-    }`,
-    parseFullFlex: true,
-    expectedErrors: [
-      {
-        path: ['max_event_level_reports'],
-        msg: 'must be a number',
-      },
-      {
-        path: ['trigger_specs', 0, 'summary_buckets'],
-        msg: 'cannot be fully validated without a valid max_event_level_reports',
-      },
-    ],
-  },
-  {
-    name: 'summary-buckets-value-wrong-type',
-    input: `{
-      "destination": "https://a.test",
-      "trigger_specs": [{
-        "trigger_data": [3],
-        "summary_buckets": ["1"]
-      }]
-    }`,
-    parseFullFlex: true,
-    expectedErrors: [
-      {
-        path: ['trigger_specs', 0, 'summary_buckets', 0],
-        msg: 'must be a number',
-      },
-    ],
-  },
-  {
-    name: 'summary-buckets-value-not-integer',
-    input: `{
-      "destination": "https://a.test",
-      "trigger_specs": [{
-        "trigger_data": [3],
-        "summary_buckets": [1.5]
-      }]
-    }`,
-    parseFullFlex: true,
-    expectedErrors: [
-      {
-        path: ['trigger_specs', 0, 'summary_buckets', 0],
-        msg: 'must be an integer',
-      },
-    ],
-  },
-  {
-    name: 'summary-buckets-value-non-positive',
-    input: `{
-      "destination": "https://a.test",
-      "trigger_specs": [{
-        "trigger_data": [3],
-        "summary_buckets": [0]
-      }]
-    }`,
-    parseFullFlex: true,
-    expectedErrors: [
-      {
-        path: ['trigger_specs', 0, 'summary_buckets', 0],
-        msg: 'must be > implicit minimum (0) and <= uint32 max (4294967295)',
-      },
-    ],
-  },
-  {
-    name: 'summary-buckets-non-increasing',
-    input: `{
-      "destination": "https://a.test",
-      "trigger_specs": [{
-        "trigger_data": [3],
-        "summary_buckets": [5, 6, 4]
-      }]
-    }`,
-    parseFullFlex: true,
-    expectedErrors: [
-      {
-        path: ['trigger_specs', 0, 'summary_buckets', 2],
-        msg: 'must be > previous value (6) and <= uint32 max (4294967295)',
-      },
-    ],
-  },
-  {
-    name: 'summary-buckets-value-exceeds-max',
-    input: `{
-      "destination": "https://a.test",
-      "trigger_specs": [{
-        "trigger_data": [3],
-        "summary_buckets": [4294967296]
-      }]
-    }`,
-    parseFullFlex: true,
-    expectedErrors: [
-      {
-        path: ['trigger_specs', 0, 'summary_buckets', 0],
-        msg: 'must be > implicit minimum (0) and <= uint32 max (4294967295)',
-      },
-    ],
-  },
-  {
-    name: 'summary-operator-wrong-type',
-    input: `{
-      "destination": "https://a.test",
-      "trigger_specs": [{
-        "trigger_data": [3],
-        "summary_operator": 4
-      }]
-    }`,
-    parseFullFlex: true,
-    expectedErrors: [
-      {
-        path: ['trigger_specs', 0, 'summary_operator'],
-        msg: 'must be a string',
-      },
-    ],
-  },
-  {
-    name: 'summary-operator-wrong-value',
-    input: `{
-      "destination": "https://a.test",
-      "trigger_specs": [{
-        "trigger_data": [3],
-        "summary_operator": "VALUE_SUM"
-      }]
-    }`,
-    parseFullFlex: true,
-    expectedErrors: [
-      {
-        path: ['trigger_specs', 0, 'summary_operator'],
-        msg: 'must be one of the following (case-sensitive): count, value_sum',
-      },
-    ],
-  },
-  {
-    // The parser is shared with top-level event_report_windows, so just test
-    // basic support here.
-    name: 'spec-event-windows-basic',
-    input: `{
-      "destination": "https://a.test",
-      "trigger_specs": [{
-        "trigger_data": [3],
-        "event_report_windows": {}
-      }]
-    }`,
-    parseFullFlex: true,
-    expectedErrors: [
-      {
-        path: ['trigger_specs', 0, 'event_report_windows', 'end_times'],
-        msg: 'required',
-      },
-    ],
-  },
   {
     name: 'trigger-data-matching-wrong-type',
     input: `{
@@ -2595,24 +2234,6 @@ const testCases: TestCase[] = [
       },
     ],
   },
-  {
-    name: 'trigger-data-matching-modulus-trigger-data-not-contiguous-across',
-    input: `{
-      "destination": "https://a.test",
-      "trigger_data_matching": "modulus",
-      "trigger_specs": [
-        {"trigger_data": [0, 1]},
-        {"trigger_data": [3]}
-      ]
-    }`,
-    parseFullFlex: true,
-    expectedErrors: [
-      {
-        path: ['trigger_data_matching'],
-        msg: 'trigger_data must form a contiguous sequence of integers starting at 0 for modulus',
-      },
-    ],
-  },
   {
     name: 'trigger-data-matching-modulus-trigger-data-not-contiguous-within',
     input: `{
@@ -2640,26 +2261,6 @@ const testCases: TestCase[] = [
       },
     ],
   },
-  {
-    name: 'trigger-data-matching-modulus-valid-across',
-    input: `{
-      "destination": "https://a.test",
-      "trigger_data_matching": "modulus",
-      "trigger_specs": [
-        {"trigger_data": [1, 0]},
-        {"trigger_data": [3]},
-        {"trigger_data": [2]},
-        {"trigger_data": [4, 5, 6, 7, 8, 9, 10]}
-      ]
-    }`,
-    vsv: {
-      maxEventLevelChannelCapacityPerSource: {
-        [SourceType.event]: Infinity,
-        [SourceType.navigation]: Infinity,
-      },
-    },
-    parseFullFlex: true,
-  },
   {
     name: 'trigger-data-matching-modulus-valid-within',
     input: `{
@@ -3236,7 +2837,6 @@ testCases.forEach((tc) =>
     source.validator({
       vsv: { ...vsv.Chromium, ...tc.vsv },
       sourceType: tc.sourceType ?? SourceType.navigation,
-      fullFlex: tc.parseFullFlex,
       noteInfoGain: tc.noteInfoGain,
     })
   )
diff --git a/ts/src/header-validator/source.ts b/ts/src/header-validator/source.ts
index 7eeb69fcf4..f4e5a24465 100644
--- a/ts/src/header-validator/source.ts
+++ b/ts/src/header-validator/source.ts
@@ -10,18 +10,6 @@ export type FilterData = Map<string, Set<string>>
 export type AggregationKeys = Map<string, bigint>
 export type NamedBudgets = Map<string, number>
 
-export enum SummaryOperator {
-  count = 'count',
-  value_sum = 'value_sum',
-}
-
-export type TriggerSpec = {
-  eventReportWindows: EventReportWindows
-  summaryBuckets: number[]
-  summaryOperator: SummaryOperator
-  triggerData: Set<number>
-}
-
 export type SourceAggregatableDebugReportingConfig =
   reg.AggregatableDebugReportingConfig & {
     budget: number
@@ -49,7 +37,8 @@ export type Source = reg.CommonDebug &
     maxEventLevelReports: number
     sourceEventId: bigint
 
-    triggerSpecs: TriggerSpec[]
+    eventReportWindows: EventReportWindows
+    triggerData: Set<number>
     triggerDataMatching: TriggerDataMatching
 
     eventLevelEpsilon: number
diff --git a/ts/src/header-validator/to-json.ts b/ts/src/header-validator/to-json.ts
index 38402e35b8..2c2f97b797 100644
--- a/ts/src/header-validator/to-json.ts
+++ b/ts/src/header-validator/to-json.ts
@@ -81,45 +81,6 @@ function serializeAggregatableDebugReportingConfig(
   }
 }
 
-type EventReportWindows = {
-  event_report_windows: { start_time: number; end_times: number[] }
-}
-
-function serializeEventReportWindows(
-  e: source.EventReportWindows
-): EventReportWindows {
-  return {
-    event_report_windows: {
-      start_time: e.startTime,
-      end_times: [...e.endTimes],
-    },
-  }
-}
-
-type TriggerData = {
-  trigger_data: number[]
-}
-
-function serializeTriggerData(d: Set<number>): TriggerData {
-  return { trigger_data: Array.from(d) }
-}
-
-type TriggerSpec = EventReportWindows &
-  TriggerData & {
-    summary_buckets: number[]
-    summary_operator: string
-  }
-
-function serializeTriggerSpec(ts: source.TriggerSpec): TriggerSpec {
-  return {
-    ...serializeEventReportWindows(ts.eventReportWindows),
-    ...serializeTriggerData(ts.triggerData),
-
-    summary_buckets: Array.from(ts.summaryBuckets),
-    summary_operator: ts.summaryOperator,
-  }
-}
-
 type SourceAggregatableDebugReportingConfig =
   AggregatableDebugReportingConfig & {
     budget: number
@@ -151,71 +112,29 @@ function serializeAttributionScopes(
   }
 }
 
-type NotFullFlexSource = Partial<EventReportWindows> & {
-  trigger_data: number[]
-  trigger_specs?: never
-}
-
-type FullFlexSource = {
-  event_report_windows?: never
-  trigger_data?: never
-  trigger_specs: TriggerSpec[]
-}
-
-function serializeFlexSource(
-  s: source.Source,
-  fullFlex: boolean
-): NotFullFlexSource | FullFlexSource {
-  if (fullFlex) {
-    return {
-      trigger_specs: Array.from(s.triggerSpecs, serializeTriggerSpec),
-    }
-  }
-
-  if (s.triggerSpecs.length === 0) {
-    return { trigger_data: [] }
-  }
-
-  if (s.triggerSpecs.length === 1) {
-    return {
-      ...serializeEventReportWindows(s.triggerSpecs[0]!.eventReportWindows),
-      ...serializeTriggerData(s.triggerSpecs[0]!.triggerData),
-    }
-  }
-
-  throw new TypeError()
-}
-
 type Source = CommonDebug &
-  Priority &
-  (NotFullFlexSource | FullFlexSource) & {
+  Priority & {
     aggregation_keys: { [key: string]: string }
     named_budgets?: { [key: string]: number }
     aggregatable_report_window: number
     destination: string[]
     destination_limit_priority: string
     event_level_epsilon: number
+    event_report_windows: { start_time: number; end_times: number[] }
     expiry: number
     filter_data: { [key: string]: string[] }
     max_event_level_reports: number
     source_event_id: string
+    trigger_data: number[]
     trigger_data_matching: string
     aggregatable_debug_reporting?: SourceAggregatableDebugReportingConfig
     attribution_scopes?: AttributionScopes
   }
 
-export interface Options {
-  fullFlex?: boolean | undefined
-}
-
-export function serializeSource(
-  s: source.Source,
-  opts: Readonly<Options>
-): string {
+export function serializeSource(s: source.Source): string {
   const source: Source = {
     ...serializeCommonDebug(s),
     ...serializePriority(s),
-    ...serializeFlexSource(s, opts.fullFlex ?? false),
 
     aggregation_keys: Object.fromEntries(
       Array.from(s.aggregationKeys.entries(), ([key, val]) => [
@@ -235,9 +154,14 @@ export function serializeSource(
     destination: Array.from(s.destination),
     destination_limit_priority: s.destinationLimitPriority.toString(),
     event_level_epsilon: s.eventLevelEpsilon,
+    event_report_windows: {
+      start_time: s.eventReportWindows.startTime,
+      end_times: [...s.eventReportWindows.endTimes],
+    },
     expiry: s.expiry,
     max_event_level_reports: s.maxEventLevelReports,
     source_event_id: s.sourceEventId.toString(),
+    trigger_data: Array.from(s.triggerData),
     trigger_data_matching: s.triggerDataMatching,
     ...ifNotNull(
       'aggregatable_debug_reporting',
@@ -293,26 +217,18 @@ type EventTriggerDatum = FilterPair &
   Priority &
   DedupKey & {
     trigger_data: string
-    value?: number
   }
 
 function serializeEventTriggerDatum(
-  d: trigger.EventTriggerDatum,
-  fullFlex: boolean
+  d: trigger.EventTriggerDatum
 ): EventTriggerDatum {
-  const obj: EventTriggerDatum = {
+  return {
     ...serializeFilterPair(d),
     ...serializePriority(d),
     ...serializeDedupKey(d),
 
     trigger_data: d.triggerData.toString(),
   }
-
-  if (fullFlex) {
-    obj.value = d.value
-  }
-
-  return obj
 }
 
 type AggregatableDedupKey = FilterPair & DedupKey
@@ -394,10 +310,7 @@ type Trigger = CommonDebug &
     attribution_scopes?: string[]
   }
 
-export function serializeTrigger(
-  t: trigger.Trigger,
-  opts: Readonly<Options>
-): string {
+export function serializeTrigger(t: trigger.Trigger): string {
   const trigger: Trigger = {
     ...serializeCommonDebug(t),
     ...serializeFilterPair(t),
@@ -426,7 +339,7 @@ export function serializeTrigger(
     aggregation_coordinator_origin: t.aggregationCoordinatorOrigin,
 
     event_trigger_data: Array.from(t.eventTriggerData, (d) =>
-      serializeEventTriggerDatum(d, opts.fullFlex ?? false)
+      serializeEventTriggerDatum(d)
     ),
 
     ...ifNotNull('trigger_context_id', t.triggerContextID, (v) => v),
diff --git a/ts/src/header-validator/trigger.test.ts b/ts/src/header-validator/trigger.test.ts
index 5ceb809575..ed0a2b71d4 100644
--- a/ts/src/header-validator/trigger.test.ts
+++ b/ts/src/header-validator/trigger.test.ts
@@ -155,7 +155,6 @@ const testCases: jsontest.TestCase<Trigger>[] = [
               map: new Map([['y', new Set()]]),
             },
           ],
-          value: 1,
         },
       ],
       positive: [
@@ -1656,69 +1655,6 @@ const testCases: jsontest.TestCase<Trigger>[] = [
     ],
   },
 
-  // Full Flex
-
-  {
-    name: 'value-wrong-type',
-    input: `{"event_trigger_data": [{"value":"1"}]}`,
-    parseFullFlex: true,
-    expectedErrors: [
-      {
-        path: ['event_trigger_data', 0, 'value'],
-        msg: 'must be a number',
-      },
-    ],
-  },
-  {
-    name: 'value-zero',
-    input: `{"event_trigger_data": [{"value":0}]}`,
-    parseFullFlex: true,
-    expectedErrors: [
-      {
-        path: ['event_trigger_data', 0, 'value'],
-        msg: 'must be >= 1 and <= uint32 max (4294967295)',
-      },
-    ],
-  },
-  {
-    name: 'value-negative',
-    input: `{"event_trigger_data": [{"value":-1}]}`,
-    parseFullFlex: true,
-    expectedErrors: [
-      {
-        path: ['event_trigger_data', 0, 'value'],
-        msg: 'must be >= 1 and <= uint32 max (4294967295)',
-      },
-    ],
-  },
-  {
-    name: 'value-not-integer',
-    input: `{"event_trigger_data": [{"value":1.5}]}`,
-    parseFullFlex: true,
-    expectedErrors: [
-      {
-        path: ['event_trigger_data', 0, 'value'],
-        msg: 'must be an integer',
-      },
-    ],
-  },
-  {
-    name: 'value-max',
-    input: `{"event_trigger_data": [{"value":4294967295}]}`,
-    parseFullFlex: true,
-  },
-  {
-    name: 'value-gt-max',
-    input: `{"event_trigger_data": [{"value":4294967296}]}`,
-    parseFullFlex: true,
-    expectedErrors: [
-      {
-        path: ['event_trigger_data', 0, 'value'],
-        msg: 'must be >= 1 and <= uint32 max (4294967295)',
-      },
-    ],
-  },
-
   // Named budgets.
   {
     name: 'named-budgets-wrong-type',
@@ -1770,7 +1706,6 @@ testCases.forEach((tc) =>
     tc,
     trigger.validator({
       vsv: { ...vsv.Chromium, ...tc.vsv },
-      fullFlex: tc.parseFullFlex,
     })
   )
 )
diff --git a/ts/src/header-validator/trigger.ts b/ts/src/header-validator/trigger.ts
index 7ccdbe4e63..43ab19216e 100644
--- a/ts/src/header-validator/trigger.ts
+++ b/ts/src/header-validator/trigger.ts
@@ -34,7 +34,6 @@ export type EventTriggerDatum = FilterPair &
   reg.Priority &
   DedupKey & {
     triggerData: bigint
-    value: number
   }
 
 export type AggregatableDedupKey = FilterPair & DedupKey
diff --git a/ts/src/header-validator/validate-json.test.ts b/ts/src/header-validator/validate-json.test.ts
index a17d961083..0facc5f085 100644
--- a/ts/src/header-validator/validate-json.test.ts
+++ b/ts/src/header-validator/validate-json.test.ts
@@ -3,6 +3,5 @@ import * as vsv from '../vendor-specific-values'
 
 export type TestCase<T> = testutil.TestCase<T> & {
   vsv?: Readonly<Partial<vsv.VendorSpecificValues>>
-  parseFullFlex?: boolean
   parseNamedBudgets?: boolean
 }
diff --git a/ts/src/header-validator/validate-json.ts b/ts/src/header-validator/validate-json.ts
index d9aae56ac1..cc057c6cf3 100644
--- a/ts/src/header-validator/validate-json.ts
+++ b/ts/src/header-validator/validate-json.ts
@@ -38,7 +38,6 @@ export const UINT32_MAX: number = 2 ** 32 - 1
 
 export interface RegistrationOptions {
   vsv: VendorSpecificValues
-  fullFlex?: boolean | undefined
 }
 
 export class RegistrationContext<
diff --git a/ts/src/header-validator/validate-source.ts b/ts/src/header-validator/validate-source.ts
index 6ec95350e6..f536826e56 100644
--- a/ts/src/header-validator/validate-source.ts
+++ b/ts/src/header-validator/validate-source.ts
@@ -10,9 +10,7 @@ import {
   FilterData,
   Source,
   SourceAggregatableDebugReportingConfig,
-  SummaryOperator,
   TriggerDataMatching,
-  TriggerSpec,
 } from './source'
 import {
   ItemErrorAction,
@@ -336,12 +334,12 @@ function eventLevelEpsilon(j: Json, ctx: Context): Maybe<number> {
 function channelCapacity(s: Source, ctx: Context): void {
   const numStatesWords = 'number of possible output states'
 
-  const perTriggerDataConfigs = s.triggerSpecs.flatMap((spec) =>
-    Array<privacy.PerTriggerDataConfig>(spec.triggerData.size).fill(
-      new privacy.PerTriggerDataConfig(
-        spec.eventReportWindows.endTimes.length,
-        spec.summaryBuckets.length
-      )
+  const perTriggerDataConfigs = Array<privacy.PerTriggerDataConfig>(
+    s.triggerData.size
+  ).fill(
+    new privacy.PerTriggerDataConfig(
+      s.eventReportWindows.endTimes.length,
+      s.maxEventLevelReports
     )
   )
 
@@ -432,200 +430,20 @@ function sourceAggregatableDebugReportingConfig(
   })
 }
 
-function summaryBuckets(
-  j: Json | undefined,
-  ctx: Context,
-  maxEventLevelReports: Maybe<number>
-): Maybe<number[]> {
-  let maxLength
-  if (maxEventLevelReports.value === undefined) {
-    ctx.error(
-      'cannot be fully validated without a valid max_event_level_reports'
-    )
-    maxLength = constants.maxSettableEventLevelAttributionsPerSource
-  } else {
-    maxLength = maxEventLevelReports.value
-  }
-
-  if (j === undefined) {
-    return maxEventLevelReports.map(makeDefaultSummaryBuckets)
-  }
-
-  let prev = 0
-  let prevDesc = 'implicit minimum'
-
-  const bucket = (j: Json): Maybe<number> =>
-    number(j, ctx)
-      .filter(isInteger, ctx)
-      .filter(
-        isInRange,
-        ctx,
-        prev + 1,
-        UINT32_MAX,
-        `must be > ${prevDesc} (${prev}) and <= uint32 max (${UINT32_MAX})`
-      )
-      .peek((n) => {
-        prev = n
-        prevDesc = 'previous value'
-      })
-
-  return array(j, ctx, bucket, {
-    minLength: 1,
-    maxLength,
-    maxLengthErrSuffix: ' (max_event_level_reports)',
-    itemErrorAction: ItemErrorAction.earlyExit, // suppress unhelpful cascaded errors
-  })
-}
-
 function fullFlexTriggerDatum(j: Json, ctx: Context): Maybe<number> {
   return number(j, ctx)
     .filter(isInteger, ctx)
     .filter(isInRange, ctx, 0, UINT32_MAX)
 }
 
-function triggerDataSet(
-  j: Json,
-  ctx: Context,
-  allowEmpty: boolean = false
-): Maybe<Set<number>> {
+function triggerData(j: Json, ctx: Context): Maybe<Set<number>> {
   return set(j, ctx, fullFlexTriggerDatum, {
-    minLength: allowEmpty ? 0 : 1,
+    minLength: 0,
     maxLength: constants.maxTriggerDataPerSource,
     requireDistinct: true,
   })
 }
 
-type TriggerSpecDeps = {
-  expiry: Maybe<number>
-  eventReportWindows: Maybe<EventReportWindows>
-  maxEventLevelReports: Maybe<number>
-}
-
-function makeDefaultSummaryBuckets(maxEventLevelReports: number): number[] {
-  return Array.from({ length: maxEventLevelReports }, (_, i) => i + 1)
-}
-
-function triggerSpec(
-  j: Json,
-  ctx: Context,
-  deps: TriggerSpecDeps
-): Maybe<TriggerSpec> {
-  return struct(j, ctx, {
-    eventReportWindows: field('event_report_windows', (j) =>
-      j === undefined
-        ? deps.eventReportWindows
-        : eventReportWindows(j, ctx, deps.expiry)
-    ),
-
-    summaryBuckets: field(
-      'summary_buckets',
-      summaryBuckets,
-      deps.maxEventLevelReports
-    ),
-
-    summaryOperator: field(
-      'summary_operator',
-      withDefault(enumerated, SummaryOperator.count),
-      SummaryOperator
-    ),
-
-    triggerData: field('trigger_data', required(triggerDataSet)),
-  })
-}
-
-function triggerSpecs(
-  j: Json,
-  ctx: Context,
-  deps: TriggerSpecDeps
-): Maybe<TriggerSpec[]> {
-  return array(j, ctx, (j) => triggerSpec(j, ctx, deps), {
-    maxLength: constants.maxTriggerDataPerSource,
-  }).filter((specs) => {
-    const triggerData = new Set<number>()
-    const dups = new Set<number>()
-    for (const spec of specs) {
-      for (const triggerDatum of spec.triggerData) {
-        if (triggerData.has(triggerDatum)) {
-          dups.add(triggerDatum)
-        } else {
-          triggerData.add(triggerDatum)
-        }
-      }
-    }
-
-    let ok = true
-    if (triggerData.size > constants.maxTriggerDataPerSource) {
-      ctx.error(
-        `exceeds maximum number of distinct trigger_data (${triggerData.size} > ${constants.maxTriggerDataPerSource})`
-      )
-      ok = false
-    }
-
-    if (dups.size > 0) {
-      ctx.error(`duplicate trigger_data: ${Array.from(dups).join(', ')}`)
-      ok = false
-    }
-
-    return ok
-  })
-}
-
-function triggerSpecsFromTriggerData(
-  j: Json,
-  ctx: Context,
-  deps: TriggerSpecDeps
-): Maybe<TriggerSpec[]> {
-  return triggerDataSet(j, ctx, /*allowEmpty=*/ true).map((triggerData) => {
-    if (
-      triggerData.size === 0 ||
-      deps.eventReportWindows.value === undefined ||
-      deps.maxEventLevelReports.value === undefined
-    ) {
-      return []
-    }
-
-    return [
-      {
-        eventReportWindows: deps.eventReportWindows.value,
-        summaryBuckets: makeDefaultSummaryBuckets(
-          deps.maxEventLevelReports.value
-        ),
-        summaryOperator: SummaryOperator.count,
-        triggerData: triggerData,
-      },
-    ]
-  })
-}
-
-function defaultTriggerSpecs(
-  ctx: Context,
-  eventReportWindows: Maybe<EventReportWindows>,
-  maxEventLevelReports: Maybe<number>
-): Maybe<TriggerSpec[]> {
-  return eventReportWindows.flatMap((eventReportWindows) =>
-    maxEventLevelReports.map((maxEventLevelReports) => [
-      {
-        eventReportWindows,
-        summaryBuckets: Array.from(
-          { length: maxEventLevelReports },
-          (_, i) => i + 1
-        ),
-        summaryOperator: SummaryOperator.count,
-        triggerData: new Set(
-          Array.from(
-            {
-              length: Number(
-                constants.defaultTriggerDataCardinality[ctx.opts.sourceType]
-              ),
-            },
-            (_, i) => i
-          )
-        ),
-      },
-    ])
-  )
-}
-
 function compareNumbers(a: number, b: number): number {
   return a - b
 }
@@ -636,9 +454,7 @@ function isTriggerDataMatchingValidForSpecs(s: Source, ctx: Context): boolean {
       return true
     }
 
-    const triggerData: number[] = s.triggerSpecs
-      .flatMap((spec) => Array.from(spec.triggerData))
-      .sort(compareNumbers)
+    const triggerData: number[] = Array.from(s.triggerData).sort(compareNumbers)
 
     if (triggerData.some((triggerDatum, i) => triggerDatum !== i)) {
       ctx.error(
@@ -656,7 +472,7 @@ function warnInconsistentMaxEventLevelReportsAndTriggerSpecs(
   ctx: Context
 ): void {
   const allowsReports = s.maxEventLevelReports > 0
-  const hasSpecs = s.triggerSpecs.length > 0
+  const hasSpecs = s.triggerData.size > 0
 
   if (allowsReports && !hasSpecs) {
     ctx.warning(
@@ -677,44 +493,6 @@ function source(j: Json, ctx: Context): Maybe<Source> {
         withDefault(expiry, constants.validSourceExpiryRange[1])
       )(j, ctx)
 
-      const eventReportWindowsVal = exclusive(
-        {
-          event_report_window: (j) => eventReportWindow(j, ctx, expiryVal),
-          event_report_windows: (j) => eventReportWindows(j, ctx, expiryVal),
-        },
-        expiryVal.map(defaultEventReportWindows, ctx)
-      )(j, ctx)
-
-      const maxEventLevelReportsVal = field(
-        'max_event_level_reports',
-        maxEventLevelReports
-      )(j, ctx)
-
-      const defaultTriggerSpecsVal = defaultTriggerSpecs(
-        ctx,
-        eventReportWindowsVal,
-        maxEventLevelReportsVal
-      )
-
-      const triggerSpecsDeps = {
-        expiry: expiryVal,
-        eventReportWindows: eventReportWindowsVal,
-        maxEventLevelReports: maxEventLevelReportsVal,
-      }
-
-      const triggerSpecsVal = exclusive(
-        {
-          trigger_data: (j) =>
-            triggerSpecsFromTriggerData(j, ctx, triggerSpecsDeps),
-          ...(ctx.opts.fullFlex
-            ? {
-                trigger_specs: (j) => triggerSpecs(j, ctx, triggerSpecsDeps),
-              }
-            : {}),
-        },
-        defaultTriggerSpecsVal
-      )(j, ctx)
-
       return struct(j, ctx, {
         aggregatableReportWindow: field('aggregatable_report_window', (j) =>
           j === undefined ? expiryVal : singleReportWindow(j, ctx, expiryVal)
@@ -733,9 +511,35 @@ function source(j: Json, ctx: Context): Maybe<Source> {
         ),
         expiry: () => expiryVal,
         filterData: field('filter_data', withDefault(filterData, new Map())),
-        maxEventLevelReports: () => maxEventLevelReportsVal,
+        maxEventLevelReports: field(
+          'max_event_level_reports',
+          maxEventLevelReports
+        ),
         sourceEventId: field('source_event_id', withDefault(uint64, 0n)),
-        triggerSpecs: () => triggerSpecsVal,
+        eventReportWindows: exclusive(
+          {
+            event_report_window: (j) => eventReportWindow(j, ctx, expiryVal),
+            event_report_windows: (j) => eventReportWindows(j, ctx, expiryVal),
+          },
+          expiryVal.map(defaultEventReportWindows, ctx)
+        ),
+
+        triggerData: field(
+          'trigger_data',
+          withDefault(
+            triggerData,
+            new Set(
+              Array.from(
+                {
+                  length: Number(
+                    constants.defaultTriggerDataCardinality[ctx.opts.sourceType]
+                  ),
+                },
+                (_, i) => i
+              )
+            )
+          )
+        ),
         aggregatableDebugReporting: field(
           'aggregatable_debug_reporting',
           withDefault(
@@ -846,6 +650,6 @@ export function validateSource(
 export function validator(opts: Readonly<SourceOptions>): Validator<Source> {
   return {
     validate: (input) => validateSource(input, opts),
-    serialize: (value) => serializeSource(value, opts),
+    serialize: serializeSource,
   }
 }
diff --git a/ts/src/header-validator/validate-trigger.ts b/ts/src/header-validator/validate-trigger.ts
index 49a6e55901..9d81ae420c 100644
--- a/ts/src/header-validator/validate-trigger.ts
+++ b/ts/src/header-validator/validate-trigger.ts
@@ -31,7 +31,6 @@ import {
   RegistrationContext as Context,
   RegistrationOptions,
   StructFields,
-  UINT32_MAX,
   aggregatableDebugReportingConfig,
   aggregatableKeyValueValue,
   aggregationCoordinatorOriginField,
@@ -245,27 +244,11 @@ function aggregatableFilteringIdMaxBytes(
     })
 }
 
-function eventTriggerValue(j: Json, ctx: Context): Maybe<number> {
-  return number(j, ctx)
-    .filter(isInteger, ctx)
-    .filter(
-      isInRange,
-      ctx,
-      1,
-      UINT32_MAX,
-      `must be >= 1 and <= uint32 max (${UINT32_MAX})`
-    )
-}
-
 function eventTriggerData(j: Json, ctx: Context): Maybe<EventTriggerDatum[]> {
   return array(j, ctx, (j) =>
     struct(j, ctx, {
       triggerData: field('trigger_data', withDefault(uint64, 0n)),
 
-      value: ctx.opts.fullFlex
-        ? field('value', withDefault(eventTriggerValue, 1))
-        : () => Maybe.some(1),
-
       ...filterFields,
       ...dedupKeyField,
       ...priorityField,
@@ -443,6 +426,6 @@ export function validator(
 ): Validator<Trigger> {
   return {
     validate: (input) => validateTrigger(input, opts),
-    serialize: (value) => serializeTrigger(value, opts),
+    serialize: serializeTrigger,
   }
 }