@researchdatabox/redbox-core 5.0.4 → 5.1.0-beta.12568

package/dist/action-execution/executor.js

@@ -0,0 +1,435 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createActionExecutionOperation = createActionExecutionOperation;
+exports.createActionExecutionSupervisor = createActionExecutionSupervisor;
+exports.createPhaseContext = createPhaseContext;
+exports.runSequentialActionPlan = runSequentialActionPlan;
+exports.dispatchDetachedActionPlan = dispatchDetachedActionPlan;
+const effect_1 = require("effect");
+const Cause = __importStar(require("effect/Cause"));
+const Fiber = __importStar(require("effect/Fiber"));
+const node_crypto_1 = require("node:crypto");
+const failure_1 = require("./failure");
+const policy_1 = require("./policy");
+/**
+ * A failed action is reported as its own status when the executor itself ended
+ * the attempt; everything else is an ordinary failure.
+ */
+const STATUS_BY_FAILURE_KIND = {
+    timeout: 'timed_out',
+    interrupted: 'interrupted',
+};
+function statusForFailure(failure) {
+    return STATUS_BY_FAILURE_KIND[failure.kind] ?? 'failed';
+}
+function now(dependencies) {
+    return dependencies.now?.() ?? new Date();
+}
+function iso(value) {
+    return value.toISOString();
+}
+function newId(dependencies) {
+    return dependencies.uuid?.() ?? (0, node_crypto_1.randomUUID)();
+}
+function durationMs(startedAt, completedAt) {
+    return Math.max(0, Math.round(new Date(completedAt).getTime() - new Date(startedAt).getTime()));
+}
+function isCooperativelyCancellable(action) {
+    return action.cooperativeCancellation?.() ?? true;
+}
+function maxAttempts(action) {
+    return action.policy?.retry?.maxAttempts ?? 1;
+}
+function commonFields(context, action, attempt) {
+    const fields = {
+        execution_id: context.executionId,
+        phase_execution_id: context.phaseExecutionId,
+    };
+    if (context.requestId) {
+        fields.request_id = context.requestId;
+    }
+    if (context.recordOid) {
+        fields.record_oid = context.recordOid;
+    }
+    fields.hook_mode = context.mode;
+    fields.hook_phase = context.phase;
+    fields.action_id = action.actionId;
+    fields.action_index = action.index;
+    if (attempt !== undefined) {
+        fields.attempt = attempt;
+    }
+    fields.max_attempts = maxAttempts(action);
+    return fields;
+}
+function finalEventName(status, detached) {
+    if (status === 'succeeded' || status === 'dispatched') {
+        return detached ? 'record_hook_detached_action_completed' : 'record_hook_action_completed';
+    }
+    if (status === 'timed_out') {
+        return 'record_hook_action_timed_out';
+    }
+    return detached ? 'record_hook_detached_action_failed' : 'record_hook_action_failed';
+}
+function logActionResult(dependencies, context, action, result, detached) {
+    const fields = commonFields(context, action, result.attempts);
+    fields.status = result.status;
+    fields.duration_ms = result.durationMs;
+    if (result.failure) {
+        fields.failure_kind = result.failure.kind;
+        fields.failure_code = result.failure.code;
+        if (result.failure.cancellationCooperative !== undefined) {
+            fields.cancellation_cooperative = result.failure.cancellationCooperative;
+        }
+    }
+    const event = finalEventName(result.status, detached);
+    if (!result.failure) {
+        dependencies.logger?.info?.(event, fields);
+        return;
+    }
+    // Only a genuinely unexpected failure is an operator error; everything else
+    // is a hook reporting a problem it already knows about.
+    const level = result.failure.kind === 'unexpected' ? 'error' : 'warn';
+    dependencies.logger?.[level]?.(event, fields);
+}
+function logActionStart(dependencies, context, action, attempt, detached) {
+    const fields = commonFields(context, action, attempt);
+    fields.detached = detached;
+    dependencies.logger?.debug?.('record_hook_action_started', fields);
+}
+/**
+ * Extract the value the legacy adapter needs to rethrow. Defects and
+ * interruptions are converted to branded failures so normalization stays
+ * deterministic.
+ */
+function failureCause(cause) {
+    const failure = Cause.failureOrCause(cause);
+    if (failure._tag === 'Left') {
+        return failure.left;
+    }
+    if (Cause.isInterruptedOnly(cause)) {
+        return new failure_1.ActionInterruptedFailure(true);
+    }
+    return Cause.squash(failure.right);
+}
+function runAttempt(action) {
+    return effect_1.Effect.gen(function* () {
+        // suspend is deliberate: the legacy adapter invokes the resolved function
+        // only when the attempt starts, so retries receive the same live arguments.
+        let effect = effect_1.Effect.suspend(() => action.invoke());
+        if (action.policy?.timeoutMs !== undefined) {
+            effect = effect.pipe(effect_1.Effect.timeoutFail({
+                duration: `${action.policy.timeoutMs} millis`,
+                onTimeout: () => new failure_1.ActionTimeoutFailure(isCooperativelyCancellable(action)),
+            }));
+        }
+        const exit = yield* effect_1.Effect.exit(effect);
+        if (exit._tag === 'Success') {
+            return { ok: true, value: exit.value };
+        }
+        const cause = failureCause(exit.cause);
+        return {
+            ok: false,
+            cause,
+            failure: (0, failure_1.normalizeActionFailure)(cause, isCooperativelyCancellable(action)),
+        };
+    });
+}
+function shouldRetry(action, attemptNumber, failure) {
+    const retry = action.policy?.retry;
+    if (!retry || attemptNumber >= retry.maxAttempts) {
+        return false;
+    }
+    // An opaque Promise keeps running after Effect times out. Retrying it here
+    // would overlap the original side effect with a second invocation. The
+    // idempotent acknowledgement alone is not enough to make that safe.
+    if ((failure.kind === 'timeout' || failure.kind === 'interrupted') && failure.cancellationCooperative === false) {
+        return false;
+    }
+    return (retry.retryOn ?? ['transient']).includes(failure.kind);
+}
+/**
+ * Run one action to completion, including retries and backoff. The reported
+ * duration deliberately spans every attempt and every delay between them.
+ *
+ * `project` lets the caller consume a successful value while the action is
+ * still open: if projecting the value fails, the action itself is reported as
+ * failed rather than the phase silently continuing.
+ */
+function executeAction(action, dependencies, context, detached = false, project) {
+    return effect_1.Effect.gen(function* () {
+        const startedAt = iso(now(dependencies));
+        let attemptNumber = 0;
+        let attempt;
+        for (;;) {
+            attemptNumber += 1;
+            logActionStart(dependencies, context, action, attemptNumber, detached);
+            attempt = yield* runAttempt(action);
+            if (attempt.ok) {
+                const successFields = commonFields(context, action, attemptNumber);
+                successFields.status = 'succeeded';
+                dependencies.logger?.debug?.('record_hook_action_attempt_succeeded', successFields);
+            }
+            if (attempt.ok || !shouldRetry(action, attemptNumber, attempt.failure)) {
+                break;
+            }
+            const delay = (0, policy_1.retryDelayMs)(action.policy?.retry?.schedule, attemptNumber, dependencies.random);
+            const retryFields = commonFields(context, action, attemptNumber);
+            retryFields.failure_kind = attempt.failure.kind;
+            retryFields.failure_code = attempt.failure.code;
+            retryFields.delay_ms = delay;
+            dependencies.logger?.warn?.('record_hook_action_retry_scheduled', retryFields);
+            if (delay > 0) {
+                yield* (dependencies.sleep?.(delay) ?? effect_1.Effect.sleep(`${delay} millis`));
+            }
+        }
+        if (attempt.ok && project) {
+            try {
+                project(attempt.value);
+            }
+            catch (error) {
+                attempt = {
+                    ok: false,
+                    cause: error,
+                    failure: (0, failure_1.normalizeActionFailure)(error, isCooperativelyCancellable(action)),
+                };
+            }
+        }
+        const completedAt = iso(now(dependencies));
+        const result = {
+            actionId: action.actionId,
+            mode: action.mode,
+            phase: action.phase,
+            index: action.index,
+            status: attempt.ok ? 'succeeded' : statusForFailure(attempt.failure),
+            attempts: attemptNumber,
+            startedAt,
+            completedAt,
+            durationMs: durationMs(startedAt, completedAt),
+        };
+        if (!attempt.ok) {
+            result.failure = attempt.failure;
+        }
+        logActionResult(dependencies, context, action, result, detached);
+        return { attempt, result };
+    });
+}
+function skippedResult(action, reason, dependencies) {
+    const timestamp = iso(now(dependencies));
+    return {
+        actionId: action.actionId,
+        mode: action.mode,
+        phase: action.phase,
+        index: action.index,
+        status: 'skipped',
+        attempts: 0,
+        startedAt: timestamp,
+        completedAt: timestamp,
+        durationMs: 0,
+        skippedReason: reason,
+    };
+}
+/**
+ * Validate every configured policy before any side effect runs, so an invalid
+ * policy is a plain configuration error at the plan boundary rather than a
+ * failure discovered halfway through a phase.
+ */
+function validatedPlan(actions) {
+    return actions.map(action => ({ ...action, policy: (0, policy_1.validateActionExecutionPolicy)(action.policy) }));
+}
+function createActionExecutionOperation(mode, requestId, recordOid, dependencies = {}) {
+    const operation = {
+        executionId: newId(dependencies),
+        mode,
+        reports: [],
+        startedAt: iso(now(dependencies)),
+    };
+    if (requestId) {
+        operation.requestId = requestId;
+    }
+    if (recordOid) {
+        operation.recordOid = recordOid;
+    }
+    return operation;
+}
+/**
+ * Owns detached fibers for the lifetime of a service. A Sails `lower` hook can
+ * interrupt the set so shutdown does not leave post-save work running against
+ * a closed datastore.
+ */
+function createActionExecutionSupervisor() {
+    const fibers = new Set();
+    return {
+        register(fiber) {
+            fibers.add(fiber);
+            fiber.addObserver(() => fibers.delete(fiber));
+        },
+        interruptAll() {
+            const active = Array.from(fibers);
+            fibers.clear();
+            for (const fiber of active) {
+                effect_1.Effect.runFork(Fiber.interruptFork(fiber));
+            }
+        },
+    };
+}
+function createPhaseContext(operation, phase, dependencies = {}, mode = operation.mode) {
+    const context = {
+        executionId: operation.executionId,
+        phaseExecutionId: newId(dependencies),
+        mode,
+        phase,
+    };
+    if (operation.requestId) {
+        context.requestId = operation.requestId;
+    }
+    if (operation.recordOid) {
+        context.recordOid = operation.recordOid;
+    }
+    return context;
+}
+function makeReport(context, results, startedAt, dependencies, status) {
+    const completedAt = iso(now(dependencies));
+    const report = {
+        context,
+        status,
+        startedAt,
+        completedAt,
+        durationMs: durationMs(startedAt, completedAt),
+        actions: results,
+    };
+    const fields = commonFields(context, { actionId: 'phase', mode: context.mode, phase: context.phase, index: -1 });
+    fields.status = status;
+    fields.duration_ms = report.durationMs;
+    fields.total_actions = results.length;
+    dependencies.logger?.info?.('record_hook_phase_completed', fields);
+    return report;
+}
+/**
+ * Sequential fail-fast strategy, used for the awaited `pre` and `postSync`
+ * phases. `onSuccess` lets the caller thread record/response state between
+ * actions without teaching the executor anything about records.
+ */
+function runSequentialActionPlan(actions, context, dependencies = {}, onSuccess) {
+    const plan = validatedPlan(actions);
+    return effect_1.Effect.gen(function* () {
+        const startedAt = iso(now(dependencies));
+        const results = [];
+        let terminalCause;
+        let failed = false;
+        for (const [index, action] of plan.entries()) {
+            const executed = yield* executeAction(action, dependencies, context, false, value => onSuccess?.(value, index));
+            results.push(executed.result);
+            if (executed.attempt.ok) {
+                continue;
+            }
+            failed = true;
+            terminalCause = executed.attempt.cause;
+            for (const remaining of plan.slice(index + 1)) {
+                results.push(skippedResult(remaining, 'prior_action_failed', dependencies));
+            }
+            break;
+        }
+        const report = makeReport(context, results, startedAt, dependencies, failed ? 'failed' : 'completed');
+        const outcome = { report };
+        if (terminalCause !== undefined) {
+            outcome.terminalCause = terminalCause;
+        }
+        return outcome;
+    });
+}
+/**
+ * Detached dispatch strategy, used for `post`. Each action is forked in
+ * configuration order and its terminal result is delivered through the
+ * optional completion callback; the dispatch report itself remains an honest
+ * record of launch rather than being rewritten after the fact.
+ */
+function dispatchDetachedActionPlan(actions, context, dependencies = {}) {
+    const plan = validatedPlan(actions);
+    const startedAt = iso(now(dependencies));
+    const results = [];
+    for (const action of plan) {
+        const timestamp = iso(now(dependencies));
+        results.push({
+            actionId: action.actionId,
+            mode: action.mode,
+            phase: action.phase,
+            index: action.index,
+            status: 'dispatched',
+            attempts: 0,
+            startedAt: timestamp,
+            completedAt: timestamp,
+            durationMs: 0,
+        });
+        const fields = commonFields(context, action);
+        fields.status = 'dispatched';
+        fields.duration_ms = 0;
+        dependencies.logger?.info?.('record_hook_action_dispatched', fields);
+        // runFork starts the fiber immediately, so the first legacy invocation of
+        // each action still happens in configuration order.
+        const fiber = effect_1.Effect.runFork(executeAction(action, dependencies, context, true).pipe(effect_1.Effect.tap(executed => effect_1.Effect.sync(() => dependencies.onDetachedActionComplete?.(context, executed.result))), effect_1.Effect.onExit(exit => {
+            if (exit._tag === 'Failure') {
+                const interrupted = Cause.isInterruptedOnly(exit.cause);
+                const interruptedFields = commonFields(context, action, 1);
+                const failure = interrupted
+                    ? (0, failure_1.normalizeActionFailure)(new failure_1.ActionInterruptedFailure(isCooperativelyCancellable(action)), isCooperativelyCancellable(action))
+                    : (0, failure_1.normalizeActionFailure)(failureCause(exit.cause), isCooperativelyCancellable(action));
+                const result = {
+                    actionId: action.actionId,
+                    mode: action.mode,
+                    phase: action.phase,
+                    index: action.index,
+                    status: statusForFailure(failure),
+                    attempts: 1,
+                    startedAt: iso(now(dependencies)),
+                    completedAt: iso(now(dependencies)),
+                    durationMs: 0,
+                    failure,
+                };
+                dependencies.onDetachedActionComplete?.(context, result);
+                interruptedFields.status = result.status;
+                interruptedFields.failure_kind = failure.kind;
+                interruptedFields.failure_code = failure.code;
+                interruptedFields.cancellation_cooperative = failure.cancellationCooperative;
+                interruptedFields.duration_ms = 0;
+                dependencies.logger?.warn?.('record_hook_detached_action_failed', interruptedFields);
+            }
+            return effect_1.Effect.void;
+        })));
+        dependencies.supervisor?.register?.(fiber);
+    }
+    return { report: makeReport(context, results, startedAt, dependencies, 'dispatched') };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"executor.js","sourceRoot":"","sources":["../../src/action-execution/executor.ts"],"names":[],"mappings":"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"}

package/dist/action-execution/failure.d.ts

@@ -0,0 +1,49 @@
+import { type ActionFailureKind, type SafeActionFailure } from './types';
+export declare class ActionConfigurationError extends Error {
+    readonly _tag = "ActionConfigurationError";
+    readonly code = "invalid-hook-execution-policy";
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare class ActionValidationFailure extends Error {
+    readonly _tag = "ActionValidationFailure";
+    readonly code = "action-validation-failed";
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare class ActionDomainFailure extends Error {
+    readonly _tag = "ActionDomainFailure";
+    readonly code: string;
+    constructor(message: string, code?: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare class ActionTransientFailure extends Error {
+    readonly _tag = "ActionTransientFailure";
+    readonly code: string;
+    constructor(message: string, code?: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare class ActionTimeoutFailure extends Error {
+    readonly _tag = "ActionTimeoutFailure";
+    readonly code = "action-timeout";
+    readonly cancellationCooperative: boolean;
+    constructor(cancellationCooperative: boolean);
+}
+export declare class ActionInterruptedFailure extends Error {
+    readonly _tag = "ActionInterruptedFailure";
+    readonly code = "action-interrupted";
+    readonly cancellationCooperative: boolean;
+    constructor(cancellationCooperative: boolean);
+}
+export declare function isActionFailureKind(value: unknown): value is ActionFailureKind;
+/**
+ * Normalization order is fixed by the design: configuration, validation,
+ * branded domain/transient, executor timeout, interruption, then everything
+ * else as unexpected. Message text is never inspected.
+ */
+export declare function normalizeActionFailure(cause: unknown, fallbackCancellationCooperative?: boolean): SafeActionFailure;
+//# sourceMappingURL=failure.d.ts.map

package/dist/action-execution/failure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"failure.d.ts","sourceRoot":"","sources":["../../src/action-execution/failure.ts"],"names":[],"mappings":"AACA,OAAO,EAAwB,KAAK,iBAAiB,EAAE,KAAK,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAS/F,qBAAa,wBAAyB,SAAQ,KAAK;IACjD,QAAQ,CAAC,IAAI,8BAA8B;IAC3C,QAAQ,CAAC,IAAI,mCAAmC;gBAEpC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;CAI3D;AAED,qBAAa,uBAAwB,SAAQ,KAAK;IAChD,QAAQ,CAAC,IAAI,6BAA6B;IAC1C,QAAQ,CAAC,IAAI,8BAA8B;gBAE/B,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;CAI3D;AAED,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,QAAQ,CAAC,IAAI,yBAAyB;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAEV,OAAO,EAAE,MAAM,EAAE,IAAI,SAAyB,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;CAK1F;AAED,qBAAa,sBAAuB,SAAQ,KAAK;IAC/C,QAAQ,CAAC,IAAI,4BAA4B;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAEV,OAAO,EAAE,MAAM,EAAE,IAAI,SAA4B,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;CAK7F;AAED,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,IAAI,0BAA0B;IACvC,QAAQ,CAAC,IAAI,oBAAoB;IACjC,QAAQ,CAAC,uBAAuB,EAAE,OAAO,CAAC;gBAE9B,uBAAuB,EAAE,OAAO;CAK7C;AAED,qBAAa,wBAAyB,SAAQ,KAAK;IACjD,QAAQ,CAAC,IAAI,8BAA8B;IAC3C,QAAQ,CAAC,IAAI,wBAAwB;IACrC,QAAQ,CAAC,uBAAuB,EAAE,OAAO,CAAC;gBAE9B,uBAAuB,EAAE,OAAO;CAK7C;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,iBAAiB,CAE9E;AAqBD;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,EAAE,+BAA+B,CAAC,EAAE,OAAO,GAAG,iBAAiB,CAqCnH"}

package/dist/action-execution/failure.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionInterruptedFailure = exports.ActionTimeoutFailure = exports.ActionTransientFailure = exports.ActionDomainFailure = exports.ActionValidationFailure = exports.ActionConfigurationError = void 0;
+exports.isActionFailureKind = isActionFailureKind;
+exports.normalizeActionFailure = normalizeActionFailure;
+const RBValidationError_1 = require("../model/RBValidationError");
+const types_1 = require("./types");
+class ActionConfigurationError extends Error {
+    _tag = 'ActionConfigurationError';
+    code = 'invalid-hook-execution-policy';
+    constructor(message, options) {
+        super(message, options);
+        this.name = this._tag;
+    }
+}
+exports.ActionConfigurationError = ActionConfigurationError;
+class ActionValidationFailure extends Error {
+    _tag = 'ActionValidationFailure';
+    code = 'action-validation-failed';
+    constructor(message, options) {
+        super(message, options);
+        this.name = this._tag;
+    }
+}
+exports.ActionValidationFailure = ActionValidationFailure;
+class ActionDomainFailure extends Error {
+    _tag = 'ActionDomainFailure';
+    code;
+    constructor(message, code = 'action-domain-failed', options) {
+        super(message, options);
+        this.name = this._tag;
+        this.code = code;
+    }
+}
+exports.ActionDomainFailure = ActionDomainFailure;
+class ActionTransientFailure extends Error {
+    _tag = 'ActionTransientFailure';
+    code;
+    constructor(message, code = 'action-transient-failed', options) {
+        super(message, options);
+        this.name = this._tag;
+        this.code = code;
+    }
+}
+exports.ActionTransientFailure = ActionTransientFailure;
+class ActionTimeoutFailure extends Error {
+    _tag = 'ActionTimeoutFailure';
+    code = 'action-timeout';
+    cancellationCooperative;
+    constructor(cancellationCooperative) {
+        super('Action execution timed out');
+        this.name = this._tag;
+        this.cancellationCooperative = cancellationCooperative;
+    }
+}
+exports.ActionTimeoutFailure = ActionTimeoutFailure;
+class ActionInterruptedFailure extends Error {
+    _tag = 'ActionInterruptedFailure';
+    code = 'action-interrupted';
+    cancellationCooperative;
+    constructor(cancellationCooperative) {
+        super('Action execution was interrupted');
+        this.name = this._tag;
+        this.cancellationCooperative = cancellationCooperative;
+    }
+}
+exports.ActionInterruptedFailure = ActionInterruptedFailure;
+function isActionFailureKind(value) {
+    return types_1.ACTION_FAILURE_KINDS.includes(value);
+}
+function fields(value) {
+    return value !== null && typeof value === 'object' ? value : {};
+}
+/** True for both a real instance and a structurally tagged look-alike. */
+function hasTag(value, tag) {
+    return fields(value)._tag === tag;
+}
+function safeCode(value, fallback) {
+    const code = fields(value).code;
+    return typeof code === 'string' && code.trim() ? code : fallback;
+}
+function cooperative(value, fallback) {
+    const flag = fields(value).cancellationCooperative;
+    return typeof flag === 'boolean' ? flag : fallback;
+}
+/**
+ * Normalization order is fixed by the design: configuration, validation,
+ * branded domain/transient, executor timeout, interruption, then everything
+ * else as unexpected. Message text is never inspected.
+ */
+function normalizeActionFailure(cause, fallbackCancellationCooperative) {
+    if (hasTag(cause, 'ActionConfigurationError')) {
+        return { kind: 'configuration', code: 'invalid-hook-execution-policy' };
+    }
+    if (RBValidationError_1.RBValidationError.isRBValidationError(cause)) {
+        return { kind: 'validation', code: 'record-validation-failed' };
+    }
+    if (hasTag(cause, 'ActionValidationFailure')) {
+        return { kind: 'validation', code: 'action-validation-failed' };
+    }
+    if (hasTag(cause, 'ActionDomainFailure')) {
+        return {
+            kind: 'domain',
+            code: safeCode(cause, 'action-domain-failed'),
+        };
+    }
+    if (hasTag(cause, 'ActionTransientFailure')) {
+        return {
+            kind: 'transient',
+            code: safeCode(cause, 'action-transient-failed'),
+        };
+    }
+    if (hasTag(cause, 'ActionTimeoutFailure')) {
+        return {
+            kind: 'timeout',
+            code: 'action-timeout',
+            cancellationCooperative: cooperative(cause, fallbackCancellationCooperative),
+        };
+    }
+    if (hasTag(cause, 'ActionInterruptedFailure')) {
+        return {
+            kind: 'interrupted',
+            code: 'action-interrupted',
+            cancellationCooperative: cooperative(cause, fallbackCancellationCooperative),
+        };
+    }
+    return { kind: 'unexpected', code: 'action-unexpected-failure' };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/action-execution/index.d.ts

@@ -0,0 +1,7 @@
+export * from './types';
+export * from './failure';
+export * from './policy';
+export * from './legacy-result';
+export * from './executor';
+export * from './audit';
+//# sourceMappingURL=index.d.ts.map

package/dist/action-execution/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/action-execution/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC"}