@tasker-systems/tasker 0.1.6 → 0.1.8

package/dist/events/index.d.ts

@@ -1,3 +1,3 @@
-export { y as ErrorCallback, n as EventName, o as EventNames, d as EventPoller, z as EventPollerConfig, f as EventSystem, F as EventSystemConfig, G as EventSystemStats, A as MetricsCallback, p as MetricsEventName, q as MetricsEventNames, M as MetricsPayload, P as PollerCyclePayload, r as PollerEventName, s as PollerEventNames, C as PollerState, g as StepCompletionSentPayload, D as StepEventCallback, t as StepEventName, u as StepEventNames, h as StepExecutionCompletedPayload, i as StepExecutionFailedPayload, j as StepExecutionReceivedPayload, k as StepExecutionStartedPayload, T as TaskerEventEmitter, l as TaskerEventMap, W as WorkerErrorPayload, v as WorkerEventName, w as WorkerEventNames, m as WorkerEventPayload, x as createEventPoller } from '../index-CRCYa9Xk.js';
+export { y as ErrorCallback, n as EventName, o as EventNames, d as EventPoller, z as EventPollerConfig, f as EventSystem, F as EventSystemConfig, G as EventSystemStats, A as MetricsCallback, p as MetricsEventName, q as MetricsEventNames, M as MetricsPayload, P as PollerCyclePayload, r as PollerEventName, s as PollerEventNames, C as PollerState, g as StepCompletionSentPayload, D as StepEventCallback, t as StepEventName, u as StepEventNames, h as StepExecutionCompletedPayload, i as StepExecutionFailedPayload, j as StepExecutionReceivedPayload, k as StepExecutionStartedPayload, T as TaskerEventEmitter, l as TaskerEventMap, W as WorkerErrorPayload, v as WorkerEventName, w as WorkerEventNames, m as WorkerEventPayload, x as createEventPoller } from '../index-CVhy3k3k.js';
 import 'eventemitter3';
 import '../ffi/index.js';

package/dist/events/index.js

@@ -1486,6 +1486,10 @@ var StepExecutionSubscriber = class {
   /**
    * Send a completion result to Rust via FFI and handle the response.
    *
+   * If the primary FFI call fails (e.g. serialization error, unexpected
+   * type mismatch), we construct a guaranteed-safe failure result so the
+   * step is marked as permanently failed rather than silently lost.
+   *
    * @returns true if the completion was accepted by Rust, false otherwise
    */
   async sendCompletionViaFfi(event, napiResult, isSuccess) {
@@ -1509,8 +1513,61 @@ var StepExecutionSubscriber = class {
       return false;
     } catch (error) {
       this.handleFfiError(event, error);
-      return false;
+      return this.submitFallbackFailure(event, error);
+    }
+  }
+  /**
+   * Submit a minimal safe-failure result after the primary FFI call fails.
+   *
+   * Builds a primitive-only result guaranteed to serialize, then attempts
+   * to submit it. Throws if the fallback is also rejected or fails,
+   * since the step would otherwise be silently lost.
+   */
+  submitFallbackFailure(event, originalError) {
+    const fallback = this.buildFfiSafeFailure(event, originalError);
+    try {
+      const accepted = this.module.completeStepEvent(event.eventId, fallback);
+      if (accepted) {
+        pinoLog.warn(
+          { component: "subscriber", eventId: event.eventId },
+          "FFI fallback failure submitted successfully"
+        );
+        return true;
+      }
+      this.throwOrphanedError(event, "rejected", originalError);
+    } catch (fallbackError) {
+      this.throwOrphanedError(event, "failed", originalError, fallbackError);
+    }
+    return false;
+  }
+  /**
+   * Throw an error indicating a step has been orphaned (both primary and fallback failed).
+   */
+  throwOrphanedError(event, reason, originalError, fallbackError) {
+    const originalMsg = originalError instanceof Error ? originalError.message : String(originalError);
+    if (reason === "rejected") {
+      pinoLog.error(
+        { component: "subscriber", eventId: event.eventId, stepUuid: event.stepUuid },
+        "FFI fallback submission also rejected - step is orphaned"
+      );
+      throw new Error(
+        `Both primary and fallback FFI submissions rejected for event ${event.eventId}. Step ${event.stepUuid} is orphaned.`
+      );
     }
+    const fallbackMsg = fallbackError instanceof Error ? fallbackError.message : String(fallbackError);
+    pinoLog.error(
+      {
+        component: "subscriber",
+        eventId: event.eventId,
+        stepUuid: event.stepUuid,
+        error: fallbackMsg,
+        originalError: originalMsg
+      },
+      "FFI fallback also failed - step is orphaned"
+    );
+    throw new Error(
+      `Both primary and fallback FFI submissions failed for event ${event.eventId}. Step ${event.stepUuid} is orphaned. Fallback: ${fallbackMsg}, Original: ${originalMsg}`
+    );
   }
   /**
    * Handle successful FFI completion submission.
@@ -1570,6 +1627,36 @@ var StepExecutionSubscriber = class {
       error_message: error instanceof Error ? error.message : String(error)
     });
   }
+  /**
+   * Build a minimal NapiStepExecutionResult guaranteed to serialize through napi-rs.
+   *
+   * Uses only primitive values so there is zero chance of a secondary
+   * serialization failure. The step will be marked as permanently failed
+   * rather than silently lost.
+   */
+  buildFfiSafeFailure(event, error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      stepUuid: event.stepUuid,
+      success: false,
+      result: {},
+      status: "error",
+      metadata: {
+        executionTimeMs: 0,
+        retryable: false,
+        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        ...this.workerId != null && { workerId: this.workerId },
+        custom: {
+          ffi_serialization_error: errorMessage.substring(0, 500)
+        }
+      },
+      error: {
+        message: `FFI serialization failed: ${errorMessage}`.substring(0, 500),
+        errorType: "FFI_SERIALIZATION_ERROR",
+        retryable: false
+      }
+    };
+  }
 };
 
 // src/events/event-system.ts