chore: merge main into preview with Result refactor

Brings in all remaining main commits including:
- refactor: unify result types with Result<T, E> (#1125)
- feat: instrument telemetry for deploy command (#1206)
- feat: record command attrs on failure (#1204)
- feat: instrument telemetry for create command (#1202)

Adapts preview's deploy flow to use OperationResult with string errors
for compatibility with the telemetry layer.

Author: notgitika

src/cli/commands/deploy/command.tsx

@@ -1,4 +1,4 @@
-import { ConfigIO, serializeResult } from '../../../lib';
+import { ConfigIO } from '../../../lib';
 import { getErrorMessage } from '../../errors';
 import { withCommandRunTelemetry } from '../../telemetry/cli-command-run.js';
 import { COMMAND_DESCRIPTIONS } from '../../tui/copy';
@@ -50,28 +50,28 @@ async function handleDeployCLI(options: DeployOptions): Promise<void> {
 
   const { deployResult } = await withCommandRunTelemetry('deploy', attrs, async () => {
     const result = await executeDeploy(options).catch(
-      (e): DeployResult => ({ success: false, error: e instanceof Error ? e : new Error(getErrorMessage(e)) })
+      (e): DeployResult => ({ success: false, error: getErrorMessage(e) })
     );
     if (!result.success) {
-      return { success: false as const, error: result.error, deployResult: result };
+      return { success: false as const, error: result.error ?? 'Deploy failed', deployResult: result };
     }
     return { success: true as const, deployResult: result };
   });
 
   // ALL output happens here, after telemetry
   if (!deployResult.success) {
     if (options.json) {
-      console.log(JSON.stringify(serializeResult(deployResult)));
+      console.log(JSON.stringify(deployResult));
     } else {
-      console.error(deployResult.error.message);
+      console.error(deployResult.error);
       if (deployResult.logPath) {
         console.error(`Log: ${deployResult.logPath}`);
       }
     }
     process.exit(1);
   }
 
-  printDeployResult(deployResult, options);
+  printDeployResult(deployResult as DeployResult & { success: true }, options);
 
   if (deployResult.postDeployWarnings && deployResult.postDeployWarnings.length > 0) {
     process.exit(2);

src/cli/tui/screens/deploy/useDeployFlow.ts

@@ -25,7 +25,7 @@ import {
 } from '../../../operations/deploy/post-deploy-config-bundles';
 import { setupHttpGateways } from '../../../operations/deploy/post-deploy-http-gateways';
 import { enableOnlineEvalConfigs } from '../../../operations/deploy/post-deploy-online-evals';
-import { withCommandRunTelemetry } from '../../../telemetry/cli-command-run.js';
+import { type OperationResult, withCommandRunTelemetry } from '../../../telemetry/cli-command-run.js';
 import {
   type StackDiffSummary,
   type Step,
@@ -607,7 +607,7 @@ export function useDeployFlow(options: DeployFlowOptions = {}): DeployFlowState
 
     const attrs = context ? computeDeployAttrs(context.projectSpec, 'deploy') : { ...DEFAULT_DEPLOY_ATTRS };
 
-    const run = async (): Promise<{ success: true } | { success: false; error: Error }> => {
+    const run = async (): Promise<OperationResult> => {
       // Run diff before deploy to capture pre-deploy differences
       if (!isDiffRunningRef.current) {
         isDiffRunningRef.current = true;
@@ -787,7 +787,7 @@ export function useDeployFlow(options: DeployFlowOptions = {}): DeployFlowState
             error: logger.getFailureMessage('Publish assets'),
           }));
         }
-        return { success: false, error: err instanceof Error ? err : new Error(errorMsg) } as const;
+        return { success: false, error: errorMsg };
       } finally {
         // Disable verbose output and clear callback after deploy
         switchableIoHost?.setVerbose(false);
@@ -826,7 +826,7 @@ export function useDeployFlow(options: DeployFlowOptions = {}): DeployFlowState
       ? computeDeployAttrs(context.projectSpec, 'diff')
       : { ...DEFAULT_DEPLOY_ATTRS, mode: 'diff' as const };
 
-    const run = async (): Promise<{ success: true } | { success: false; error: Error }> => {
+    const run = async (): Promise<OperationResult> => {
       setDiffStep(prev => ({ ...prev, status: 'running' }));
       setShouldStartDeploy(false);
       setDiffSummaries([]);
@@ -862,7 +862,7 @@ export function useDeployFlow(options: DeployFlowOptions = {}): DeployFlowState
           status: 'error',
           error: logger.getFailureMessage('Run CDK diff'),
         }));
-        return { success: false, error: err instanceof Error ? err : new Error(errorMsg) };
+        return { success: false, error: errorMsg };
       } finally {
         switchableIoHost?.setVerbose(false);
         switchableIoHost?.setOnRawMessage(null);

src/lib/index.ts

@@ -28,3 +28,5 @@ export * from './utils';
 // Schema I/O utilities
 export * from './schemas/io';
 export * from './time-constants';
+export { serializeResult } from './result';
+export type { Result } from './result';

src/lib/result.ts

@@ -0,0 +1,30 @@
+/**
+ * Discriminated union for fallible operations, inspired by Rust's Result<T, E>.
+ *
+ * Success branch spreads T onto the result; failure branch carries an Error.
+ * E extends Error so callers always get stack traces, cause chains, and instanceof narrowing.
+ *
+ * @example
+ *   Result                                    // { success: true } | { success: false; error: Error }
+ *   Result<{ name: string }>                  // { success: true; name: string } | { success: false; error: Error }
+ *   Result<{ name: string }, ValidationError> // { success: true; name: string } | { success: false; error: ValidationError }
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export type Result<T extends Record<string, unknown> = {}, E extends Error = Error> =
+  | ({ success: true } & T)
+  | { success: false; error: E };
+
+/**
+ * Converts a Result object to a JSON-serializable form.
+ * Error objects have non-enumerable properties, so JSON.stringify produces `{}`.
+ * This replaces the `error` field with the error message string.
+ */
+export function serializeResult<T extends Record<string, unknown>>(
+  result: ({ success: true } & T) | ({ success: false; error: Error } & Record<string, unknown>)
+): Record<string, unknown> {
+  if (!result.success) {
+    const { error, ...rest } = result;
+    return { ...rest, error: error.message };
+  }
+  return result;
+}