TS strict (3/3): runtime model/form/service changes + enable strict mode (#3688)

* TS strict (2/4): strictNullChecks null-safety guards

Mechanical null-safety: nullish-coalescing defaults, optional chaining,
{#if} render guards, and generics-driven refactors. Behavior-preserving.
Rebased onto main after the base PR (#3686) merged.

* TS strict (3/4): runtime-affecting model, form, and service changes

WorkflowExecution optional fields (with their snapshot tests), schedule-form
zod default seeding, standalone-activity retry fields as strings coerced at the
boundary, duration-input defaults, and requestFromAPI's Promise<T | undefined>.

* TS strict: enable strict mode and enforce it in CI

Fold the strict: true flip + Danger warn->fail into this PR. The standalone-activity
form's superForm types only resolve correctly under strictNullChecks, so the behavior
changes can't type-check on a strict:false main — the flag must land with them.
Supersedes the separate flag PR (#3640).

Author: tegan-temporal

dangerfile.ts

@@ -104,10 +104,15 @@ async function checkStrictModeErrors() {
     const relevantErrors: Record<string, StrictError[]> = {};
     let relevantErrorCount = 0;
 
+    // svelte-check and Danger both report repo-relative POSIX paths; compare
+    // by normalized equality (substring matching both missed regressions and
+    // false-blocked unrelated files that share a path suffix).
+    const normalizePath = (p: string) => p.replace(/^\.?\//, '');
+
     for (const [filename, errors] of Object.entries(result.errorsByFile)) {
+      const normalizedFilename = normalizePath(filename);
       const isChanged = Array.from(changedFiles).some(
-        (changedFile) =>
-          changedFile.includes(filename) || filename.includes(changedFile),
+        (changedFile) => normalizePath(changedFile) === normalizedFilename,
       );
 
       if (isChanged) {
@@ -120,25 +125,23 @@ async function checkStrictModeErrors() {
       return;
     }
 
-    const percentageInPR = (
-      (relevantErrorCount / result.totalErrors) *
-      100
-    ).toFixed(1);
+    const fileCount = Object.keys(relevantErrors).length;
 
-    // Post summary warning with all errors
-    let warningMessage = `📊 **Strict Mode**: ${relevantErrorCount} error${relevantErrorCount > 1 ? 's' : ''} in ${Object.keys(relevantErrors).length} file${Object.keys(relevantErrors).length > 1 ? 's' : ''} (${percentageInPR}% of ${result.totalErrors} total)\n\n`;
+    // The codebase is strict-clean; any strict error in a changed file is a
+    // regression and must block the PR.
+    let failureMessage = `❌ **Strict Mode**: ${relevantErrorCount} TypeScript error${relevantErrorCount > 1 ? 's' : ''} in ${fileCount} changed file${fileCount > 1 ? 's' : ''}. Strict mode is enforced — please fix before merging.\n\n`;
 
     for (const [filename, errors] of Object.entries(relevantErrors)) {
-      warningMessage += `<details>\n<summary><strong>${filename}</strong> (${errors.length})</summary>\n\n`;
+      failureMessage += `<details>\n<summary><strong>${filename}</strong> (${errors.length})</summary>\n\n`;
 
       for (const error of errors) {
-        warningMessage += `- L${error.start.line}:${error.start.character}: ${error.message}\n`;
+        failureMessage += `- L${error.start.line}:${error.start.character}: ${error.message}\n`;
       }
 
-      warningMessage += '\n</details>\n\n';
+      failureMessage += '\n</details>\n\n';
     }
 
-    warn(warningMessage);
+    fail(failureMessage);
 
     // Post individual warnings for errors on lines in the diff
     for (const [filename, errors] of Object.entries(relevantErrors)) {
@@ -183,13 +186,13 @@ async function checkStrictModeErrors() {
         );
       }
 
-      // Post warnings for errors on lines that are in the diff
+      // Post inline failures for errors on lines that are in the diff
       for (const error of errors) {
         if (linesInDiff.has(error.start.line)) {
           if (DEBUG) {
-            console.log(`Posting warning for ${filename}:${error.start.line}`);
+            console.log(`Posting failure for ${filename}:${error.start.line}`);
           }
-          warn(error.message, filename, error.start.line);
+          fail(error.message, filename, error.start.line);
         }
       }
     }

scripts/count-strict-errors.ts

@@ -60,7 +60,13 @@ try {
       if (data.type === 'ERROR') {
         const error: StrictError = {
           filename: data.filename,
-          start: data.start,
+          // svelte-check's machine-verbose output uses 0-indexed LSP
+          // positions; convert to 1-indexed to match editors and GitHub
+          // inline-comment line numbers (Danger's `fail(msg, file, line)`).
+          start: {
+            line: data.start.line + 1,
+            character: data.start.character + 1,
+          },
           message: data.message.split('\n')[0], // Only first line
         };
 

src/lib/components/activity/activity-options-update-drawer.svelte

@@ -30,13 +30,13 @@
   };
 
   let { open = $bindable(), namespace, execution, activity }: Props = $props();
-  let { activityId: id, activityType: type } = $derived(activity);
+  let { activityId: id } = $derived(activity);
 
   // Form fields are seeded from activity.activityOptions once when the drawer
   // opens. They must NOT reset reactively if the activity prop changes while
   // the user is mid-edit — untrack() captures the initial value intentionally.
   let taskQueue = $state(
-    untrack(() => activity.activityOptions?.taskQueue?.name),
+    untrack(() => activity.activityOptions?.taskQueue?.name ?? ''),
   );
   let scheduleToCloseTimeout = $state(
     untrack(() =>
@@ -65,10 +65,14 @@
     ),
   );
   let maximumAttempts = $state(
-    untrack(() => activity?.activityOptions?.retryPolicy?.maximumAttempts),
+    untrack(() => activity?.activityOptions?.retryPolicy?.maximumAttempts ?? 0),
   );
+  // Temporal rejects backoffCoefficient < 1; default to the server default (2)
+  // when unset rather than submitting an invalid 0 via the full field mask.
   let backoffCoefficient = $state(
-    untrack(() => activity?.activityOptions?.retryPolicy?.backoffCoefficient),
+    untrack(
+      () => activity?.activityOptions?.retryPolicy?.backoffCoefficient ?? 2,
+    ),
   );
   let initialInterval = $state(
     untrack(() =>
@@ -125,7 +129,7 @@
       console.error('Error updating activity options:', error);
       toaster.push({
         variant: 'error',
-        message: `Options for Activity ${id} have been failed to update: ${error?.message}`,
+        message: `Options for Activity ${id} have been failed to update: ${(error as Error)?.message}`,
         duration: 5000,
       });
     } finally {

src/lib/components/schedule/schedule-form/schedule-policies-drawer.svelte

@@ -225,6 +225,7 @@
           initialUnit={getFirstWholeNumberUnit(
             $policies.catchupWindow,
             durationUnits,
+            'second(s)',
           )}
           units={durationUnits}
           error={!!$errors.catchupWindow?.[0]}
@@ -263,6 +264,7 @@
         initialUnit={getFirstWholeNumberUnit(
           $policies.taskTimeout,
           durationUnits,
+          'second(s)',
         )}
         units={durationUnits}
         error={!!$errors.taskTimeout?.[0]}
@@ -282,6 +284,7 @@
         initialUnit={getFirstWholeNumberUnit(
           $policies.runTimeout,
           durationUnits,
+          'second(s)',
         )}
         units={durationUnits}
         error={!!$errors.runTimeout?.[0]}
@@ -300,6 +303,7 @@
         initialUnit={getFirstWholeNumberUnit(
           $policies.executionTimeout,
           durationUnits,
+          'second(s)',
         )}
         units={durationUnits}
         error={!!$errors.executionTimeout?.[0]}

src/lib/components/schedule/schedule-form/schedule-spec-item.svelte

@@ -50,7 +50,7 @@
     }
 
     if (specKind === 'frozen') {
-      return spec.calendar ? 'Calendar' : 'Interval';
+      return spec.interval?.interval ? 'Interval' : 'Calendar';
     }
 
     return translate('schedules.spec-type-none');

src/lib/components/schedule/schema/form.ts

@@ -78,78 +78,81 @@ const formSpecKind = z.enum([
 ]);
 export type FormSpecKind = z.infer<typeof formSpecKind>;
 
-export const formSpecSchema = z
-  .object({
-    kind: formSpecKind,
-    cronString: z.string().trim().default(''),
-    interval: z
-      .object({
-        interval: durationString().optional(),
-        phase: durationString().optional(),
-      })
-      .default({}),
-    calendar: structuredCalendarSchema(),
-  })
-  .superRefine((spec, ctx) => {
-    switch (spec.kind) {
-      case 'none': {
+// The bare object schema, without the cross-field validation below. Parsing a
+// partial seed through this injects the field defaults without tripping the
+// refinements (e.g. "cron string is required"), yielding a complete spec.
+export const formSpecObject = z.object({
+  kind: formSpecKind,
+  cronString: z.string().trim().default(''),
+  interval: z
+    .object({
+      interval: durationString().optional(),
+      phase: durationString().optional(),
+    })
+    .default({}),
+  calendar: structuredCalendarSchema(),
+});
+
+export const formSpecSchema = formSpecObject.superRefine((spec, ctx) => {
+  switch (spec.kind) {
+    case 'none': {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: 'Type is required ',
+        path: ['kind'],
+      });
+      return;
+    }
+
+    case 'cron': {
+      if (!spec.cronString) {
         ctx.addIssue({
           code: z.ZodIssueCode.custom,
-          message: 'Type is required ',
-          path: ['kind'],
+          message: 'Cron expression is required',
+          path: ['cronString'],
         });
-        return;
       }
 
-      case 'cron': {
-        if (!spec.cronString) {
-          ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: 'Cron expression is required',
-            path: ['cronString'],
-          });
-        }
-
-        if (!isValidCronString(spec.cronString)) {
-          ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message:
-              'Cron string format invalid. Format: minute (0-59) hour (0-23) day-of-month (1-31) month (1-12) day-of-week (0-6) separated by a space',
-            path: ['cronString'],
-          });
-        }
-
-        return;
+      if (!isValidCronString(spec.cronString)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message:
+            'Cron string format invalid. Format: minute (0-59) hour (0-23) day-of-month (1-31) month (1-12) day-of-week (0-6) separated by a space',
+          path: ['cronString'],
+        });
       }
 
-      case 'frozen': {
-        return;
-      }
+      return;
+    }
 
-      case 'interval': {
-        if (
-          !spec.interval?.interval ||
-          !Number(parseDuration(spec.interval.interval))
-        ) {
-          ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: 'Interval is required',
-            path: ['interval.interval'],
-          });
-        }
-
-        return;
-      }
+    case 'frozen': {
+      return;
+    }
 
-      case 'month': {
-        return;
+    case 'interval': {
+      if (
+        !spec.interval?.interval ||
+        !Number(parseDuration(spec.interval.interval))
+      ) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: 'Interval is required',
+          path: ['interval.interval'],
+        });
       }
 
-      case 'week': {
-        return;
-      }
+      return;
     }
-  });
+
+    case 'month': {
+      return;
+    }
+
+    case 'week': {
+      return;
+    }
+  }
+});
 
 export type FormSpecSchema = z.infer<typeof formSpecSchema>;
 const formScheduleTimingSchema = z.object({
@@ -209,7 +212,10 @@ export const formScheduleSchema = z
         });
       }
 
-      if (schedule.endAfterOccurrences <= 0) {
+      if (
+        typeof schedule.endAfterOccurrences === 'number' &&
+        schedule.endAfterOccurrences <= 0
+      ) {
         ctx.addIssue({
           code: z.ZodIssueCode.custom,
           message: 'Number of occurrences must be greater than 0',

src/lib/components/schedule/utilities/get-form-schedule-defaults.test.ts

@@ -53,7 +53,9 @@ describe('getFormScheduleDefaults', () => {
     });
 
     it('seeds a single cron spec', () => {
-      expect(defaults.specs).toEqual([{ kind: 'cron', cronString: '' }]);
+      expect(defaults.specs).toHaveLength(1);
+      expect(defaults.specs[0].kind).toBe('cron');
+      expect(defaults.specs[0].cronString).toBe('');
     });
 
     it('uses the default policies and timeouts', () => {
@@ -127,9 +129,12 @@ describe('getFormScheduleDefaults', () => {
     });
 
     it('loads the interval spec', () => {
-      expect(defaults.specs).toEqual([
-        { kind: 'frozen', interval: { interval: '3600s', phase: '0s' } },
-      ]);
+      expect(defaults.specs).toHaveLength(1);
+      expect(defaults.specs[0].kind).toBe('frozen');
+      expect(defaults.specs[0].interval).toEqual({
+        interval: '3600s',
+        phase: '0s',
+      });
     });
 
     it('parses the overlap policy and timeouts', () => {

src/lib/components/schedule/utilities/get-form-spec-initial-data.test.ts

@@ -3,11 +3,13 @@ import { describe, expect, it } from 'vitest';
 import { getFormSpecInitialData } from './get-form-spec-initial-data';
 
 describe('getFormSpecInitialData', () => {
-  it('returns an empty cron spec', () => {
-    expect(getFormSpecInitialData('cron')).toEqual({
-      kind: 'cron',
-      cronString: '',
-    });
+  it('returns a cron spec with defaults injected', () => {
+    const spec = getFormSpecInitialData('cron');
+
+    expect(spec.kind).toBe('cron');
+    expect(spec.cronString).toBe('');
+    expect(spec.interval).toEqual({});
+    expect(spec.calendar).toBeDefined();
   });
 
   it('seeds a week spec with the current day of the week', () => {
@@ -29,13 +31,11 @@ describe('getFormSpecInitialData', () => {
     expect(spec.calendar?.month).toEqual([{ start: now.getMonth() + 1 }]);
   });
 
-  it('returns an empty interval spec', () => {
-    expect(getFormSpecInitialData('interval')).toEqual({
-      kind: 'interval',
-      interval: {
-        interval: undefined,
-        phase: undefined,
-      },
-    });
+  it('returns an interval spec with an empty interval', () => {
+    const spec = getFormSpecInitialData('interval');
+
+    expect(spec.kind).toBe('interval');
+    expect(spec.interval).toEqual({});
+    expect(spec.calendar).toBeDefined();
   });
 });