From 713eb3eae8db2f5e7906d0c12090004e5c81a0c7 Mon Sep 17 00:00:00 2001
From: Jack McDade <jack@jackmcdade.com>
Date: Tue, 31 Mar 2026 21:01:22 -0400
Subject: [PATCH 1/3] Fake Submission Generator
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Includes submission-only and full-workflow modes, plus a bulk cleanup action to remove fake submissions. Adds Faker-backed fake data generation, tags generated entries with `fake: true`, includes a configurable “Enable Fake Submission Generator” toggle in form settings, and updates backend safeguards/tests/localization to support the new behavior.
---
 lang/en/messages.php                          |   9 +
 .../js/components/forms/SubmissionListing.vue |   7 +
 resources/js/pages/forms/Show.vue             | 108 +++++
 routes/cp.php                                 |   1 +
 src/Actions/DeleteFakeSubmissions.php         |  76 ++++
 src/Forms/FakeSubmissionGenerator.php         | 397 ++++++++++++++++++
 src/Forms/Form.php                            |   4 +
 .../CP/Forms/FormSubmissionsController.php    |  48 +++
 .../Controllers/CP/Forms/FormsController.php  |   9 +
 .../CP/Forms/SubmissionActionController.php   |   2 +-
 src/Providers/ExtensionServiceProvider.php    |   1 +
 .../Forms/DeleteFakeSubmissionsActionTest.php | 122 ++++++
 .../Forms/GenerateFakeSubmissionTest.php      | 175 ++++++++
 13 files changed, 958 insertions(+), 1 deletion(-)
 create mode 100644 src/Actions/DeleteFakeSubmissions.php
 create mode 100644 src/Forms/FakeSubmissionGenerator.php
 create mode 100644 tests/Feature/Forms/DeleteFakeSubmissionsActionTest.php
 create mode 100644 tests/Feature/Forms/GenerateFakeSubmissionTest.php

diff --git a/lang/en/messages.php b/lang/en/messages.php
index ae79894ece6..af4a0b2b945 100644
--- a/lang/en/messages.php
+++ b/lang/en/messages.php
@@ -133,9 +133,18 @@
     'form_configure_honeypot_instructions' => 'Field name to use as a honeypot. Honeypots are special fields used to reduce bot spam.',
     'form_configure_intro' => 'Forms collect information from visitors and can trigger events and send notifications when submissions are received.',
     'form_configure_mailer_instructions' => 'Choose the mailer for sending this email. Leave blank to fall back to the default mailer.',
+    'form_configure_generate_fake_submissions_instructions' => 'Allow generating fake submissions and workflow testing from the submissions screen.',
     'form_configure_store_instructions' => 'Disable to stop storing submissions. Events and email notifications will still be sent.',
     'form_configure_title_instructions' => 'Use a call to action, such as \'Contact Us\'.',
     'form_create_description' => 'Get started by creating your first form.',
+    'form_fake_submissions_deleted' => 'Deleted :count fake submission.|Deleted :count fake submissions.',
+    'form_fake_submissions_delete_failed' => 'Fake submissions could not be deleted.',
+    'form_fake_submissions_form_not_found' => 'Form could not be found for deleting fake submissions.',
+    'form_fake_submissions_none_to_delete' => 'No fake submissions to delete.',
+    'form_fake_submissions_partial_delete' => ':success/:total fake submissions were deleted.',
+    'form_fake_submission_generation_disabled' => 'Generating fake submissions is disabled for this form.',
+    'form_fake_submission_cancelled' => 'Fake submission was cancelled by a form event listener.',
+    'form_fake_submission_generated' => 'Fake submission generated.',
     'getting_started_widget_collections' => 'Collections hold the different content types that make up your site, helping you stay organized.',
     'getting_started_widget_docs' => 'Discover everything Statamic can do, and learn how to use its powerful features the right way.',
     'getting_started_widget_header' => 'Getting Started with Statamic',
diff --git a/resources/js/components/forms/SubmissionListing.vue b/resources/js/components/forms/SubmissionListing.vue
index 27c9b1bd3b3..f3c15a5297c 100644
--- a/resources/js/components/forms/SubmissionListing.vue
+++ b/resources/js/components/forms/SubmissionListing.vue
@@ -1,5 +1,6 @@
 <template>
     <Listing
+        ref="listing"
         :url="requestUrl"
         :columns="columns"
         :action-url="actionUrl"
@@ -42,5 +43,11 @@ export default {
             requestUrl: cp_url(`forms/${this.form}/submissions`),
         };
     },
+
+    methods: {
+        refresh() {
+            this.$refs.listing?.refresh();
+        },
+    },
 };
 </script>
diff --git a/resources/js/pages/forms/Show.vue b/resources/js/pages/forms/Show.vue
index 66893dd3ce9..8e9eab56aa8 100644
--- a/resources/js/pages/forms/Show.vue
+++ b/resources/js/pages/forms/Show.vue
@@ -1,5 +1,6 @@
 <script setup>
 import { ref } from 'vue';
+import axios from 'axios';
 import Head from '@/pages/layout/Head.vue';
 import { Header, Dropdown, DropdownMenu, DropdownItem, Button, CommandPaletteItem } from '@ui';
 import ResourceDeleter from '@/components/ResourceDeleter.vue';
@@ -14,11 +15,65 @@ const props = defineProps([
     'columns',
     'filters',
     'actionUrl',
+    'generateFakeSubmissionUrl',
     'exporters',
     'redirectUrl',
 ]);
 
 const deleter = ref(null);
+const generatingFakeSubmission = ref(false);
+const deletingFakeSubmissions = ref(false);
+const submissionListing = ref(null);
+
+async function generateFakeSubmission(mode) {
+    if (generatingFakeSubmission.value) {
+        return;
+    }
+
+    generatingFakeSubmission.value = true;
+
+    try {
+        const { data } = await axios.post(props.generateFakeSubmissionUrl, { mode });
+        Statamic.$toast.success(data.message);
+        submissionListing.value?.refresh();
+    } catch (error) {
+        const message = error?.response?.data?.message ?? __('Something went wrong');
+        Statamic.$toast.error(message, { duration: null });
+    } finally {
+        generatingFakeSubmission.value = false;
+    }
+}
+
+async function deleteFakeSubmissions() {
+    if (deletingFakeSubmissions.value) {
+        return;
+    }
+
+    deletingFakeSubmissions.value = true;
+
+    try {
+        const { data } = await axios.post(props.actionUrl, {
+            action: 'delete_fake_submissions',
+            selections: ['_all_fake_submissions_'],
+            context: { form: props.form.handle },
+            values: {},
+        });
+
+        const message = data?.message ?? __('Saved');
+
+        if (data?.success === false) {
+            Statamic.$toast.error(message, { duration: null });
+        } else {
+            Statamic.$toast.success(message);
+            submissionListing.value?.refresh();
+        }
+    } catch (error) {
+        const message = error?.response?.data?.message ?? __('Something went wrong');
+        Statamic.$toast.error(message, { duration: null });
+    } finally {
+        deletingFakeSubmissions.value = false;
+    }
+}
 </script>
 
 <template>
@@ -89,6 +144,58 @@ const deleter = ref(null);
                 </DropdownMenu>
             </Dropdown>
 
+            <Dropdown v-if="form.canGenerateFakeSubmissions">
+                <template #trigger>
+                    <Button
+                        :text="__('Generate Fake Submission')"
+                        :loading="generatingFakeSubmission || deletingFakeSubmissions"
+                        :disabled="generatingFakeSubmission || deletingFakeSubmissions"
+                    />
+                </template>
+                <DropdownMenu>
+                    <DropdownItem
+                        :text="__('Submission Only')"
+                        icon="flask"
+                        @click="generateFakeSubmission('cp_only')"
+                    />
+                    <DropdownItem
+                        :text="__('Submission + All Workflows')"
+                        icon="rocket"
+                        @click="generateFakeSubmission('full_pipeline')"
+                    />
+                    <DropdownItem
+                        :text="__('Delete All Fake Submissions')"
+                        icon="trash"
+                        variant="destructive"
+                        @click="deleteFakeSubmissions"
+                    />
+                </DropdownMenu>
+            </Dropdown>
+
+            <CommandPaletteItem
+                v-if="form.canGenerateFakeSubmissions"
+                category="Actions"
+                :text="__('Generate Fake Submission')"
+                icon="flask"
+                :action="() => generateFakeSubmission('cp_only')"
+            />
+
+            <CommandPaletteItem
+                v-if="form.canGenerateFakeSubmissions"
+                category="Actions"
+                :text="__('Generate Fake Submission + Run All Workflows')"
+                icon="rocket"
+                :action="() => generateFakeSubmission('full_pipeline')"
+            />
+
+            <CommandPaletteItem
+                v-if="form.canGenerateFakeSubmissions"
+                category="Actions"
+                :text="__('Delete All Fake Submissions')"
+                icon="trash"
+                :action="deleteFakeSubmissions"
+            />
+
             <CommandPaletteItem
                 v-for="exporter in exporters"
                 :key="exporter.downloadUrl"
@@ -101,6 +208,7 @@ const deleter = ref(null);
         </Header>
 
         <FormSubmissionListing
+            ref="submissionListing"
             :form="form.handle"
             :action-url="actionUrl"
             sort-column="datestamp"
diff --git a/routes/cp.php b/routes/cp.php
index 7e6ee982656..faf327d6de4 100644
--- a/routes/cp.php
+++ b/routes/cp.php
@@ -343,6 +343,7 @@
     Route::post('forms/actions/list', [FormActionController::class, 'bulkActions'])->name('forms.actions.bulk');
     Route::post('forms/{form}/submissions/actions', [SubmissionActionController::class, 'run'])->name('forms.submissions.actions.run');
     Route::post('forms/{form}/submissions/actions/list', [SubmissionActionController::class, 'bulkActions'])->name('forms.submissions.actions.bulk');
+    Route::post('forms/{form}/submissions/generate-fake', [FormSubmissionsController::class, 'generateFake'])->name('forms.submissions.generate-fake');
     Route::resource('forms', FormsController::class);
     Route::resource('forms.submissions', FormSubmissionsController::class);
     Route::get('forms/{form}/fields', FormFieldsController::class)->name('forms.fields.index');
diff --git a/src/Actions/DeleteFakeSubmissions.php b/src/Actions/DeleteFakeSubmissions.php
new file mode 100644
index 00000000000..876a6bd45d4
--- /dev/null
+++ b/src/Actions/DeleteFakeSubmissions.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Statamic\Actions;
+
+use Exception;
+use Statamic\Facades\Form;
+use Statamic\Facades\User;
+
+class DeleteFakeSubmissions extends Action
+{
+    protected $dangerous = true;
+
+    protected $icon = 'trash';
+
+    public static function title()
+    {
+        return __('Delete Fake Submissions');
+    }
+
+    public function visibleTo($item)
+    {
+        return false;
+    }
+
+    public function authorize($user, $item)
+    {
+        return $user->can('delete', $item);
+    }
+
+    public function run($items, $values)
+    {
+        $formHandle = $this->context['form'] ?? null;
+        $form = $formHandle ? Form::find($formHandle) : null;
+
+        if (! $form) {
+            throw new Exception(__('statamic::messages.form_fake_submissions_form_not_found'));
+        }
+
+        $fakeSubmissions = $form->submissions()->filter(fn ($submission) => (bool) $submission->get('fake'));
+        $currentUser = request()->user() ? User::fromUser(request()->user()) : null;
+        $requiredPermission = "delete {$form->handle()} form submissions";
+        $isSuper = $currentUser && method_exists($currentUser, 'isSuper') && $currentUser->isSuper();
+        $canConfigureForms = $currentUser && method_exists($currentUser, 'hasPermission') && $currentUser->hasPermission('configure forms');
+        $canDeleteSubmissions = $currentUser && method_exists($currentUser, 'hasPermission') && $currentUser->hasPermission($requiredPermission);
+
+        if (! $isSuper && ! $canConfigureForms && ! $canDeleteSubmissions) {
+            throw new Exception(__('You are not authorized to run this action.'));
+        }
+
+        if ($fakeSubmissions->isEmpty()) {
+            return [
+                'message' => __('statamic::messages.form_fake_submissions_none_to_delete'),
+            ];
+        }
+
+        $failures = $fakeSubmissions->reject(fn ($submission) => $submission->delete());
+        $deletedCount = $fakeSubmissions->count() - $failures->count();
+
+        if ($deletedCount === 0) {
+            throw new Exception(__('statamic::messages.form_fake_submissions_delete_failed'));
+        }
+
+        if ($failures->isNotEmpty()) {
+            throw new Exception(__('statamic::messages.form_fake_submissions_partial_delete', [
+                'success' => $deletedCount,
+                'total' => $fakeSubmissions->count(),
+            ]));
+        }
+
+        return [
+            'message' => trans_choice('statamic::messages.form_fake_submissions_deleted', $deletedCount, [
+                'count' => $deletedCount,
+            ]),
+        ];
+    }
+}
diff --git a/src/Forms/FakeSubmissionGenerator.php b/src/Forms/FakeSubmissionGenerator.php
new file mode 100644
index 00000000000..b6abd6a7c9d
--- /dev/null
+++ b/src/Forms/FakeSubmissionGenerator.php
@@ -0,0 +1,397 @@
+<?php
+
+namespace Statamic\Forms;
+
+use Illuminate\Support\Arr;
+use Illuminate\Support\Str as IlluminateStr;
+use Statamic\Contracts\Forms\Form as FormContract;
+use Statamic\Fields\Field;
+use Statamic\Support\Str;
+
+class FakeSubmissionGenerator
+{
+    protected $faker;
+
+    public function __construct()
+    {
+        $this->faker = class_exists(\Faker\Factory::class) ? \Faker\Factory::create() : null;
+    }
+
+    public function generate(FormContract $form): array
+    {
+        return $form->blueprint()->fields()->all()
+            ->mapWithKeys(fn (Field $field) => [$field->handle() => $this->valueForField($field)])
+            ->all();
+    }
+
+    private function valueForField(Field $field): mixed
+    {
+        $type = $field->type();
+        $default = $field->defaultValue();
+
+        if ($default !== null && ! in_array($type, ['toggle', 'checkboxes', 'select', 'radio', 'button_group'])) {
+            return $default;
+        }
+
+        return match ($type) {
+            'text', 'revealer', 'hidden' => $this->textValueFor($field),
+            'slug' => IlluminateStr::slug($this->textValueFor($field)),
+            'textarea', 'markdown' => $this->paragraph(),
+            'integer', 'range' => $this->number(1, 5000),
+            'float' => $this->decimalNumber(),
+            'toggle' => $this->boolean(),
+            'date' => $this->date(),
+            'time' => $this->time(),
+            'date_and_time' => $this->dateTime(),
+            'email' => $this->email(),
+            'link', 'url' => $this->url(),
+            'select', 'radio', 'button_group' => $this->randomOptionKey($field),
+            'checkboxes' => $this->randomOptionKeys($field),
+            'list' => [$this->word(), $this->word(), $this->word()],
+            default => $default,
+        };
+    }
+
+    private function randomOptionKey(Field $field): mixed
+    {
+        $options = $this->normalizedOptions($field);
+
+        if (empty($options)) {
+            return null;
+        }
+
+        if ($yesNo = $this->yesNoOptionValues($options)) {
+            return $yesNo[random_int(0, 1)];
+        }
+
+        if ($weighted = $this->semanticOptionWeights($field, $options)) {
+            return $this->pickWeightedOption($weighted);
+        }
+
+        return $options[array_rand($options)];
+    }
+
+    private function randomOptionKeys(Field $field): array
+    {
+        $options = $this->normalizedOptions($field);
+
+        if (empty($options)) {
+            return [];
+        }
+
+        if ($yesNo = $this->yesNoOptionValues($options)) {
+            return random_int(0, 1) === 1 ? [$yesNo[0]] : [$yesNo[1]];
+        }
+
+        if ($weighted = $this->semanticOptionWeights($field, $options)) {
+            $max = min(3, count($weighted));
+            $count = random_int(1, $max);
+            $picked = [];
+
+            while (count($picked) < $count) {
+                $candidate = $this->pickWeightedOption($weighted);
+
+                if (! in_array($candidate, $picked, true)) {
+                    $picked[] = $candidate;
+                }
+            }
+
+            return $picked;
+        }
+
+        shuffle($options);
+
+        return array_slice($options, 0, random_int(1, min(2, count($options))));
+    }
+
+    private function normalizedOptions(Field $field): array
+    {
+        $options = Arr::wrap($field->get('options', []));
+
+        if ($options === []) {
+            return [];
+        }
+
+        if (Arr::isAssoc($options)) {
+            return array_keys($options);
+        }
+
+        return array_values(array_map(function ($option) {
+            return is_array($option) ? Arr::get($option, 'value') : $option;
+        }, $options));
+    }
+
+    private function yesNoOptionValues(array $options): ?array
+    {
+        if (count($options) !== 2) {
+            return null;
+        }
+
+        $normalized = array_map(fn ($option) => Str::lower(trim((string) $option)), $options);
+        $truthy = ['yes', 'true', '1', 'y', 'on'];
+        $falsey = ['no', 'false', '0', 'n', 'off'];
+
+        if (
+            (in_array($normalized[0], $truthy, true) && in_array($normalized[1], $falsey, true))
+            || (in_array($normalized[1], $truthy, true) && in_array($normalized[0], $falsey, true))
+        ) {
+            return $options;
+        }
+
+        return null;
+    }
+
+    private function semanticOptionWeights(Field $field, array $options): ?array
+    {
+        $weights = [];
+        $fieldContext = $this->normalizedFieldContext($field);
+
+        foreach ($options as $option) {
+            $normalized = Str::lower((string) $option);
+            $weight = 1;
+
+            if (str_contains($fieldContext, 'country') && $this->containsAny($normalized, ['united states', 'usa', 'canada', 'uk'])) {
+                $weight += 3;
+            }
+
+            if (str_contains($fieldContext, 'state') && $this->containsAny($normalized, ['california', 'new york', 'texas', 'florida'])) {
+                $weight += 3;
+            }
+
+            if (str_contains($fieldContext, 'priority') && $this->containsAny($normalized, ['medium', 'normal'])) {
+                $weight += 4;
+            }
+
+            if (str_contains($fieldContext, 'status') && $this->containsAny($normalized, ['active', 'open', 'pending'])) {
+                $weight += 3;
+            }
+
+            if (str_contains($fieldContext, 'size') && $this->containsAny($normalized, ['medium', 'm'])) {
+                $weight += 4;
+            }
+
+            if (str_contains($fieldContext, 'rating') && $this->containsAny($normalized, ['4', '5', 'good', 'great', 'excellent'])) {
+                $weight += 3;
+            }
+
+            if (str_contains($fieldContext, 'plan') && $this->containsAny($normalized, ['pro', 'standard', 'plus'])) {
+                $weight += 3;
+            }
+
+            $weights[] = ['value' => $option, 'weight' => $weight];
+        }
+
+        $allDefault = collect($weights)->every(fn ($item) => $item['weight'] === 1);
+
+        return $allDefault ? null : $weights;
+    }
+
+    private function pickWeightedOption(array $weightedOptions): mixed
+    {
+        $total = array_sum(array_column($weightedOptions, 'weight'));
+        $roll = random_int(1, max($total, 1));
+
+        foreach ($weightedOptions as $option) {
+            $roll -= $option['weight'];
+
+            if ($roll <= 0) {
+                return $option['value'];
+            }
+        }
+
+        return $weightedOptions[array_key_last($weightedOptions)]['value'];
+    }
+
+    private function containsAny(string $haystack, array $needles): bool
+    {
+        foreach ($needles as $needle) {
+            if (str_contains($haystack, Str::lower($needle))) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private function word(): string
+    {
+        if ($this->faker) {
+            return (string) $this->faker->word();
+        }
+
+        return 'sample_'.Str::lower(Str::random(6));
+    }
+
+    private function textValueFor(Field $field): string
+    {
+        if ($this->faker) {
+            if ($this->looksLike($field, ['email', 'e-mail'])) {
+                return (string) $this->faker->safeEmail();
+            }
+
+            if ($this->looksLike($field, ['phone', 'tel', 'mobile', 'fax'])) {
+                return (string) $this->faker->phoneNumber();
+            }
+
+            if ($this->looksLike($field, ['first_name', 'firstname', 'given_name'])) {
+                return (string) $this->faker->firstName();
+            }
+
+            if ($this->looksLike($field, ['last_name', 'lastname', 'surname', 'family_name'])) {
+                return (string) $this->faker->lastName();
+            }
+
+            if ($this->looksLike($field, ['full_name', 'name'])) {
+                return (string) $this->faker->name();
+            }
+
+            if ($this->looksLike($field, ['company', 'organization', 'organisation', 'business'])) {
+                return (string) $this->faker->company();
+            }
+
+            if ($this->looksLike($field, ['address', 'street'])) {
+                return (string) $this->faker->streetAddress();
+            }
+
+            if ($this->looksLike($field, ['city', 'town'])) {
+                return (string) $this->faker->city();
+            }
+
+            if ($this->looksLike($field, ['state', 'province', 'region'])) {
+                return (string) $this->faker->state();
+            }
+
+            if ($this->looksLike($field, ['country'])) {
+                return (string) $this->faker->country();
+            }
+
+            if ($this->looksLike($field, ['zip', 'postal', 'postcode'])) {
+                return (string) $this->faker->postcode();
+            }
+
+            if ($this->looksLike($field, ['url', 'website', 'site'])) {
+                return (string) $this->faker->url();
+            }
+
+            if ($this->looksLike($field, ['job', 'title', 'position', 'role'])) {
+                return (string) $this->faker->jobTitle();
+            }
+
+            if ($this->looksLike($field, ['subject'])) {
+                return (string) $this->faker->sentence(6);
+            }
+
+            if ($this->looksLike($field, ['message', 'comment', 'notes', 'description', 'bio'])) {
+                return (string) $this->faker->paragraph(2);
+            }
+
+            return (string) $this->faker->sentence(4);
+        }
+
+        return 'sample_'.Str::lower(Str::random(8));
+    }
+
+    private function looksLike(Field $field, array $tokens): bool
+    {
+        $haystack = $this->normalizedFieldContext($field);
+
+        foreach ($tokens as $token) {
+            if (str_contains($haystack, Str::lower($token))) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private function normalizedFieldContext(Field $field): string
+    {
+        $parts = [
+            $field->handle(),
+            $field->display(),
+        ];
+
+        return Str::lower(implode(' ', array_filter($parts, fn ($part) => is_string($part) && $part !== '')));
+    }
+
+    private function paragraph(): string
+    {
+        if ($this->faker) {
+            return (string) $this->faker->paragraph(2);
+        }
+
+        return 'Sample content '.Str::lower(Str::random(16));
+    }
+
+    private function number(int $min, int $max): int
+    {
+        if ($this->faker) {
+            return (int) $this->faker->numberBetween($min, $max);
+        }
+
+        return random_int($min, $max);
+    }
+
+    private function decimalNumber(): float
+    {
+        if ($this->faker) {
+            return (float) $this->faker->randomFloat(2, 1, 1000);
+        }
+
+        return random_int(100, 100000) / 100;
+    }
+
+    private function boolean(): bool
+    {
+        if ($this->faker) {
+            return (bool) $this->faker->boolean();
+        }
+
+        return (bool) random_int(0, 1);
+    }
+
+    private function date(): string
+    {
+        if ($this->faker) {
+            return (string) $this->faker->date('Y-m-d');
+        }
+
+        return now()->subDays(random_int(0, 365))->toDateString();
+    }
+
+    private function time(): string
+    {
+        if ($this->faker) {
+            return (string) $this->faker->time('H:i');
+        }
+
+        return now()->setTime(random_int(0, 23), random_int(0, 59))->format('H:i');
+    }
+
+    private function dateTime(): string
+    {
+        if ($this->faker) {
+            return $this->faker->dateTime()->format(DATE_ATOM);
+        }
+
+        return now()->subMinutes(random_int(0, 60 * 24 * 30))->toIso8601String();
+    }
+
+    private function email(): string
+    {
+        if ($this->faker) {
+            return (string) $this->faker->safeEmail();
+        }
+
+        return 'sample+'.Str::lower(Str::random(8)).'@example.com';
+    }
+
+    private function url(): string
+    {
+        if ($this->faker) {
+            return (string) $this->faker->url();
+        }
+
+        return 'https://example.com/'.Str::lower(Str::random(10));
+    }
+}
diff --git a/src/Forms/Form.php b/src/Forms/Form.php
index 4639858fb6d..5aec7f53c3b 100644
--- a/src/Forms/Form.php
+++ b/src/Forms/Form.php
@@ -223,6 +223,10 @@ public function save()
             $data['store'] = false;
         }
 
+        if ($this->get('generate_fake_submissions') === false) {
+            $data['generate_fake_submissions'] = false;
+        }
+
         File::put($this->path(), YAML::dump($data));
 
         foreach ($afterSaveCallbacks as $callback) {
diff --git a/src/Http/Controllers/CP/Forms/FormSubmissionsController.php b/src/Http/Controllers/CP/Forms/FormSubmissionsController.php
index 9d0610a686e..bffe4648d60 100644
--- a/src/Http/Controllers/CP/Forms/FormSubmissionsController.php
+++ b/src/Http/Controllers/CP/Forms/FormSubmissionsController.php
@@ -2,8 +2,13 @@
 
 namespace Statamic\Http\Controllers\CP\Forms;
 
+use Illuminate\Http\Request;
 use Inertia\Inertia;
+use Statamic\Events\FormSubmitted;
+use Statamic\Facades\Site;
 use Statamic\Fields\Field;
+use Statamic\Forms\FakeSubmissionGenerator;
+use Statamic\Forms\SendEmails;
 use Statamic\Http\Controllers\CP\CpController;
 use Statamic\Http\Requests\FilteredRequest;
 use Statamic\Http\Resources\CP\Submissions\Submissions;
@@ -96,4 +101,47 @@ public function show($form, $submission)
             'meta' => $fields->meta(),
         ]);
     }
+
+    public function generateFake(Request $request, $form, FakeSubmissionGenerator $generator)
+    {
+        $this->authorize('view', $form);
+
+        if (! $form->get('generate_fake_submissions', true)) {
+            return response([
+                'message' => __('statamic::messages.form_fake_submission_generation_disabled'),
+            ], 403);
+        }
+
+        $validated = $request->validate([
+            'mode' => ['required', 'in:cp_only,full_pipeline'],
+        ]);
+
+        $values = $generator->generate($form);
+        $fields = $form->blueprint()->fields()->addValues($values);
+        $submission = $form->makeSubmission();
+        $submission->data(
+            $fields->process()->values()->merge([
+                'fake' => true,
+            ])
+        );
+
+        if ($validated['mode'] === 'full_pipeline') {
+            if (FormSubmitted::dispatch($submission) === false) {
+                return response([
+                    'message' => __('statamic::messages.form_fake_submission_cancelled'),
+                ], 422);
+            }
+        }
+
+        $submission->save();
+
+        if ($validated['mode'] === 'full_pipeline') {
+            SendEmails::dispatch($submission, Site::default());
+        }
+
+        return response([
+            'id' => $submission->id(),
+            'message' => __('statamic::messages.form_fake_submission_generated'),
+        ]);
+    }
 }
diff --git a/src/Http/Controllers/CP/Forms/FormsController.php b/src/Http/Controllers/CP/Forms/FormsController.php
index 297b1a193f6..020d0dc6971 100644
--- a/src/Http/Controllers/CP/Forms/FormsController.php
+++ b/src/Http/Controllers/CP/Forms/FormsController.php
@@ -77,12 +77,14 @@ public function show($form)
                 'canEdit' => User::current()->can('edit', $form),
                 'canDelete' => User::current()->can('delete', $form),
                 'canConfigureFields' => User::current()->can('configure form fields'),
+                'canGenerateFakeSubmissions' => (bool) $form->get('generate_fake_submissions', true),
             ],
             'columns' => $columns,
             'filters' => Scope::filters('form-submissions', [
                 'form' => $form->handle(),
             ]),
             'actionUrl' => cp_route('forms.submissions.actions.run', $form->handle()),
+            'generateFakeSubmissionUrl' => cp_route('forms.submissions.generate-fake', $form->handle()),
             'exporters' => $form->exporters()->map(fn ($exporter) => [
                 'title' => $exporter->title(),
                 'downloadUrl' => $exporter->downloadUrl(),
@@ -168,6 +170,7 @@ public function edit($form)
             'honeypot' => $form->honeypot(),
             'store' => $form->store(),
             'email' => $form->email(),
+            'generate_fake_submissions' => (bool) $form->get('generate_fake_submissions', true),
         ]);
 
         $fields = $blueprint
@@ -257,6 +260,12 @@ protected function editFormBlueprint($form)
                         'type' => 'toggle',
                         'instructions' => __('statamic::messages.form_configure_store_instructions'),
                     ],
+                    'generate_fake_submissions' => [
+                        'display' => __('Enable Fake Submission Generator'),
+                        'type' => 'toggle',
+                        'default' => true,
+                        'instructions' => __('statamic::messages.form_configure_generate_fake_submissions_instructions'),
+                    ],
                 ],
             ],
             'email' => [
diff --git a/src/Http/Controllers/CP/Forms/SubmissionActionController.php b/src/Http/Controllers/CP/Forms/SubmissionActionController.php
index 1b10ac01c68..d17bbd1a16e 100644
--- a/src/Http/Controllers/CP/Forms/SubmissionActionController.php
+++ b/src/Http/Controllers/CP/Forms/SubmissionActionController.php
@@ -12,6 +12,6 @@ protected function getSelectedItems($items, $context)
 
         return $items->map(function ($item) use ($form) {
             return $form->submission($item);
-        });
+        })->filter();
     }
 }
diff --git a/src/Providers/ExtensionServiceProvider.php b/src/Providers/ExtensionServiceProvider.php
index b5f71dcc8a1..551d23d7d92 100644
--- a/src/Providers/ExtensionServiceProvider.php
+++ b/src/Providers/ExtensionServiceProvider.php
@@ -30,6 +30,7 @@ class ExtensionServiceProvider extends ServiceProvider
         Actions\CopyAssetUrl::class,
         Actions\CopyPasswordResetLink::class,
         Actions\Delete::class,
+        Actions\DeleteFakeSubmissions::class,
         Actions\DeleteMultisiteEntry::class,
         Actions\DisableTwoFactorAuthentication::class,
         Actions\DownloadAsset::class,
diff --git a/tests/Feature/Forms/DeleteFakeSubmissionsActionTest.php b/tests/Feature/Forms/DeleteFakeSubmissionsActionTest.php
new file mode 100644
index 00000000000..b44b44858d2
--- /dev/null
+++ b/tests/Feature/Forms/DeleteFakeSubmissionsActionTest.php
@@ -0,0 +1,122 @@
+<?php
+
+namespace Tests\Feature\Forms;
+
+use PHPUnit\Framework\Attributes\Test;
+use Statamic\Facades\Blueprint;
+use Statamic\Facades\Form;
+use Statamic\Facades\User;
+use Tests\FakesRoles;
+use Tests\PreventSavingStacheItemsToDisk;
+use Tests\TestCase;
+
+class DeleteFakeSubmissionsActionTest extends TestCase
+{
+    use FakesRoles;
+    use PreventSavingStacheItemsToDisk;
+
+    protected function resolveApplicationConfiguration($app)
+    {
+        parent::resolveApplicationConfiguration($app);
+
+        $app['config']['statamic.forms.forms'] = $this->fakeStacheDirectory.'/forms';
+    }
+
+    #[Test]
+    public function it_deletes_all_fake_submissions_for_a_form()
+    {
+        $form = $this->makeForm('contact');
+        $user = $this->userWithSubmissionPermissions($form->handle());
+
+        $this->makeSubmission($form, ['name' => 'Real', 'fake' => false]);
+        $this->makeSubmission($form, ['name' => 'Fake 1', 'fake' => true]);
+        $this->makeSubmission($form, ['name' => 'Fake 2', 'fake' => true]);
+
+        $this->assertCount(3, $form->querySubmissions()->get());
+        $this->assertCount(2, $form->querySubmissions()->where('fake', true)->get());
+
+        $this
+            ->actingAs($user)
+            ->post(cp_route('forms.submissions.actions.run', $form->handle()), [
+                'action' => 'delete_fake_submissions',
+                'selections' => ['_all_fake_submissions_'],
+                'context' => ['form' => $form->handle()],
+                'values' => [],
+            ])
+            ->assertOk()
+            ->assertJson([
+                'success' => true,
+            ]);
+
+        $this->assertCount(1, $form->querySubmissions()->get());
+        $this->assertCount(0, $form->querySubmissions()->where('fake', true)->get());
+    }
+
+    #[Test]
+    public function it_does_not_delete_fake_submissions_without_delete_permission()
+    {
+        $form = $this->makeForm('contact');
+        $user = $this->userWithViewOnlyPermission($form->handle());
+
+        $this->makeSubmission($form, ['name' => 'Fake 1', 'fake' => true]);
+        $this->makeSubmission($form, ['name' => 'Fake 2', 'fake' => true]);
+
+        $this
+            ->actingAs($user)
+            ->post(cp_route('forms.submissions.actions.run', $form->handle()), [
+                'action' => 'delete_fake_submissions',
+                'selections' => ['_all_fake_submissions_'],
+                'context' => ['form' => $form->handle()],
+                'values' => [],
+            ])
+            ->assertOk()
+            ->assertJson([
+                'success' => false,
+            ]);
+
+        $this->assertCount(2, $form->querySubmissions()->where('fake', true)->get());
+    }
+
+    private function makeForm(string $handle)
+    {
+        Blueprint::makeFromFields([
+            'name' => ['type' => 'text'],
+        ])->setHandle($handle)->setNamespace('forms')->save();
+
+        return tap(Form::make($handle)->title('Contact'))->save();
+    }
+
+    private function makeSubmission($form, array $values)
+    {
+        $submission = $form->makeSubmission();
+        $submission->data(collect($values));
+        $submission->save();
+
+        return $submission;
+    }
+
+    private function userWithSubmissionPermissions(string $formHandle)
+    {
+        $this->setTestRoles([
+            'test' => [
+                'access cp',
+                "view {$formHandle} form submissions",
+                "delete {$formHandle} form submissions",
+            ],
+        ]);
+
+        return User::make()->assignRole('test')->save();
+    }
+
+    private function userWithViewOnlyPermission(string $formHandle)
+    {
+        $this->setTestRoles([
+            'test' => [
+                'access cp',
+                "view {$formHandle} form submissions",
+            ],
+        ]);
+
+        return User::make()->assignRole('test')->save();
+    }
+}
diff --git a/tests/Feature/Forms/GenerateFakeSubmissionTest.php b/tests/Feature/Forms/GenerateFakeSubmissionTest.php
new file mode 100644
index 00000000000..a5e228cc7dd
--- /dev/null
+++ b/tests/Feature/Forms/GenerateFakeSubmissionTest.php
@@ -0,0 +1,175 @@
+<?php
+
+namespace Tests\Feature\Forms;
+
+use Illuminate\Support\Facades\Bus;
+use Illuminate\Support\Facades\Event;
+use PHPUnit\Framework\Attributes\Test;
+use Statamic\Events\FormSubmitted;
+use Statamic\Facades\Blueprint;
+use Statamic\Facades\Form;
+use Statamic\Facades\User;
+use Statamic\Forms\SendEmails;
+use Tests\FakesRoles;
+use Tests\PreventSavingStacheItemsToDisk;
+use Tests\TestCase;
+
+class GenerateFakeSubmissionTest extends TestCase
+{
+    use FakesRoles;
+    use PreventSavingStacheItemsToDisk;
+
+    protected function resolveApplicationConfiguration($app)
+    {
+        parent::resolveApplicationConfiguration($app);
+
+        $app['config']['statamic.forms.forms'] = $this->fakeStacheDirectory.'/forms';
+    }
+
+    #[Test]
+    public function authorized_users_can_generate_a_fake_submission()
+    {
+        $form = $this->makeForm('contact');
+        $user = $this->userWithViewPermission($form->handle());
+
+        $this->assertEquals(0, $form->querySubmissions()->count());
+
+        $this
+            ->actingAs($user)
+            ->post(cp_route('forms.submissions.generate-fake', $form->handle()), ['mode' => 'cp_only'])
+            ->assertOk();
+
+        $this->assertEquals(1, $form->querySubmissions()->count());
+        $this->assertTrue((bool) $form->querySubmissions()->first()->get('fake'));
+    }
+
+    #[Test]
+    public function unauthorized_users_cannot_generate_a_fake_submission()
+    {
+        $form = $this->makeForm('contact');
+        $user = $this->userWithoutViewPermission();
+
+        $this
+            ->from('/original')
+            ->actingAs($user)
+            ->post(cp_route('forms.submissions.generate-fake', $form->handle()), ['mode' => 'cp_only'])
+            ->assertRedirect('/original')
+            ->assertSessionHas('error');
+    }
+
+    #[Test]
+    public function cp_only_mode_does_not_dispatch_full_pipeline_side_effects()
+    {
+        Event::fake([FormSubmitted::class]);
+        Bus::fake();
+
+        $form = $this->makeForm('contact');
+        $user = $this->userWithViewPermission($form->handle());
+
+        $this
+            ->actingAs($user)
+            ->post(cp_route('forms.submissions.generate-fake', $form->handle()), ['mode' => 'cp_only'])
+            ->assertOk();
+
+        Event::assertNotDispatched(FormSubmitted::class);
+        Bus::assertNotDispatched(SendEmails::class);
+        $this->assertEquals(1, $form->querySubmissions()->count());
+    }
+
+    #[Test]
+    public function full_pipeline_mode_dispatches_frontend_side_effects()
+    {
+        Event::fake([FormSubmitted::class]);
+        Bus::fake();
+
+        $form = $this->makeForm('contact');
+        $user = $this->userWithViewPermission($form->handle());
+
+        $this
+            ->actingAs($user)
+            ->post(cp_route('forms.submissions.generate-fake', $form->handle()), ['mode' => 'full_pipeline'])
+            ->assertOk();
+
+        Event::assertDispatched(FormSubmitted::class);
+        Bus::assertDispatched(SendEmails::class);
+        $this->assertEquals(1, $form->querySubmissions()->count());
+    }
+
+    #[Test]
+    public function unsupported_fields_fallback_to_null()
+    {
+        $form = $this->makeForm('contact');
+        $user = $this->userWithViewPermission($form->handle());
+
+        $this
+            ->actingAs($user)
+            ->post(cp_route('forms.submissions.generate-fake', $form->handle()), ['mode' => 'cp_only'])
+            ->assertOk();
+
+        $submission = $form->querySubmissions()->first();
+
+        $this->assertNotNull($submission->get('name'));
+        $this->assertNull($submission->get('rich_content'));
+    }
+
+    #[Test]
+    public function it_cannot_generate_fake_submissions_when_disabled_in_form_configuration()
+    {
+        $form = $this->makeForm('contact', false);
+        $user = $this->userWithViewPermission($form->handle());
+
+        $this
+            ->actingAs($user)
+            ->post(cp_route('forms.submissions.generate-fake', $form->handle()), ['mode' => 'cp_only'])
+            ->assertStatus(403);
+
+        $this->assertEquals(0, $form->querySubmissions()->count());
+    }
+
+    private function makeForm(string $handle, bool $generateFakeSubmissions = true)
+    {
+        Blueprint::makeFromFields([
+            'name' => ['type' => 'text'],
+            'message' => ['type' => 'textarea'],
+            'category' => [
+                'type' => 'select',
+                'options' => [
+                    'support' => 'Support',
+                    'sales' => 'Sales',
+                ],
+            ],
+            'tags' => [
+                'type' => 'checkboxes',
+                'options' => [
+                    'a' => 'A',
+                    'b' => 'B',
+                    'c' => 'C',
+                ],
+            ],
+            'rich_content' => ['type' => 'bard'],
+        ])->setHandle($handle)->setNamespace('forms')->save();
+
+        /** @var \Statamic\Forms\Form $form */
+        $form = Form::make($handle)->title('Contact')->merge([
+            'generate_fake_submissions' => $generateFakeSubmissions,
+        ]);
+
+        $form->save();
+
+        return $form;
+    }
+
+    private function userWithViewPermission(string $formHandle)
+    {
+        $this->setTestRoles(['test' => ['access cp', "view {$formHandle} form submissions"]]);
+
+        return User::make()->assignRole('test')->save();
+    }
+
+    private function userWithoutViewPermission()
+    {
+        $this->setTestRoles(['test' => ['access cp']]);
+
+        return User::make()->assignRole('test')->save();
+    }
+}

From b84230a68d5076ccb58b7b6613dee43fc7936a4d Mon Sep 17 00:00:00 2001
From: Jack McDade <jack@jackmcdade.com>
Date: Tue, 31 Mar 2026 21:06:08 -0400
Subject: [PATCH 2/3] Let's go with _fake to avoid edge case var collision with
 user data

---
 src/Actions/DeleteFakeSubmissions.php            |  2 +-
 .../CP/Forms/FormSubmissionsController.php       |  2 +-
 .../Forms/DeleteFakeSubmissionsActionTest.php    | 16 ++++++++--------
 .../Feature/Forms/GenerateFakeSubmissionTest.php |  2 +-
 4 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/Actions/DeleteFakeSubmissions.php b/src/Actions/DeleteFakeSubmissions.php
index 876a6bd45d4..3e36851d418 100644
--- a/src/Actions/DeleteFakeSubmissions.php
+++ b/src/Actions/DeleteFakeSubmissions.php
@@ -36,7 +36,7 @@ public function run($items, $values)
             throw new Exception(__('statamic::messages.form_fake_submissions_form_not_found'));
         }
 
-        $fakeSubmissions = $form->submissions()->filter(fn ($submission) => (bool) $submission->get('fake'));
+        $fakeSubmissions = $form->submissions()->filter(fn ($submission) => (bool) $submission->get('_fake'));
         $currentUser = request()->user() ? User::fromUser(request()->user()) : null;
         $requiredPermission = "delete {$form->handle()} form submissions";
         $isSuper = $currentUser && method_exists($currentUser, 'isSuper') && $currentUser->isSuper();
diff --git a/src/Http/Controllers/CP/Forms/FormSubmissionsController.php b/src/Http/Controllers/CP/Forms/FormSubmissionsController.php
index bffe4648d60..37b72b186af 100644
--- a/src/Http/Controllers/CP/Forms/FormSubmissionsController.php
+++ b/src/Http/Controllers/CP/Forms/FormSubmissionsController.php
@@ -121,7 +121,7 @@ public function generateFake(Request $request, $form, FakeSubmissionGenerator $g
         $submission = $form->makeSubmission();
         $submission->data(
             $fields->process()->values()->merge([
-                'fake' => true,
+                '_fake' => true,
             ])
         );
 
diff --git a/tests/Feature/Forms/DeleteFakeSubmissionsActionTest.php b/tests/Feature/Forms/DeleteFakeSubmissionsActionTest.php
index b44b44858d2..d44112f25fa 100644
--- a/tests/Feature/Forms/DeleteFakeSubmissionsActionTest.php
+++ b/tests/Feature/Forms/DeleteFakeSubmissionsActionTest.php
@@ -28,12 +28,12 @@ public function it_deletes_all_fake_submissions_for_a_form()
         $form = $this->makeForm('contact');
         $user = $this->userWithSubmissionPermissions($form->handle());
 
-        $this->makeSubmission($form, ['name' => 'Real', 'fake' => false]);
-        $this->makeSubmission($form, ['name' => 'Fake 1', 'fake' => true]);
-        $this->makeSubmission($form, ['name' => 'Fake 2', 'fake' => true]);
+        $this->makeSubmission($form, ['name' => 'Real', '_fake' => false]);
+        $this->makeSubmission($form, ['name' => 'Fake 1', '_fake' => true]);
+        $this->makeSubmission($form, ['name' => 'Fake 2', '_fake' => true]);
 
         $this->assertCount(3, $form->querySubmissions()->get());
-        $this->assertCount(2, $form->querySubmissions()->where('fake', true)->get());
+        $this->assertCount(2, $form->querySubmissions()->where('_fake', true)->get());
 
         $this
             ->actingAs($user)
@@ -49,7 +49,7 @@ public function it_deletes_all_fake_submissions_for_a_form()
             ]);
 
         $this->assertCount(1, $form->querySubmissions()->get());
-        $this->assertCount(0, $form->querySubmissions()->where('fake', true)->get());
+        $this->assertCount(0, $form->querySubmissions()->where('_fake', true)->get());
     }
 
     #[Test]
@@ -58,8 +58,8 @@ public function it_does_not_delete_fake_submissions_without_delete_permission()
         $form = $this->makeForm('contact');
         $user = $this->userWithViewOnlyPermission($form->handle());
 
-        $this->makeSubmission($form, ['name' => 'Fake 1', 'fake' => true]);
-        $this->makeSubmission($form, ['name' => 'Fake 2', 'fake' => true]);
+        $this->makeSubmission($form, ['name' => 'Fake 1', '_fake' => true]);
+        $this->makeSubmission($form, ['name' => 'Fake 2', '_fake' => true]);
 
         $this
             ->actingAs($user)
@@ -74,7 +74,7 @@ public function it_does_not_delete_fake_submissions_without_delete_permission()
                 'success' => false,
             ]);
 
-        $this->assertCount(2, $form->querySubmissions()->where('fake', true)->get());
+        $this->assertCount(2, $form->querySubmissions()->where('_fake', true)->get());
     }
 
     private function makeForm(string $handle)
diff --git a/tests/Feature/Forms/GenerateFakeSubmissionTest.php b/tests/Feature/Forms/GenerateFakeSubmissionTest.php
index a5e228cc7dd..8b93e82ab57 100644
--- a/tests/Feature/Forms/GenerateFakeSubmissionTest.php
+++ b/tests/Feature/Forms/GenerateFakeSubmissionTest.php
@@ -40,7 +40,7 @@ public function authorized_users_can_generate_a_fake_submission()
             ->assertOk();
 
         $this->assertEquals(1, $form->querySubmissions()->count());
-        $this->assertTrue((bool) $form->querySubmissions()->first()->get('fake'));
+        $this->assertTrue((bool) $form->querySubmissions()->first()->get('_fake'));
     }
 
     #[Test]

From 8318338437a3afeb8094321d504df381aff88e95 Mon Sep 17 00:00:00 2001
From: Jack McDade <jack@jackmcdade.com>
Date: Tue, 31 Mar 2026 21:22:56 -0400
Subject: [PATCH 3/3] Simply by removing all the weighted option picking logic.
 Random is fine.

---
 src/Forms/FakeSubmissionGenerator.php | 120 --------------------------
 1 file changed, 120 deletions(-)

diff --git a/src/Forms/FakeSubmissionGenerator.php b/src/Forms/FakeSubmissionGenerator.php
index b6abd6a7c9d..fa838207032 100644
--- a/src/Forms/FakeSubmissionGenerator.php
+++ b/src/Forms/FakeSubmissionGenerator.php
@@ -60,14 +60,6 @@ private function randomOptionKey(Field $field): mixed
             return null;
         }
 
-        if ($yesNo = $this->yesNoOptionValues($options)) {
-            return $yesNo[random_int(0, 1)];
-        }
-
-        if ($weighted = $this->semanticOptionWeights($field, $options)) {
-            return $this->pickWeightedOption($weighted);
-        }
-
         return $options[array_rand($options)];
     }
 
@@ -79,26 +71,6 @@ private function randomOptionKeys(Field $field): array
             return [];
         }
 
-        if ($yesNo = $this->yesNoOptionValues($options)) {
-            return random_int(0, 1) === 1 ? [$yesNo[0]] : [$yesNo[1]];
-        }
-
-        if ($weighted = $this->semanticOptionWeights($field, $options)) {
-            $max = min(3, count($weighted));
-            $count = random_int(1, $max);
-            $picked = [];
-
-            while (count($picked) < $count) {
-                $candidate = $this->pickWeightedOption($weighted);
-
-                if (! in_array($candidate, $picked, true)) {
-                    $picked[] = $candidate;
-                }
-            }
-
-            return $picked;
-        }
-
         shuffle($options);
 
         return array_slice($options, 0, random_int(1, min(2, count($options))));
@@ -121,98 +93,6 @@ private function normalizedOptions(Field $field): array
         }, $options));
     }
 
-    private function yesNoOptionValues(array $options): ?array
-    {
-        if (count($options) !== 2) {
-            return null;
-        }
-
-        $normalized = array_map(fn ($option) => Str::lower(trim((string) $option)), $options);
-        $truthy = ['yes', 'true', '1', 'y', 'on'];
-        $falsey = ['no', 'false', '0', 'n', 'off'];
-
-        if (
-            (in_array($normalized[0], $truthy, true) && in_array($normalized[1], $falsey, true))
-            || (in_array($normalized[1], $truthy, true) && in_array($normalized[0], $falsey, true))
-        ) {
-            return $options;
-        }
-
-        return null;
-    }
-
-    private function semanticOptionWeights(Field $field, array $options): ?array
-    {
-        $weights = [];
-        $fieldContext = $this->normalizedFieldContext($field);
-
-        foreach ($options as $option) {
-            $normalized = Str::lower((string) $option);
-            $weight = 1;
-
-            if (str_contains($fieldContext, 'country') && $this->containsAny($normalized, ['united states', 'usa', 'canada', 'uk'])) {
-                $weight += 3;
-            }
-
-            if (str_contains($fieldContext, 'state') && $this->containsAny($normalized, ['california', 'new york', 'texas', 'florida'])) {
-                $weight += 3;
-            }
-
-            if (str_contains($fieldContext, 'priority') && $this->containsAny($normalized, ['medium', 'normal'])) {
-                $weight += 4;
-            }
-
-            if (str_contains($fieldContext, 'status') && $this->containsAny($normalized, ['active', 'open', 'pending'])) {
-                $weight += 3;
-            }
-
-            if (str_contains($fieldContext, 'size') && $this->containsAny($normalized, ['medium', 'm'])) {
-                $weight += 4;
-            }
-
-            if (str_contains($fieldContext, 'rating') && $this->containsAny($normalized, ['4', '5', 'good', 'great', 'excellent'])) {
-                $weight += 3;
-            }
-
-            if (str_contains($fieldContext, 'plan') && $this->containsAny($normalized, ['pro', 'standard', 'plus'])) {
-                $weight += 3;
-            }
-
-            $weights[] = ['value' => $option, 'weight' => $weight];
-        }
-
-        $allDefault = collect($weights)->every(fn ($item) => $item['weight'] === 1);
-
-        return $allDefault ? null : $weights;
-    }
-
-    private function pickWeightedOption(array $weightedOptions): mixed
-    {
-        $total = array_sum(array_column($weightedOptions, 'weight'));
-        $roll = random_int(1, max($total, 1));
-
-        foreach ($weightedOptions as $option) {
-            $roll -= $option['weight'];
-
-            if ($roll <= 0) {
-                return $option['value'];
-            }
-        }
-
-        return $weightedOptions[array_key_last($weightedOptions)]['value'];
-    }
-
-    private function containsAny(string $haystack, array $needles): bool
-    {
-        foreach ($needles as $needle) {
-            if (str_contains($haystack, Str::lower($needle))) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
     private function word(): string
     {
         if ($this->faker) {