@clusterenvision/ui-framework 1.0.0

package/dist/chunk-FNXIYAET.cjs

@@ -0,0 +1,1593 @@
+'use strict';
+
+var chunkSM35JOYD_cjs = require('./chunk-SM35JOYD.cjs');
+var fs = require('fs');
+
+// src/runtime/logger.js
+var defaultConsoleWriter = {
+  debug: console.debug.bind(console),
+  info: console.info.bind(console),
+  warn: console.warn.bind(console),
+  error: console.error.bind(console)
+};
+var ConsoleLogger = class {
+  constructor(scope = "runtime", writer = defaultConsoleWriter) {
+    this.scope = scope;
+    this.writer = writer;
+  }
+  log(event) {
+    const { context: originalContext, error: explicitError, level, message } = event;
+    const { context, errorFromContext } = extractErrorFromContext(originalContext);
+    const payload = {
+      ...context,
+      level,
+      timestamp: (event.timestamp ?? /* @__PURE__ */ new Date()).toISOString()
+    };
+    const normalizedScope = context?.scope ?? this.scope;
+    if (normalizedScope) {
+      payload.scope = normalizedScope;
+    }
+    const normalizedError = explicitError ?? normalizeError(errorFromContext);
+    if (normalizedError) {
+      payload.error = normalizedError;
+    }
+    this.writer[level](`[ceui${normalizedScope ? `:${normalizedScope}` : ""}] ${message}`, payload);
+  }
+  debug(message, context) {
+    this.log({ level: "debug", message, context });
+  }
+  info(message, context) {
+    this.log({ level: "info", message, context });
+  }
+  warn(message, context) {
+    this.log({ level: "warn", message, context });
+  }
+  error(message, context) {
+    this.log({ level: "error", message, context });
+  }
+};
+function extractErrorFromContext(context) {
+  if (!context || typeof context !== "object") {
+    return { context: void 0, errorFromContext: void 0 };
+  }
+  const { error, ...rest } = context;
+  return { context: rest, errorFromContext: error };
+}
+function normalizeError(error) {
+  if (!error) {
+    return void 0;
+  }
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack,
+      cause: error.cause
+    };
+  }
+  if (typeof error === "string") {
+    return { message: error };
+  }
+  if (typeof error === "object") {
+    const candidate = error;
+    const message = typeof candidate.message === "string" ? candidate.message : JSON.stringify(candidate);
+    const stack = typeof candidate.stack === "string" ? candidate.stack : void 0;
+    const name = typeof candidate.name === "string" ? candidate.name : void 0;
+    const cause = candidate.cause;
+    return { message, stack, name, cause };
+  }
+  if (typeof error === "number" || typeof error === "boolean" || typeof error === "bigint" || typeof error === "symbol") {
+    return { message: String(error) };
+  }
+  return { message: "Unknown error" };
+}
+
+// src/runtime/workflow/services.js
+var SystemTimeService = class {
+  wait(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  now() {
+    return /* @__PURE__ */ new Date();
+  }
+};
+var DefaultBackgroundRunner = class {
+  constructor(logger = new ConsoleWorkflowLogger()) {
+    this.logger = logger;
+  }
+  dispatch(taskName, payload) {
+    this.logger.info("Dispatch background task", {
+      eventId: "workflow.background.dispatch",
+      taskName,
+      payload
+    });
+    return Promise.resolve();
+  }
+};
+var InMemoryWorkflowStore = class {
+  constructor() {
+    this.instances = /* @__PURE__ */ new Map();
+  }
+  save(instance) {
+    this.instances.set(instance.id, {
+      ...instance,
+      history: [...instance.history],
+      state: { ...instance.state }
+    });
+    return Promise.resolve();
+  }
+  load(id) {
+    const record = this.instances.get(id);
+    if (!record) {
+      return Promise.resolve(null);
+    }
+    return Promise.resolve({
+      ...record,
+      history: [...record.history],
+      state: { ...record.state }
+    });
+  }
+};
+var InMemorySchedulerService = class {
+  constructor(background = new DefaultBackgroundRunner(), time = new SystemTimeService(), logger = new ConsoleWorkflowLogger(), trace) {
+    this.background = background;
+    this.time = time;
+    this.logger = logger;
+    this.trace = trace;
+  }
+  async schedule(request, context) {
+    const delay = computeDelay(request, this.time.now());
+    if (delay > 0) {
+      await this.time.wait(delay);
+    }
+    await this.background.dispatch(request.taskName, request.payload);
+    this.logger.info("Scheduled workflow task dispatched", {
+      eventId: "workflow.scheduler.dispatch",
+      taskName: request.taskName,
+      runAt: request.runAt?.toISOString(),
+      delayMs: delay,
+      workflowId: context.definition.name,
+      stepId: context.step.id,
+      runId: context.runId,
+      workflowVersion: context.definition.version
+    });
+    const sink = context.trace ?? this.trace;
+    if (sink) {
+      void sink.record({
+        type: "workflow.scheduler.dispatched",
+        timestamp: /* @__PURE__ */ new Date(),
+        workflowId: context.definition.name,
+        workflowVersion: context.definition.version,
+        instanceId: context.instanceId,
+        stepId: context.step.id,
+        runId: context.runId,
+        delayMs: delay,
+        attributes: { taskName: request.taskName }
+      });
+    }
+  }
+};
+var InMemoryDatabaseRegistry = class {
+  constructor() {
+    this.providers = /* @__PURE__ */ new Map();
+  }
+  register(provider) {
+    this.providers.set(provider.name, provider);
+  }
+  get(name) {
+    return this.providers.get(name);
+  }
+  list() {
+    return [...this.providers.keys()];
+  }
+};
+var DefaultApprovalResolver = class {
+  resolve(gate, context) {
+    if (!gate.requiredRoles && !gate.approvers) {
+      return Promise.resolve({ status: "approved", decidedAt: /* @__PURE__ */ new Date(), decidedBy: context.actor?.id });
+    }
+    const actor = context.actor;
+    if (!actor) {
+      return Promise.resolve({ status: "pending" });
+    }
+    const roleMatch = gate.requiredRoles?.every((role) => actor.roles?.includes(role)) ?? true;
+    const approverMatch = gate.approvers ? gate.approvers.includes(actor.id) : true;
+    if (roleMatch && approverMatch) {
+      return Promise.resolve({ status: "approved", decidedAt: /* @__PURE__ */ new Date(), decidedBy: actor.id });
+    }
+    return Promise.resolve({ status: "pending" });
+  }
+};
+var ConsoleWorkflowLogger = class extends ConsoleLogger {
+  constructor() {
+    super("workflow");
+  }
+};
+function computeDelay(request, now) {
+  if (request.runAt) {
+    return Math.max(0, request.runAt.getTime() - now.getTime());
+  }
+  if (typeof request.delayMs === "number") {
+    return Math.max(0, request.delayMs);
+  }
+  return 0;
+}
+var NoopWorkflowTraceSink = class {
+  record() {
+  }
+};
+var ConsoleWorkflowTraceSink = class {
+  constructor(logger = new ConsoleWorkflowLogger()) {
+    this.logger = logger;
+  }
+  record(event) {
+    const timestamp = event.timestamp instanceof Date ? event.timestamp : new Date(event.timestamp);
+    this.logger.info("Workflow trace event", {
+      eventId: event.type,
+      workflowId: event.workflowId,
+      workflowVersion: event.workflowVersion,
+      instanceId: event.instanceId,
+      stepId: event.stepId,
+      runId: event.runId,
+      attempt: event.attempt,
+      gateId: event.gateId,
+      approvalStatus: event.approvalStatus,
+      durationMs: event.durationMs,
+      delayMs: event.delayMs,
+      attributes: event.attributes,
+      timestamp: timestamp.toISOString()
+    });
+  }
+};
+var RecordingWorkflowTraceSink = class {
+  constructor() {
+    this.events = [];
+  }
+  record(event) {
+    this.events.push(event);
+  }
+  getEvents() {
+    return [...this.events];
+  }
+  toJSON() {
+    return this.getEvents();
+  }
+  clear() {
+    this.events.length = 0;
+  }
+};
+var FileWorkflowTraceSink = class {
+  constructor(filePath, writer = fs.promises) {
+    this.exporter = new chunkSM35JOYD_cjs.JsonlTraceExporter({ filePath, writer });
+  }
+  record(event) {
+    return this.exporter.export(buildWorkflowTracePayload(event));
+  }
+};
+var WorkflowTraceExporterSink = class {
+  constructor(exporter) {
+    this.exporter = exporter;
+  }
+  record(event) {
+    return this.exporter.export(buildWorkflowTracePayload(event));
+  }
+};
+function buildWorkflowTracePayload(event) {
+  const timestamp = event.timestamp instanceof Date ? event.timestamp : new Date(event.timestamp);
+  return {
+    type: event.type,
+    timestamp,
+    attributes: compact({
+      workflowId: event.workflowId,
+      workflowVersion: event.workflowVersion,
+      instanceId: event.instanceId,
+      stepId: event.stepId,
+      runId: event.runId,
+      attempt: event.attempt,
+      gateId: event.gateId,
+      approvalStatus: event.approvalStatus,
+      durationMs: event.durationMs,
+      delayMs: event.delayMs,
+      actorId: event.actorId,
+      ...event.attributes
+    })
+  };
+}
+function compact(record) {
+  if (!record) {
+    return void 0;
+  }
+  const entries = Object.entries(record).filter(([, value]) => typeof value !== "undefined");
+  if (entries.length === 0) {
+    return void 0;
+  }
+  return Object.fromEntries(entries);
+}
+
+// src/runtime/workflow/runtime.js
+var WorkflowRuntime = class {
+  constructor(options) {
+    this.options = options;
+    this.tasks = /* @__PURE__ */ new Map();
+    this.logger = options.logger ?? new ConsoleWorkflowLogger();
+    this.trace = options.traceSink ?? new NoopWorkflowTraceSink();
+    const time = options.services?.time ?? new SystemTimeService();
+    const background = options.services?.background ?? new DefaultBackgroundRunner(this.logger);
+    const scheduler = options.services?.scheduler ?? new InMemorySchedulerService(background, time, this.logger, this.trace);
+    this.services = {
+      background,
+      http: options.services?.http,
+      databases: options.services?.databases,
+      time,
+      scheduler,
+      trace: this.trace
+    };
+    this.idGenerator = options.idGenerator ?? (() => {
+      const globalCrypto = globalThis.crypto;
+      if (globalCrypto?.randomUUID) {
+        return globalCrypto.randomUUID();
+      }
+      return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+    });
+    this.approvalResolver = options.approvalResolver ?? new DefaultApprovalResolver();
+    if (options.tasks) {
+      for (const [name, handler] of Object.entries(options.tasks)) {
+        this.registerTask(name, handler);
+      }
+    }
+  }
+  registerTask(name, handler) {
+    this.tasks.set(name, handler);
+  }
+  hasTask(name) {
+    return this.tasks.has(name);
+  }
+  listTasks() {
+    return [...this.tasks.keys()];
+  }
+  async run(definition, request = {}) {
+    const state = { ...request.state ?? {} };
+    const instance = {
+      id: request.instanceId ?? this.idGenerator(),
+      workflowId: definition.name,
+      version: definition.version,
+      status: "running",
+      currentStep: definition.entry,
+      state,
+      actor: request.actor,
+      metadata: request.metadata ?? definition.metadata,
+      history: [],
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    await this.options.store.save(instance);
+    this.emitTrace({
+      type: "workflow.run.started",
+      workflowId: definition.name,
+      workflowVersion: definition.version,
+      instanceId: instance.id,
+      actorId: instance.actor?.id
+    });
+    let currentStepId = definition.entry;
+    while (currentStepId) {
+      const step = currentStepId ? definition.steps[currentStepId] : void 0;
+      if (!step) {
+        throw new Error(`Unknown step '${currentStepId}' in workflow '${definition.name}'`);
+      }
+      instance.currentStep = step.id;
+      const approval = await this.ensureApprovals(step, instance);
+      const approvalDecision = approval?.decision;
+      if (approvalDecision?.status === "pending") {
+        instance.status = "waiting";
+        await this.persist(instance);
+        this.emitTrace({
+          type: "workflow.run.waiting",
+          workflowId: definition.name,
+          workflowVersion: definition.version,
+          instanceId: instance.id,
+          stepId: step.id,
+          attributes: { reason: "approval-pending", gateId: approval?.gateId }
+        });
+        return { instance, status: "waiting" };
+      }
+      if (approvalDecision?.status === "rejected") {
+        instance.status = "failed";
+        instance.history.push(this.buildHistoryEntry(step, "failure", 0, approvalDecision.reason ?? "Approval rejected"));
+        await this.persist(instance);
+        this.emitTrace({
+          type: "workflow.run.failed",
+          workflowId: definition.name,
+          workflowVersion: definition.version,
+          instanceId: instance.id,
+          stepId: step.id,
+          attributes: { reason: "approval-rejected", gateId: approval?.gateId }
+        });
+        return { instance, status: "failed" };
+      }
+      const { result, attempts } = await this.executeStep(definition, step, state, instance);
+      instance.history.push(this.buildHistoryEntry(step, result.status, attempts, typeof result.error === "string" ? result.error : void 0));
+      instance.state = state;
+      instance.updatedAt = /* @__PURE__ */ new Date();
+      if (result.status === "success") {
+        const transition = result.transition ?? step.transitions?.success;
+        if (!transition) {
+          instance.status = "completed";
+          await this.persist(instance);
+          this.emitTrace({
+            type: "workflow.run.completed",
+            workflowId: definition.name,
+            workflowVersion: definition.version,
+            instanceId: instance.id
+          });
+          return { instance, status: "completed", output: state };
+        }
+        currentStepId = transition;
+      } else {
+        const transition = step.transitions?.failure;
+        if (transition) {
+          currentStepId = transition;
+        } else {
+          instance.status = "failed";
+          await this.persist(instance);
+          this.emitTrace({
+            type: "workflow.run.failed",
+            workflowId: definition.name,
+            workflowVersion: definition.version,
+            instanceId: instance.id,
+            stepId: step.id
+          });
+          return { instance, status: "failed" };
+        }
+      }
+    }
+    instance.status = "completed";
+    await this.persist(instance);
+    this.emitTrace({
+      type: "workflow.run.completed",
+      workflowId: definition.name,
+      workflowVersion: definition.version,
+      instanceId: instance.id
+    });
+    return { instance, status: "completed", output: state };
+  }
+  async executeStep(definition, step, state, instance) {
+    const handler = this.resolveTask(step.task);
+    const retryPolicy = this.normalizeRetry(step.retry);
+    const services = this.services;
+    const logger = this.logger;
+    let attempt = 0;
+    while (attempt < retryPolicy.maxAttempts) {
+      attempt += 1;
+      const context = {
+        runId: this.idGenerator(),
+        instanceId: instance.id,
+        definition,
+        step,
+        input: step.task.input,
+        state,
+        actor: instance.actor,
+        services,
+        logger,
+        trace: this.trace
+      };
+      const stepStart = /* @__PURE__ */ new Date();
+      this.emitTrace({
+        type: "workflow.step.started",
+        workflowId: definition.name,
+        workflowVersion: definition.version,
+        instanceId: instance.id,
+        stepId: step.id,
+        runId: context.runId,
+        attempt
+      });
+      try {
+        const result = await handler(context);
+        if (result.data) {
+          Object.assign(state, result.data);
+        }
+        if (result.status === "success") {
+          const finishedAt = /* @__PURE__ */ new Date();
+          this.emitTrace({
+            type: "workflow.step.completed",
+            workflowId: definition.name,
+            workflowVersion: definition.version,
+            instanceId: instance.id,
+            stepId: step.id,
+            runId: context.runId,
+            attempt,
+            durationMs: finishedAt.getTime() - stepStart.getTime(),
+            attributes: result.data
+          });
+          return { result, attempts: attempt };
+        }
+        this.emitTrace({
+          type: "workflow.step.failed",
+          workflowId: definition.name,
+          workflowVersion: definition.version,
+          instanceId: instance.id,
+          stepId: step.id,
+          runId: context.runId,
+          attempt,
+          attributes: { reason: "handler-result", transition: result.transition }
+        });
+        if (attempt < retryPolicy.maxAttempts) {
+          const waitTime = await this.waitForRetry(attempt, retryPolicy.delayMs, retryPolicy.backoff);
+          this.emitTrace({
+            type: "workflow.step.retry",
+            workflowId: definition.name,
+            workflowVersion: definition.version,
+            instanceId: instance.id,
+            stepId: step.id,
+            runId: context.runId,
+            attempt,
+            delayMs: waitTime
+          });
+          continue;
+        }
+        return { result, attempts: attempt };
+      } catch (error) {
+        logger.error("Workflow step execution failed", {
+          eventId: "workflow.step.failed",
+          workflowId: definition.name,
+          workflowVersion: definition.version,
+          stepId: step.id,
+          runId: context.runId,
+          attempt,
+          error
+        });
+        this.emitTrace({
+          type: "workflow.step.failed",
+          workflowId: definition.name,
+          workflowVersion: definition.version,
+          instanceId: instance.id,
+          stepId: step.id,
+          runId: context.runId,
+          attempt,
+          attributes: {
+            reason: "exception",
+            message: error instanceof Error ? error.message : String(error)
+          }
+        });
+        if (attempt >= retryPolicy.maxAttempts) {
+          return {
+            result: { status: "failure", error },
+            attempts: attempt
+          };
+        }
+        const waitTime = await this.waitForRetry(attempt, retryPolicy.delayMs, retryPolicy.backoff);
+        this.emitTrace({
+          type: "workflow.step.retry",
+          workflowId: definition.name,
+          workflowVersion: definition.version,
+          instanceId: instance.id,
+          stepId: step.id,
+          runId: context.runId,
+          attempt,
+          delayMs: waitTime
+        });
+      }
+    }
+    return { result: { status: "failure", error: "Unknown failure" }, attempts: attempt };
+  }
+  normalizeRetry(retry) {
+    return {
+      maxAttempts: Math.max(1, retry?.maxAttempts ?? 1),
+      delayMs: retry?.delayMs ?? 0,
+      backoff: retry?.backoff ?? "fixed"
+    };
+  }
+  resolveTask(task2) {
+    const handler = this.tasks.get(task2.handler);
+    if (!handler) {
+      throw new Error(`Task handler '${task2.handler}' has not been registered`);
+    }
+    return handler;
+  }
+  buildHistoryEntry(step, status, attempt, notes) {
+    return {
+      stepId: step.id,
+      status,
+      attempt,
+      timestamp: /* @__PURE__ */ new Date(),
+      notes
+    };
+  }
+  async ensureApprovals(step, instance) {
+    if (!step.approvals || step.approvals.length === 0) {
+      return void 0;
+    }
+    for (const gate of step.approvals) {
+      this.emitTrace({
+        type: "workflow.approval.requested",
+        workflowId: instance.workflowId,
+        workflowVersion: instance.version,
+        instanceId: instance.id,
+        stepId: step.id,
+        gateId: gate.id,
+        actorId: instance.actor?.id
+      });
+      const decision = await this.approvalResolver.resolve(gate, {
+        actor: instance.actor,
+        instance,
+        step
+      });
+      this.emitTrace({
+        type: "workflow.approval.resolved",
+        workflowId: instance.workflowId,
+        workflowVersion: instance.version,
+        instanceId: instance.id,
+        stepId: step.id,
+        gateId: gate.id,
+        approvalStatus: decision.status,
+        actorId: decision.decidedBy ?? instance.actor?.id
+      });
+      if (decision.status !== "approved") {
+        return { decision, gateId: gate.id };
+      }
+    }
+    return void 0;
+  }
+  async waitForRetry(attempt, delayMs, backoff) {
+    if (delayMs <= 0 || !this.services.time) {
+      return 0;
+    }
+    let waitTime = delayMs;
+    if (backoff === "exponential") {
+      waitTime = delayMs * 2 ** (attempt - 1);
+    } else if (backoff === "jitter") {
+      const base = delayMs * 2 ** (attempt - 1);
+      waitTime = Math.floor(Math.random() * base);
+    }
+    await this.services.time.wait(waitTime);
+    return waitTime;
+  }
+  async persist(instance) {
+    await this.options.store.save(instance);
+  }
+  emitTrace(event) {
+    void this.trace.record({
+      ...event,
+      timestamp: event.timestamp ?? /* @__PURE__ */ new Date()
+    });
+  }
+};
+
+// src/runtime/workflow/dsl.js
+function createWorkflow(name, configure, options = {}) {
+  const builder = new WorkflowBuilder(name, options.version ?? "1.0.0");
+  if (options.entry) {
+    builder.entry(options.entry);
+  }
+  if (options.metadata) {
+    builder.metadata(options.metadata);
+  }
+  configure(builder);
+  return builder.build();
+}
+var WorkflowBuilder = class {
+  constructor(workflowName, versionValue) {
+    this.workflowName = workflowName;
+    this.versionValue = versionValue;
+    this.steps = /* @__PURE__ */ new Map();
+  }
+  version(value) {
+    this.versionValue = value;
+    return this;
+  }
+  entry(stepId) {
+    this.entryStep = stepId;
+    return this;
+  }
+  metadata(data) {
+    this.metadataValue = { ...this.metadataValue ?? {}, ...data };
+    return this;
+  }
+  step(id, task2, configure) {
+    const definition = {
+      id,
+      task: task2
+    };
+    const builder = new WorkflowStepBuilder(this, definition);
+    configure?.(builder);
+    this.steps.set(id, definition);
+    if (!this.entryStep) {
+      this.entryStep = id;
+    }
+    return this;
+  }
+  build() {
+    if (!this.entryStep) {
+      throw new Error(`Workflow '${this.workflowName}' must declare at least one step`);
+    }
+    return {
+      name: this.workflowName,
+      version: this.versionValue,
+      entry: this.entryStep,
+      steps: Object.fromEntries(this.steps),
+      metadata: this.metadataValue
+    };
+  }
+};
+var WorkflowStepBuilder = class {
+  constructor(parent, definition) {
+    this.parent = parent;
+    this.definition = definition;
+  }
+  onSuccess(stepId) {
+    this.definition.transitions = { ...this.definition.transitions ?? {}, success: stepId };
+    return this;
+  }
+  onFailure(stepId) {
+    this.definition.transitions = { ...this.definition.transitions ?? {}, failure: stepId };
+    return this;
+  }
+  withRetry(policy) {
+    this.definition.retry = { ...policy };
+    return this;
+  }
+  withApproval(gate) {
+    this.definition.approvals = [...this.definition.approvals ?? [], gate];
+    return this;
+  }
+  metadata(data) {
+    this.definition.metadata = { ...this.definition.metadata ?? {}, ...data };
+    return this;
+  }
+  end() {
+    return this.parent;
+  }
+};
+function task(handler, input) {
+  return { handler, input };
+}
+function workflowFromJson(json) {
+  if (!json.name || !json.entry || !json.version) {
+    throw new Error("Invalid workflow definition JSON payload");
+  }
+  return {
+    name: json.name,
+    version: json.version,
+    entry: json.entry,
+    steps: json.steps,
+    metadata: json.metadata
+  };
+}
+
+// src/runtime/workflow/tasks.js
+var HTTP_TASK = "workflow.http.request";
+var DATABASE_TASK = "workflow.database.execute";
+var DELAY_TASK = "workflow.time.delay";
+var SCHEDULE_TASK = "workflow.background.schedule";
+function httpTask(options) {
+  return { handler: HTTP_TASK, input: options };
+}
+function databaseTask(options) {
+  return { handler: DATABASE_TASK, input: options };
+}
+function delayTask(options) {
+  return { handler: DELAY_TASK, input: options };
+}
+function scheduleTask(options) {
+  return { handler: SCHEDULE_TASK, input: options };
+}
+function createDefaultTaskMap(executor) {
+  return {
+    [HTTP_TASK]: createHttpTaskHandler(executor),
+    [DATABASE_TASK]: createDatabaseTaskHandler(),
+    [DELAY_TASK]: createDelayTaskHandler(),
+    [SCHEDULE_TASK]: createScheduleTaskHandler()
+  };
+}
+function createHttpTaskHandler(fallback) {
+  return async (context) => {
+    if (!context.input) {
+      throw new Error("HTTP task requires an input payload");
+    }
+    const optionsCandidate = context.input;
+    if (!optionsCandidate.url || typeof optionsCandidate.url !== "string") {
+      throw new Error("HTTP task requires a `url` property");
+    }
+    const options = optionsCandidate;
+    const executor = context.services.http ?? fallback ?? createFetchHttpExecutor();
+    const response = await executor(options, context);
+    const isSuccess = response.status >= 200 && response.status < 300;
+    const payloadKey = options.assignResponseTo;
+    const data = payloadKey ? { [payloadKey]: response.body ?? response } : void 0;
+    return {
+      status: isSuccess ? "success" : "failure",
+      data,
+      error: isSuccess ? void 0 : { status: response.status, body: response.body }
+    };
+  };
+}
+function createDatabaseTaskHandler() {
+  return async (context) => {
+    if (!context.input) {
+      throw new Error("Database task requires input payload");
+    }
+    const partialInput = context.input;
+    if (!partialInput.provider) {
+      throw new Error("Database task input missing `provider`");
+    }
+    if (!partialInput.operation) {
+      throw new Error("Database task input missing `operation` details");
+    }
+    const options = partialInput;
+    const registry = context.services.databases;
+    if (!registry) {
+      throw new Error("No database registry injected into workflow services");
+    }
+    const provider = registry.get(options.provider);
+    if (!provider) {
+      throw new Error(`Database provider '${options.provider}' was not registered`);
+    }
+    const result = await provider.execute(options.operation, { actor: context.actor });
+    const data = options.assignResultTo ? { [options.assignResultTo]: result } : void 0;
+    return { status: "success", data };
+  };
+}
+function createDelayTaskHandler() {
+  return async (context) => {
+    const options = context.input ? context.input : {};
+    const delayMs = normalizeDelay(options);
+    if (delayMs <= 0) {
+      return { status: "success" };
+    }
+    if (context.services.time) {
+      await context.services.time.wait(delayMs);
+    } else {
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+    return { status: "success" };
+  };
+}
+function createScheduleTaskHandler() {
+  return async (context) => {
+    if (!context.input) {
+      throw new Error("Schedule task requires an input payload");
+    }
+    const options = context.input;
+    if (!options.taskName) {
+      throw new Error("Schedule task requires a taskName");
+    }
+    const scheduleRequest = {
+      taskName: options.taskName,
+      payload: options.payload,
+      description: options.description,
+      runAt: options.runAt ? new Date(options.runAt) : void 0,
+      delayMs: options.delayMs
+    };
+    if (context.services.scheduler) {
+      await context.services.scheduler.schedule(scheduleRequest, context);
+      return { status: "success" };
+    }
+    const delayMs = scheduleRequest.runAt ? Math.max(0, scheduleRequest.runAt.getTime() - Date.now()) : Math.max(0, scheduleRequest.delayMs ?? 0);
+    if (delayMs > 0) {
+      if (context.services.time) {
+        await context.services.time.wait(delayMs);
+      } else {
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+      }
+    }
+    if (!context.services.background) {
+      throw new Error("No background runner available to dispatch scheduled task");
+    }
+    await context.services.background.dispatch(scheduleRequest.taskName, scheduleRequest.payload);
+    return { status: "success" };
+  };
+}
+function createFetchHttpExecutor(fetchImpl) {
+  const resolvedFetch = fetchImpl ?? globalThis.fetch;
+  if (!resolvedFetch) {
+    throw new Error("Fetch API is not available in this runtime. Provide a custom http service.");
+  }
+  return async (request, context) => {
+    const url = withQueryString(request.url, request.query);
+    const body = typeof request.body === "object" && request.body !== null ? JSON.stringify(request.body) : request.body;
+    const response = await resolvedFetch(url, {
+      method: request.method ?? "GET",
+      headers: request.headers,
+      body
+    });
+    const headers = extractHeaders(response.headers);
+    const parseMode = determineParseMode(request);
+    const payload = parseMode === "text" ? await response.text() : await safeJson(response);
+    context.logger?.debug("HTTP task executed", { url, status: response.status });
+    return {
+      status: response.status,
+      headers,
+      body: payload
+    };
+  };
+}
+function determineParseMode(request) {
+  return request.parse ?? "auto";
+}
+async function safeJson(response) {
+  try {
+    return await response.json();
+  } catch {
+    return await response.text();
+  }
+}
+function extractHeaders(source) {
+  const result = {};
+  if (!source) {
+    return result;
+  }
+  source.forEach((value, key) => {
+    result[key] = value;
+  });
+  return result;
+}
+function withQueryString(url, query) {
+  if (!query || Object.keys(query).length === 0) {
+    return url;
+  }
+  const usp = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    usp.append(key, String(value));
+  }
+  const separator = url.includes("?") ? "&" : "?";
+  return `${url}${separator}${usp.toString()}`;
+}
+var FunctionalDatabaseProvider = class {
+  constructor(name, executor) {
+    this.name = name;
+    this.executor = executor;
+  }
+  execute(operation, context) {
+    return this.executor(operation, context);
+  }
+};
+function createSqlDatabaseProvider(options) {
+  return new FunctionalDatabaseProvider(options.name, (operation) => {
+    if (!operation.text) {
+      throw new Error("SQL operations require the `text` property");
+    }
+    return options.query(operation.text, operation.parameters);
+  });
+}
+function createMySqlProvider(client, name = "mysql") {
+  return createSqlDatabaseProvider({
+    name,
+    query: (sql, params) => client.query(sql, params)
+  });
+}
+function createPostgresProvider(client, name = "postgres") {
+  return createSqlDatabaseProvider({
+    name,
+    query: (sql, params) => client.query(sql, params)
+  });
+}
+function createSqliteProvider(client, name = "sqlite") {
+  return createSqlDatabaseProvider({
+    name,
+    query: (sql, params) => client.run(sql, params)
+  });
+}
+function createMongoProvider(options) {
+  return new FunctionalDatabaseProvider(options.name ?? "mongodb", (op) => {
+    if (!op.collection) {
+      throw new Error("Mongo operations require a collection name");
+    }
+    return options.run(op);
+  });
+}
+function registerDefaultDatabaseProviders(registry, providers) {
+  for (const provider of providers) {
+    registry.register(provider);
+  }
+}
+function normalizeDelay(options) {
+  if (typeof options.milliseconds === "number") {
+    return Math.max(0, options.milliseconds);
+  }
+  if (typeof options.seconds === "number") {
+    return Math.max(0, options.seconds * 1e3);
+  }
+  return 0;
+}
+
+// src/runtime/workflow/stores/databaseStore.js
+var DatabaseWorkflowStore = class {
+  constructor(options) {
+    this.options = options;
+    this.table = options.table ?? "workflow_instances";
+    this.dialect = options.dialect ?? "postgres";
+  }
+  async save(instance) {
+    const nowIso = instance.updatedAt.toISOString();
+    const params = [
+      instance.id,
+      instance.workflowId,
+      instance.version,
+      instance.status,
+      instance.currentStep ?? null,
+      JSON.stringify(instance.state),
+      instance.actor ? JSON.stringify(instance.actor) : null,
+      instance.metadata ? JSON.stringify(instance.metadata) : null,
+      JSON.stringify(instance.history),
+      instance.createdAt.toISOString(),
+      nowIso
+    ];
+    const sql = buildUpsertStatement(this.table, this.dialect);
+    await this.options.provider.execute({ type: "command", text: sql, parameters: params });
+  }
+  async load(id) {
+    const sql = `SELECT id, workflow_id, version, status, current_step, state_json, actor_json, metadata_json, history_json, created_at, updated_at FROM ${this.table} WHERE id = ${buildPlaceholder(1, this.dialect)}`;
+    const result = await this.options.provider.execute({
+      type: "query",
+      text: sql,
+      parameters: [id]
+    });
+    if (!result || result.length === 0) {
+      return null;
+    }
+    return mapRowToInstance(result[0]);
+  }
+};
+function buildUpsertStatement(table, dialect) {
+  const columns = "(id, workflow_id, version, status, current_step, state_json, actor_json, metadata_json, history_json, created_at, updated_at)";
+  const values = buildInsertValues(11, dialect);
+  const base = `INSERT INTO ${table} ${columns} VALUES ${values}`;
+  if (dialect === "postgres") {
+    return `${base} ON CONFLICT (id) DO UPDATE SET workflow_id = EXCLUDED.workflow_id, version = EXCLUDED.version, status = EXCLUDED.status, current_step = EXCLUDED.current_step, state_json = EXCLUDED.state_json, actor_json = EXCLUDED.actor_json, metadata_json = EXCLUDED.metadata_json, history_json = EXCLUDED.history_json, updated_at = EXCLUDED.updated_at`;
+  }
+  if (dialect === "sqlite") {
+    return `${base} ON CONFLICT(id) DO UPDATE SET workflow_id = excluded.workflow_id, version = excluded.version, status = excluded.status, current_step = excluded.current_step, state_json = excluded.state_json, actor_json = excluded.actor_json, metadata_json = excluded.metadata_json, history_json = excluded.history_json, updated_at = excluded.updated_at`;
+  }
+  return `${base} ON DUPLICATE KEY UPDATE workflow_id = VALUES(workflow_id), version = VALUES(version), status = VALUES(status), current_step = VALUES(current_step), state_json = VALUES(state_json), actor_json = VALUES(actor_json), metadata_json = VALUES(metadata_json), history_json = VALUES(history_json), updated_at = VALUES(updated_at)`;
+}
+function buildInsertValues(count, dialect) {
+  if (dialect === "postgres") {
+    const placeholders2 = Array.from({ length: count }, (_, index) => `$${String(index + 1)}`).join(", ");
+    return `(${placeholders2})`;
+  }
+  const placeholders = Array.from({ length: count }, () => "?").join(", ");
+  return `(${placeholders})`;
+}
+function buildPlaceholder(position, dialect) {
+  return dialect === "postgres" ? `$${String(position)}` : "?";
+}
+function mapRowToInstance(row) {
+  return {
+    id: row.id,
+    workflowId: row.workflow_id,
+    version: row.version,
+    status: row.status,
+    currentStep: row.current_step ?? void 0,
+    state: parseJson(row.state_json, {}),
+    actor: parseJson(row.actor_json, void 0),
+    metadata: parseJson(row.metadata_json, void 0),
+    history: parseJson(row.history_json, []),
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at)
+  };
+}
+function parseJson(value, fallback) {
+  if (!value) {
+    return fallback;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+
+// src/runtime/workflow/stores/mongoStore.js
+var MongoWorkflowStore = class {
+  constructor(options) {
+    this.options = options;
+    if (this.options.createIndexes) {
+      void this.ensureIndexes();
+    }
+  }
+  async save(instance) {
+    const document = serializeInstance(instance);
+    await this.options.collection.updateOne({ _id: document._id }, {
+      $set: {
+        workflowId: document.workflowId,
+        version: document.version,
+        status: document.status,
+        currentStep: document.currentStep,
+        state: document.state,
+        actor: document.actor,
+        metadata: document.metadata,
+        history: document.history,
+        createdAt: document.createdAt,
+        updatedAt: document.updatedAt
+      }
+    }, { upsert: true });
+  }
+  async load(id) {
+    const doc = await this.options.collection.findOne({ _id: id });
+    if (!doc) {
+      return null;
+    }
+    return deserializeDocument(doc);
+  }
+  async ensureIndexes() {
+    if (!this.options.collection.createIndex) {
+      return;
+    }
+    await Promise.all([
+      this.options.collection.createIndex({ workflowId: 1, updatedAt: -1 }),
+      this.options.collection.createIndex({ status: 1, updatedAt: -1 })
+    ]);
+  }
+};
+function serializeInstance(instance) {
+  return {
+    _id: instance.id,
+    workflowId: instance.workflowId,
+    version: instance.version,
+    status: instance.status,
+    currentStep: instance.currentStep,
+    state: instance.state,
+    actor: instance.actor,
+    metadata: instance.metadata,
+    history: instance.history.map((entry) => ({
+      stepId: entry.stepId,
+      status: entry.status,
+      attempt: entry.attempt,
+      timestamp: entry.timestamp.toISOString(),
+      notes: entry.notes
+    })),
+    createdAt: instance.createdAt.toISOString(),
+    updatedAt: instance.updatedAt.toISOString()
+  };
+}
+function deserializeDocument(document) {
+  return {
+    id: document._id,
+    workflowId: document.workflowId,
+    version: document.version,
+    status: document.status,
+    currentStep: document.currentStep,
+    state: clone(document.state),
+    actor: document.actor ? clone(document.actor) : void 0,
+    metadata: document.metadata ? clone(document.metadata) : void 0,
+    history: Array.isArray(document.history) ? document.history.map((entry) => ({ ...entry, timestamp: new Date(entry.timestamp) })) : [],
+    createdAt: new Date(document.createdAt),
+    updatedAt: new Date(document.updatedAt)
+  };
+}
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/runtime/workflow/schema.js
+function workflowToVisualSchema(definition) {
+  const nodes = Object.values(definition.steps).map((step) => ({
+    id: step.id,
+    label: String(step.metadata?.label ?? step.id),
+    task: step.task,
+    approvals: step.approvals,
+    retry: step.retry,
+    metadata: step.metadata
+  }));
+  const edges = [];
+  for (const step of Object.values(definition.steps)) {
+    if (step.transitions?.success) {
+      edges.push({ id: `${step.id}->${step.transitions.success}#success`, source: step.id, target: step.transitions.success, when: "success" });
+    }
+    if (step.transitions?.failure) {
+      edges.push({ id: `${step.id}->${step.transitions.failure}#failure`, source: step.id, target: step.transitions.failure, when: "failure" });
+    }
+  }
+  return {
+    id: `${definition.name}@${definition.version}`,
+    name: definition.name,
+    version: definition.version,
+    entry: definition.entry,
+    metadata: definition.metadata,
+    nodes,
+    edges
+  };
+}
+function visualSchemaToWorkflow(schema) {
+  const steps = {};
+  for (const node of schema.nodes) {
+    steps[node.id] = {
+      id: node.id,
+      task: node.task,
+      approvals: node.approvals,
+      retry: node.retry,
+      metadata: { ...node.metadata, position: node.position, size: node.size, data: node.data }
+    };
+  }
+  for (const edge of schema.edges) {
+    if (!Object.prototype.hasOwnProperty.call(steps, edge.source)) {
+      continue;
+    }
+    const step = steps[edge.source];
+    if (!step.transitions) {
+      step.transitions = {};
+    }
+    if (edge.when === "failure") {
+      step.transitions.failure = edge.target;
+    } else {
+      step.transitions.success = edge.target;
+    }
+  }
+  return {
+    name: schema.name,
+    version: schema.version,
+    entry: schema.entry,
+    steps,
+    metadata: schema.metadata
+  };
+}
+
+// src/runtime/workflow/adapters/databaseAdapters.js
+function createPrismaProvider(options) {
+  const query = (text, params = []) => options.client.$queryRawUnsafe(text, ...params);
+  const execute = (text, params = []) => {
+    if (options.client.$executeRawUnsafe) {
+      return options.client.$executeRawUnsafe(text, ...params);
+    }
+    return query(text, params);
+  };
+  return new FunctionalDatabaseProvider(options.name ?? "prisma", (operation) => {
+    if (!operation.text) {
+      throw new Error("Prisma provider requires `text` SQL input");
+    }
+    if (operation.type === "query") {
+      return query(operation.text, operation.parameters ?? []);
+    }
+    return execute(operation.text, operation.parameters ?? []);
+  });
+}
+function createDrizzleProvider(options) {
+  return new FunctionalDatabaseProvider(options.name ?? "drizzle", (operation) => {
+    if (!operation.text) {
+      throw new Error("Drizzle provider requires `text` SQL input");
+    }
+    return options.client.execute(operation.text, operation.parameters);
+  });
+}
+function createSupabaseProvider(options) {
+  return new FunctionalDatabaseProvider(options.name ?? "supabase", async (operation) => {
+    if (operation.collection) {
+      const table = options.client.from(operation.collection);
+      if (operation.type === "query") {
+        if (typeof table.select !== "function") {
+          throw new Error("Supabase client is missing select support");
+        }
+        return table.select("*");
+      }
+      if (operation.type === "command") {
+        if (operation.payload && operation.payload.action === "insert") {
+          return table.insert(operation.payload.data);
+        }
+        if (operation.payload && operation.payload.action === "update") {
+          return table.update(operation.payload.data);
+        }
+        if (operation.payload && operation.payload.action === "delete") {
+          return table.delete();
+        }
+      }
+    }
+    if (options.client.rpc && operation.text) {
+      return options.client.rpc(operation.text, operation.payload);
+    }
+    throw new Error("Supabase provider requires `collection` or `text` with rpc support");
+  });
+}
+function createRestDatabaseProvider(options) {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  if (!fetchImpl) {
+    throw new Error("Fetch API is not available. Provide a custom fetch implementation.");
+  }
+  return new FunctionalDatabaseProvider(options.name ?? "rest-db", async (operation) => {
+    const url = new URL(options.endpoint);
+    if (operation.collection) {
+      url.pathname = `${url.pathname.replace(/\/$/, "")}/${operation.collection}`;
+    }
+    const body = JSON.stringify(operation.payload ?? { text: operation.text, parameters: operation.parameters });
+    const response = await fetchImpl(url, {
+      method: "POST",
+      headers: { "content-type": "application/json", ...options.headers ?? {} },
+      body
+    });
+    if (!response.ok) {
+      throw new Error(`REST database adapter failed with status ${String(response.status)}`);
+    }
+    return response.json();
+  });
+}
+
+// src/runtime/workflow/background.js
+var QueueBackgroundRunner = class {
+  constructor(options) {
+    this.options = options;
+  }
+  async dispatch(taskName, payload) {
+    const message = { name: taskName, payload };
+    await this.options.driver.enqueue(message);
+    this.options.metrics?.record("enqueued", { taskName });
+  }
+  async schedule(request, context) {
+    const message = {
+      name: request.taskName,
+      payload: { ...request.payload, workflowId: context.definition.name, stepId: context.step.id },
+      runAt: request.runAt
+    };
+    if (request.runAt && this.options.driver.schedule) {
+      await this.options.driver.schedule(message);
+      this.options.metrics?.record("enqueued", { taskName: request.taskName, scheduled: true });
+      return;
+    }
+    if (request.delayMs && this.options.driver.schedule) {
+      await this.options.driver.schedule({ ...message, runAt: new Date(Date.now() + request.delayMs) });
+      this.options.metrics?.record("enqueued", { taskName: request.taskName, scheduled: true });
+      return;
+    }
+    await this.dispatch(request.taskName, message.payload);
+  }
+};
+function createBullMqDriver(queue) {
+  return {
+    enqueue: (message) => queue.add(message.name, message.payload).then(() => void 0),
+    schedule: (message) => queue.add(message.name, message.payload, {
+      delay: message.runAt ? Math.max(0, message.runAt.getTime() - Date.now()) : 0
+    }).then(() => void 0)
+  };
+}
+function createSqsDriver(client, queueUrl) {
+  return {
+    enqueue: (message) => client.sendMessage({
+      QueueUrl: queueUrl,
+      MessageBody: JSON.stringify(message.payload ?? {}),
+      MessageAttributes: {
+        name: { DataType: "String", StringValue: message.name }
+      }
+    }).then(() => void 0),
+    schedule: (message) => client.sendMessage({
+      QueueUrl: queueUrl,
+      MessageBody: JSON.stringify(message.payload ?? {}),
+      DelaySeconds: message.runAt ? Math.min(900, Math.max(0, Math.floor((message.runAt.getTime() - Date.now()) / 1e3))) : void 0,
+      MessageAttributes: {
+        name: { DataType: "String", StringValue: message.name }
+      }
+    }).then(() => void 0)
+  };
+}
+function createAzureQueueDriver(client) {
+  return {
+    enqueue: (message) => client.sendMessage(JSON.stringify({ name: message.name, payload: message.payload })).then(() => void 0),
+    schedule: (message) => client.sendMessage(JSON.stringify({ name: message.name, payload: message.payload }), {
+      visibilityTimeout: message.runAt ? Math.max(0, Math.floor((message.runAt.getTime() - Date.now()) / 1e3)) : 0
+    }).then(() => void 0)
+  };
+}
+var MetricsConsoleEmitter = class {
+  record(event, metadata) {
+    console.info(`[workflow.queue] ${event}`, metadata);
+  }
+};
+
+// src/runtime/workflow/auth.js
+var PolicyApprovalResolver = class {
+  constructor(engine, fallback) {
+    this.engine = engine;
+    this.fallback = fallback;
+  }
+  async resolve(gate, context) {
+    const decision = await this.engine.evaluate({
+      actor: context.actor,
+      instance: context.instance,
+      step: context.step,
+      action: "approve",
+      metadata: { gateId: gate.id }
+    });
+    if (decision.allow) {
+      return { status: "approved", decidedAt: /* @__PURE__ */ new Date(), decidedBy: context.actor?.id };
+    }
+    if (this.fallback) {
+      return this.fallback.resolve(gate, context);
+    }
+    return { status: "pending", reason: decision.reason };
+  }
+};
+var RuleBasedPolicyEngine = class {
+  constructor(rules, defaultDecision = { allow: true }) {
+    this.rules = rules;
+    this.defaultDecision = defaultDecision;
+  }
+  evaluate(request) {
+    for (const rule of this.rules) {
+      if (rule.match(request)) {
+        return rule.decision(request);
+      }
+    }
+    return this.defaultDecision;
+  }
+};
+function actorFromOidcClaims(claims, mapping = {}) {
+  const typedClaims = claims;
+  return {
+    id: String(claims[mapping.idClaim ?? "sub"] ?? typedClaims.user_id ?? "anonymous"),
+    roles: toStringArray(claims[mapping.rolesClaim ?? "roles"] ?? claims["https://ce/roles"]),
+    scopes: toStringArray(claims[mapping.scopesClaim ?? "scope"]),
+    attributes: mapping.attributeClaims?.reduce((acc, key) => {
+      acc[key] = claims[key];
+      return acc;
+    }, {}),
+    metadata: { provider: mapping.provider ?? "oidc", raw: mapping.includeRaw ? claims : void 0 }
+  };
+}
+function actorFromCognitoClaims(claims) {
+  return actorFromOidcClaims(claims, {
+    provider: "cognito",
+    idClaim: "sub",
+    rolesClaim: "cognito:groups",
+    scopesClaim: "scope"
+  });
+}
+function actorFromAzureAdClaims(claims) {
+  return actorFromOidcClaims(claims, {
+    provider: "azure-ad",
+    idClaim: "oid",
+    rolesClaim: "roles",
+    scopesClaim: "scp"
+  });
+}
+function actorFromAuth0Claims(claims) {
+  return actorFromOidcClaims(claims, {
+    provider: "auth0",
+    idClaim: "sub",
+    rolesClaim: "https://auth0/roles",
+    scopesClaim: "scope"
+  });
+}
+function requireActorRoles(roles) {
+  return (request) => {
+    const actorRoles = request.actor?.roles ?? [];
+    const hasRoles = roles.every((role) => actorRoles.includes(role));
+    if (!hasRoles) {
+      throw new Error(`Actor ${request.actor?.id ?? "unknown"} missing required roles: ${roles.join(", ")}`);
+    }
+  };
+}
+function requireActorScopes(scopes) {
+  return (request) => {
+    const actorScopes = request.actor?.scopes ?? [];
+    const hasScopes = scopes.every((scope) => actorScopes.includes(scope));
+    if (!hasScopes) {
+      throw new Error(`Actor ${request.actor?.id ?? "unknown"} missing required scopes: ${scopes.join(", ")}`);
+    }
+  };
+}
+async function runAuthMiddleware(middleware, request) {
+  for (const fn of middleware) {
+    await fn(request);
+  }
+}
+function createStartWorkflowMiddleware(sequence) {
+  return (request) => {
+    if (request.action !== "start") {
+      return;
+    }
+    return runAuthMiddleware(sequence, request);
+  };
+}
+function createStepMiddleware(sequence) {
+  return (request) => {
+    if (request.action !== "step") {
+      return;
+    }
+    return runAuthMiddleware(sequence, request);
+  };
+}
+function multiStepApprovalResolver(resolvers) {
+  return {
+    async resolve(gate, context) {
+      for (const resolver of resolvers) {
+        const result = await resolver.resolve(gate, context);
+        if (result.status !== "pending") {
+          return result;
+        }
+      }
+      return { status: "pending" };
+    }
+  };
+}
+var ManualOverrideApprovalResolver = class {
+  constructor(overrides) {
+    this.overrides = overrides;
+  }
+  resolve(gate, context) {
+    const key = `${context.instance.id}:${gate.id}`;
+    return this.overrides.get(key) ?? { status: "pending" };
+  }
+};
+function buildPolicyRequest(instance, step, actor) {
+  return {
+    actor,
+    instance,
+    step,
+    action: "step"
+  };
+}
+function toStringArray(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => String(item));
+  }
+  if (typeof value === "string") {
+    return value.split(/[\s,]+/).filter(Boolean);
+  }
+  return [];
+}
+
+exports.ConsoleLogger = ConsoleLogger;
+exports.ConsoleWorkflowLogger = ConsoleWorkflowLogger;
+exports.ConsoleWorkflowTraceSink = ConsoleWorkflowTraceSink;
+exports.DATABASE_TASK = DATABASE_TASK;
+exports.DELAY_TASK = DELAY_TASK;
+exports.DatabaseWorkflowStore = DatabaseWorkflowStore;
+exports.DefaultApprovalResolver = DefaultApprovalResolver;
+exports.DefaultBackgroundRunner = DefaultBackgroundRunner;
+exports.FileWorkflowTraceSink = FileWorkflowTraceSink;
+exports.FunctionalDatabaseProvider = FunctionalDatabaseProvider;
+exports.HTTP_TASK = HTTP_TASK;
+exports.InMemoryDatabaseRegistry = InMemoryDatabaseRegistry;
+exports.InMemorySchedulerService = InMemorySchedulerService;
+exports.InMemoryWorkflowStore = InMemoryWorkflowStore;
+exports.ManualOverrideApprovalResolver = ManualOverrideApprovalResolver;
+exports.MetricsConsoleEmitter = MetricsConsoleEmitter;
+exports.MongoWorkflowStore = MongoWorkflowStore;
+exports.NoopWorkflowTraceSink = NoopWorkflowTraceSink;
+exports.PolicyApprovalResolver = PolicyApprovalResolver;
+exports.QueueBackgroundRunner = QueueBackgroundRunner;
+exports.RecordingWorkflowTraceSink = RecordingWorkflowTraceSink;
+exports.RuleBasedPolicyEngine = RuleBasedPolicyEngine;
+exports.SCHEDULE_TASK = SCHEDULE_TASK;
+exports.SystemTimeService = SystemTimeService;
+exports.WorkflowBuilder = WorkflowBuilder;
+exports.WorkflowRuntime = WorkflowRuntime;
+exports.WorkflowStepBuilder = WorkflowStepBuilder;
+exports.WorkflowTraceExporterSink = WorkflowTraceExporterSink;
+exports.actorFromAuth0Claims = actorFromAuth0Claims;
+exports.actorFromAzureAdClaims = actorFromAzureAdClaims;
+exports.actorFromCognitoClaims = actorFromCognitoClaims;
+exports.actorFromOidcClaims = actorFromOidcClaims;
+exports.buildPolicyRequest = buildPolicyRequest;
+exports.createAzureQueueDriver = createAzureQueueDriver;
+exports.createBullMqDriver = createBullMqDriver;
+exports.createDatabaseTaskHandler = createDatabaseTaskHandler;
+exports.createDefaultTaskMap = createDefaultTaskMap;
+exports.createDelayTaskHandler = createDelayTaskHandler;
+exports.createDrizzleProvider = createDrizzleProvider;
+exports.createFetchHttpExecutor = createFetchHttpExecutor;
+exports.createHttpTaskHandler = createHttpTaskHandler;
+exports.createMongoProvider = createMongoProvider;
+exports.createMySqlProvider = createMySqlProvider;
+exports.createPostgresProvider = createPostgresProvider;
+exports.createPrismaProvider = createPrismaProvider;
+exports.createRestDatabaseProvider = createRestDatabaseProvider;
+exports.createScheduleTaskHandler = createScheduleTaskHandler;
+exports.createSqlDatabaseProvider = createSqlDatabaseProvider;
+exports.createSqliteProvider = createSqliteProvider;
+exports.createSqsDriver = createSqsDriver;
+exports.createStartWorkflowMiddleware = createStartWorkflowMiddleware;
+exports.createStepMiddleware = createStepMiddleware;
+exports.createSupabaseProvider = createSupabaseProvider;
+exports.createWorkflow = createWorkflow;
+exports.databaseTask = databaseTask;
+exports.delayTask = delayTask;
+exports.httpTask = httpTask;
+exports.multiStepApprovalResolver = multiStepApprovalResolver;
+exports.registerDefaultDatabaseProviders = registerDefaultDatabaseProviders;
+exports.requireActorRoles = requireActorRoles;
+exports.requireActorScopes = requireActorScopes;
+exports.runAuthMiddleware = runAuthMiddleware;
+exports.scheduleTask = scheduleTask;
+exports.task = task;
+exports.visualSchemaToWorkflow = visualSchemaToWorkflow;
+exports.workflowFromJson = workflowFromJson;
+exports.workflowToVisualSchema = workflowToVisualSchema;
+//# sourceMappingURL=chunk-FNXIYAET.cjs.map
+//# sourceMappingURL=chunk-FNXIYAET.cjs.map