@jskit-ai/kernel 0.1.244 → 0.1.246

package/shared/actions/pipeline.js

@@ -1,309 +0,0 @@
-import {
-  ensureActionChannelAllowed,
-  ensureActionSurfaceAllowed,
-  ensureActionPermissionAllowed,
-  normalizeActionInput,
-  normalizeActionOutput
-} from "./policies.js";
-import {
-  createNoopIdempotencyAdapter,
-  resolveActionIdempotencyKey,
-  ensureIdempotencyKeyIfRequired
-} from "./idempotency.js";
-import { createNoopAuditAdapter } from "./audit.js";
-import { createNoopObservabilityAdapter } from "./observability.js";
-import { normalizeExecutionContext } from "./executionContext.js";
-
-async function publishActionEvents(events, builders, execution) {
-  if (!Array.isArray(builders) || builders.length === 0) return;
-  if (!events || typeof events.publish !== "function") {
-    throw new TypeError("Action event publishing requires runtime.events.publish().");
-  }
-  for (const builder of builders) {
-    const built = await builder(execution);
-    const values = Array.isArray(built) ? built : [built];
-    for (const event of values) {
-      if (event != null) await events.publish(event);
-    }
-  }
-}
-
-function normalizeOutcomeErrorCode(error) {
-  return String(error?.code || "ACTION_EXECUTION_FAILED").trim();
-}
-
-function buildActionLogPayload({ definition, context, outcome, durationMs, errorCode, idempotencyReplay }) {
-  return {
-    action: definition?.id,
-    version: definition?.version,
-    channel: context?.channel,
-    surface: context?.surface,
-    requestId: context?.requestMeta?.requestId || null,
-    durationMs,
-    outcome,
-    errorCode: errorCode || null,
-    idempotencyReplay: Boolean(idempotencyReplay)
-  };
-}
-
-async function emitAuditEvent(adapter, payload) {
-  if (!adapter || typeof adapter.emitExecution !== "function") {
-    return;
-  }
-
-  await adapter.emitExecution(payload);
-}
-
-async function executeIdempotencyClaim(adapter, payload) {
-  if (!adapter || typeof adapter.claimOrReplay !== "function") {
-    return {
-      type: "proceed",
-      idempotencyReplay: false,
-      claim: null,
-      replayResult: null
-    };
-  }
-
-  const result = await adapter.claimOrReplay(payload);
-  if (!result || typeof result !== "object") {
-    return {
-      type: "proceed",
-      idempotencyReplay: false,
-      claim: null,
-      replayResult: null
-    };
-  }
-
-  return {
-    type: String(result.type || "proceed"),
-    idempotencyReplay: result.idempotencyReplay === true,
-    claim: result.claim || null,
-    replayResult: Object.hasOwn(result, "replayResult") ? result.replayResult : null
-  };
-}
-
-async function executeActionPipeline({
-  definition,
-  input,
-  context,
-  deps = {},
-  idempotencyAdapter,
-  auditAdapter,
-  observabilityAdapter,
-  events,
-  logger = console
-} = {}) {
-  const normalizedContext = normalizeExecutionContext(context);
-  const normalizedIdempotencyAdapter = idempotencyAdapter || createNoopIdempotencyAdapter();
-  const normalizedAuditAdapter = auditAdapter || createNoopAuditAdapter();
-  const normalizedObservabilityAdapter = observabilityAdapter || createNoopObservabilityAdapter();
-  const startedAt = Date.now();
-
-  if (typeof normalizedObservabilityAdapter.recordExecutionStart === "function") {
-    normalizedObservabilityAdapter.recordExecutionStart({
-      definition,
-      context: normalizedContext
-    });
-  }
-
-  let idempotencyKey = "";
-  let idempotencyClaim = null;
-
-  try {
-    ensureActionChannelAllowed(definition, normalizedContext);
-    ensureActionSurfaceAllowed(definition, normalizedContext);
-    ensureActionPermissionAllowed(definition, normalizedContext);
-
-    const normalizedInput = await normalizeActionInput(definition, input, normalizedContext);
-
-    idempotencyKey = resolveActionIdempotencyKey(definition, normalizedContext);
-    ensureIdempotencyKeyIfRequired(definition, normalizedContext, idempotencyKey);
-
-    const idempotencyPolicy = String(definition?.idempotency || "none").trim().toLowerCase();
-    if (idempotencyPolicy !== "none") {
-      const claimResult = await executeIdempotencyClaim(normalizedIdempotencyAdapter, {
-        definition,
-        context: normalizedContext,
-        input: normalizedInput,
-        idempotencyKey
-      });
-
-      idempotencyClaim = claimResult.claim;
-      if (claimResult.type === "replay") {
-        if (typeof normalizedObservabilityAdapter.recordIdempotentReplay === "function") {
-          normalizedObservabilityAdapter.recordIdempotentReplay({
-            definition,
-            context: normalizedContext
-          });
-        }
-
-        const replayDurationMs = Date.now() - startedAt;
-        if (typeof normalizedObservabilityAdapter.recordExecutionFinish === "function") {
-          normalizedObservabilityAdapter.recordExecutionFinish({
-            definition,
-            context: normalizedContext,
-            outcome: "replay",
-            durationMs: replayDurationMs,
-            idempotencyReplay: true
-          });
-        }
-
-        await emitAuditEvent(normalizedAuditAdapter, {
-          definition,
-          context: normalizedContext,
-          outcome: "success",
-          result: claimResult.replayResult,
-          error: null,
-          durationMs: replayDurationMs,
-          idempotencyReplay: true
-        });
-
-        if (logger && typeof logger.debug === "function") {
-          logger.debug(
-            buildActionLogPayload({
-              definition,
-              context: normalizedContext,
-              outcome: "replay",
-              durationMs: replayDurationMs,
-              errorCode: null,
-              idempotencyReplay: true
-            }),
-            "action.execution"
-          );
-        }
-
-        return {
-          result: claimResult.replayResult,
-          idempotencyReplay: true
-        };
-      }
-    }
-
-    const executionResult = await definition.execute(normalizedInput, normalizedContext, deps);
-    const normalizedResult = await normalizeActionOutput(definition, executionResult, normalizedContext);
-
-    await publishActionEvents(events, definition.events, Object.freeze({
-      definition,
-      input: normalizedInput,
-      result: normalizedResult,
-      context: normalizedContext
-    }));
-
-    if (idempotencyClaim && typeof normalizedIdempotencyAdapter.markSucceeded === "function") {
-      await normalizedIdempotencyAdapter.markSucceeded({
-        definition,
-        context: normalizedContext,
-        input: normalizedInput,
-        result: normalizedResult,
-        claim: idempotencyClaim,
-        idempotencyKey
-      });
-    }
-
-    const durationMs = Date.now() - startedAt;
-    if (typeof normalizedObservabilityAdapter.recordExecutionFinish === "function") {
-      normalizedObservabilityAdapter.recordExecutionFinish({
-        definition,
-        context: normalizedContext,
-        outcome: "success",
-        durationMs,
-        idempotencyReplay: false
-      });
-    }
-
-    await emitAuditEvent(normalizedAuditAdapter, {
-      definition,
-      context: normalizedContext,
-      outcome: "success",
-      result: normalizedResult,
-      error: null,
-      durationMs,
-      idempotencyReplay: false
-    });
-
-    if (logger && typeof logger.debug === "function") {
-      logger.debug(
-        buildActionLogPayload({
-          definition,
-          context: normalizedContext,
-          outcome: "success",
-          durationMs,
-          errorCode: null,
-          idempotencyReplay: false
-        }),
-        "action.execution"
-      );
-    }
-
-    return {
-      result: normalizedResult,
-      idempotencyReplay: false
-    };
-  } catch (error) {
-    const executionError = error;
-
-    if (executionError?.code === "ACTION_VALIDATION_FAILED") {
-      if (typeof normalizedObservabilityAdapter.recordValidationFailure === "function") {
-        normalizedObservabilityAdapter.recordValidationFailure({
-          definition,
-          context: normalizedContext,
-          error: executionError
-        });
-      }
-    }
-
-    if (idempotencyClaim && typeof normalizedIdempotencyAdapter.markFailed === "function") {
-      await normalizedIdempotencyAdapter.markFailed({
-        definition,
-        context: normalizedContext,
-        input,
-        error: executionError,
-        claim: idempotencyClaim,
-        idempotencyKey
-      });
-    }
-
-    const durationMs = Date.now() - startedAt;
-    const errorCode = normalizeOutcomeErrorCode(executionError);
-
-    if (typeof normalizedObservabilityAdapter.recordExecutionFinish === "function") {
-      normalizedObservabilityAdapter.recordExecutionFinish({
-        definition,
-        context: normalizedContext,
-        outcome: "failure",
-        durationMs,
-        error: executionError,
-        errorCode,
-        idempotencyReplay: false
-      });
-    }
-
-    await emitAuditEvent(normalizedAuditAdapter, {
-      definition,
-      context: normalizedContext,
-      outcome: "failure",
-      result: null,
-      error: executionError,
-      durationMs,
-      idempotencyReplay: false
-    });
-
-    if (logger && typeof logger.debug === "function") {
-      logger.debug(
-        buildActionLogPayload({
-          definition,
-          context: normalizedContext,
-          outcome: "failure",
-          durationMs,
-          errorCode,
-          idempotencyReplay: false
-        }),
-        "action.execution"
-      );
-    }
-
-    throw executionError;
-  }
-}
-
-export { executeActionPipeline };

package/shared/actions/requestMeta.js

@@ -1,36 +0,0 @@
-import { normalizeText } from "./textNormalization.js";
-
-const DEFAULT_FIELDS = Object.freeze(["requestId", "commandId", "idempotencyKey", "ip", "userAgent", "request"]);
-
-function normalizeRequestMeta(requestMeta = {}, { fields = DEFAULT_FIELDS, emptyAsNull = false } = {}) {
-  const source = requestMeta && typeof requestMeta === "object" ? requestMeta : {};
-  const fieldList = Array.isArray(fields) && fields.length > 0 ? fields : DEFAULT_FIELDS;
-
-  const normalizeValue = (value) => {
-    const normalized = normalizeText(value);
-    if (emptyAsNull && !normalized) {
-      return null;
-    }
-    return normalized;
-  };
-
-  const normalized = {
-    ...source
-  };
-  for (const field of fieldList) {
-    if (field === "request") {
-      normalized.request = source.request || null;
-      continue;
-    }
-    if (field === "logger") {
-      normalized.logger = source.logger && typeof source.logger.warn === "function" ? source.logger : null;
-      continue;
-    }
-
-    normalized[field] = normalizeValue(source[field]);
-  }
-
-  return normalized;
-}
-
-export { normalizeRequestMeta };

package/shared/actions/textNormalization.js

@@ -1,3 +0,0 @@
-import { normalizeText, normalizeLowerText } from "../support/normalize.js";
-
-export { normalizeText, normalizeLowerText };

package/shared/actions/withActionDefaults.js

@@ -1,34 +0,0 @@
-import { normalizeObject } from "../support/normalize.js";
-
-function withActionDefaults(actions = [], defaults = {}) {
-  const sourceActions = Array.isArray(actions) ? actions : [];
-  const sourceDefaults = normalizeObject(defaults);
-  const defaultDependencies = normalizeObject(sourceDefaults.dependencies);
-  const hasDefaultDependencies = Object.keys(defaultDependencies).length > 0;
-  const hasDefaultDomain = Object.hasOwn(sourceDefaults, "domain");
-
-  return Object.freeze(
-    sourceActions.map((entry) => {
-      const action = normalizeObject(entry);
-      const actionDependencies = normalizeObject(action.dependencies);
-      const next = {
-        ...action
-      };
-
-      if (hasDefaultDomain && !Object.hasOwn(next, "domain")) {
-        next.domain = sourceDefaults.domain;
-      }
-
-      if (hasDefaultDependencies || Object.keys(actionDependencies).length > 0) {
-        next.dependencies = Object.freeze({
-          ...defaultDependencies,
-          ...actionDependencies
-        });
-      }
-
-      return Object.freeze(next);
-    })
-  );
-}
-
-export { withActionDefaults };