@classytic/streamline 1.0.0 → 2.0.0

package/dist/index.mjs

@@ -1,6 +1,7 @@
-import { a as StepNotFoundError, c as WorkflowNotFoundError, i as MaxRetriesExceededError, n as ErrorCode, o as StepTimeoutError, r as InvalidStateError, s as WorkflowError, t as DataCorruptionError } from "./errors-BqunvWPz.mjs";
-import { A as isValidStepTransition, C as RUN_STATUS_VALUES, D as isStepStatus, E as isRunStatus, M as logger, O as isTerminalState, S as shouldSkipStep, T as deriveRunStatus, _ as COMPUTED, a as singleTenantPlugin, b as createCondition, c as RUN_STATUS, d as WorkflowRunModel, f as WorkflowCache, g as validateRetryConfig, h as validateId, i as workflowRunRepository, j as WaitSignal, k as isValidRunTransition, l as STEP_STATUS, m as hookRegistry, n as isStreamlineContainer, o as tenantFilterPlugin, p as WorkflowEngine, r as createWorkflowRepository, s as CommonQueries, t as createContainer, u as WorkflowQueryBuilder, v as SCHEDULING, w as STEP_STATUS_VALUES, x as isConditionalStep, y as conditions } from "./container-BzpIMrrj.mjs";
-import { n as globalEventBus, t as WorkflowEventBus } from "./events-B5aTz7kD.mjs";
+import { a as logger, r as WaitSignal, t as GotoSignal } from "./context-DMkusPr_.mjs";
+import { A as isValidRunTransition, C as shouldSkipStep, D as isRunStatus, E as deriveRunStatus, O as isStepStatus, S as isConditionalStep, T as STEP_STATUS_VALUES, _ as validateRetryConfig, a as singleTenantPlugin, b as conditions, c as RUN_STATUS, d as WorkflowRunModel, f as WorkflowCache, g as validateId, h as workflowRegistry, i as workflowRunRepository, j as isValidStepTransition, k as isTerminalState, l as STEP_STATUS, m as hookRegistry, n as isStreamlineContainer, o as tenantFilterPlugin, p as WorkflowEngine, r as createWorkflowRepository, s as CommonQueries, t as createContainer, u as WorkflowQueryBuilder, v as COMPUTED, w as RUN_STATUS_VALUES, x as createCondition, y as SCHEDULING } from "./container-BSxj_Or4.mjs";
+import { a as StepNotFoundError, c as WorkflowNotFoundError, i as MaxRetriesExceededError, n as ErrorCode, o as StepTimeoutError, r as InvalidStateError, s as WorkflowError, t as DataCorruptionError } from "./errors-Ba7ZziTN.mjs";
+import { n as globalEventBus, t as WorkflowEventBus } from "./events-CpesEn3I.mjs";
 import { randomBytes, randomUUID } from "node:crypto";
 import mongoose, { Schema } from "mongoose";
 import semver from "semver";
@@ -39,6 +40,30 @@ import { DateTime } from "luxon";
 * ```
 */
 const toName = (id) => id.replace(/-/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").replace(/\b\w/g, (c) => c.toUpperCase());
+/** Type guard: is the step entry a StepConfig object (vs a plain handler fn)? */
+function isStepConfig(step) {
+	return typeof step === "object" && step !== null && "handler" in step;
+}
+/**
+* Convert a StepConfig entry into a Step definition.
+*
+* The Step interface uses `(context: unknown)` for conditions because steps are
+* stored in WorkflowDefinition (untyped at runtime). This is the one boundary
+* where typed `TContext` callbacks widen to `unknown` — safe because the executor
+* always passes the correct TContext at call sites.
+*/
+function toStepDef(stepId, entry) {
+	const step = {
+		id: stepId,
+		name: toName(stepId)
+	};
+	if (entry.timeout !== void 0) step.timeout = entry.timeout;
+	if (entry.retries !== void 0) step.retries = entry.retries;
+	if (entry.condition) step.condition = entry.condition;
+	if (entry.skipIf) step.skipIf = entry.skipIf;
+	if (entry.runIf) step.runIf = entry.runIf;
+	return step;
+}
 /**
 * Create a workflow with inline step handlers
 *
@@ -57,12 +82,17 @@ const toName = (id) => id.replace(/-/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2")
 * await orderProcess.start({ id: '123', email: 'user@example.com' });
 * ```
 *
-* @example Custom container for testing
+* @example Per-step configuration
 * ```typescript
-* const container = createContainer();
-* const workflow = createWorkflow('test-workflow', {
-*   steps: { ... },
-*   container
+* const pipeline = createWorkflow('ci-pipeline', {
+*   steps: {
+*     clone: { handler: async (ctx) => { ... }, timeout: 120_000 },
+*     build: { handler: async (ctx) => { ... }, retries: 5 },
+*     deploy: {
+*       handler: async (ctx) => { ... },
+*       skipIf: (ctx) => !ctx.shouldDeploy,
+*     },
+*   },
 * });
 * ```
 */
@@ -71,19 +101,34 @@ function createWorkflow(id, config) {
 	const stepIds = Object.keys(config.steps);
 	if (stepIds.length === 0) throw new Error("Workflow must have at least one step");
 	if (config.defaults) validateRetryConfig(config.defaults.retries, config.defaults.timeout);
+	const handlers = {};
+	const compensationHandlers = {};
+	const steps = stepIds.map((stepId) => {
+		const entry = config.steps[stepId];
+		if (isStepConfig(entry)) {
+			handlers[stepId] = entry.handler;
+			if (entry.onCompensate) compensationHandlers[stepId] = entry.onCompensate;
+			return toStepDef(stepId, entry);
+		}
+		handlers[stepId] = entry;
+		return {
+			id: stepId,
+			name: toName(stepId)
+		};
+	});
 	const definition = {
 		id,
 		name: toName(id),
 		version: config.version ?? "1.0.0",
-		steps: stepIds.map((stepId) => ({
-			id: stepId,
-			name: toName(stepId)
-		})),
+		steps,
 		createContext: config.context ?? ((input) => input),
 		defaults: config.defaults
 	};
 	const container = config.container ?? createContainer();
-	const engine = new WorkflowEngine(definition, config.steps, container, { ...config.autoExecute !== void 0 && { autoExecute: config.autoExecute } });
+	const engine = new WorkflowEngine(definition, handlers, container, {
+		...config.autoExecute !== void 0 && { autoExecute: config.autoExecute },
+		compensationHandlers: Object.keys(compensationHandlers).length > 0 ? compensationHandlers : void 0
+	});
 	const waitFor = async (runId, options = {}) => {
 		const { pollInterval = 1e3, timeout } = options;
 		const startTime = Date.now();
@@ -114,17 +159,20 @@ function createWorkflow(id, config) {
 //#endregion
 //#region src/features/hooks.ts
 /**
-* Hooks & Webhooks
+* Hooks & Webhooks — Durable external resume
 *
-* Inspired by Vercel's workflow hooks - pause execution and wait for external input.
+* Pause execution and wait for external input (webhooks, approvals, etc.).
+* Durable across process restarts and multi-worker deployments:
+* - Fast path: in-memory hookRegistry (same-process)
+* - Fallback: MongoDB lookup + repository-based resume (cross-process)
 *
 * @example
 * ```typescript
 * const approval = createWorkflow('doc-approval', {
 *   steps: {
 *     request: async (ctx) => {
-*       await sendApprovalEmail(ctx.input.docId);
-*       return createHook(ctx, 'approval');
+*       const hook = createHook(ctx, 'approval');
+*       return ctx.wait(hook.token, { hookToken: hook.token });
 *     },
 *     process: async (ctx) => {
 *       const { approved } = ctx.getOutput<{ approved: boolean }>('request');
@@ -133,32 +181,18 @@ function createWorkflow(id, config) {
 *   },
 * });
 *
-* // Resume hook from API route
+* // Resume from API route — works across workers/restarts
 * const result = await resumeHook(token, { approved: true });
-* console.log(result.run); // The resumed workflow run
 * ```
 */
 /**
 * Create a hook that pauses workflow until external input.
 * The token includes a crypto-random suffix for security.
 *
-* IMPORTANT: Pass the returned token to ctx.wait() to enable token validation:
-* ```typescript
-* const hook = createHook(ctx, 'approval');
-* return ctx.wait(hook.token, { hookToken: hook.token }); // Token stored for validation
-* ```
-*
 * @example
 * ```typescript
-* // In step handler
-* async function waitForApproval(ctx) {
-*   const hook = createHook(ctx, 'waiting-for-approval');
-*   console.log('Resume with token:', hook.token);
-*   return ctx.wait(hook.token, { hookToken: hook.token }); // Token validated on resume
-* }
-*
-* // From API route
-* await resumeHook('token-123', { approved: true });
+* const hook = createHook(ctx, 'waiting-for-approval');
+* return ctx.wait(hook.token, { hookToken: hook.token });
 * ```
 */
 function createHook(ctx, reason, options) {
@@ -172,14 +206,14 @@ function createHook(ctx, reason, options) {
 /**
 * Resume a paused workflow by hook token.
 *
-* Security: If the workflow was paused with a hookToken in waitingFor.data,
-* this function validates the token before resuming.
+* **Durable**: Works across process restarts and multi-worker deployments.
+* - Fast path: Uses in-memory hookRegistry if the engine is in this process.
+* - Fallback: Looks up the workflow in MongoDB and resumes via atomic DB operations.
 *
-* Multi-worker support: Falls back to DB lookup if engine not in local registry.
+* Security: Validates the token against the stored hookToken if present.
 *
 * @example
 * ```typescript
-* // API route handler
 * app.post('/hooks/:token', async (req, res) => {
 *   const result = await resumeHook(req.params.token, req.body);
 *   res.json({ success: true, runId: result.runId, status: result.run.status });
@@ -190,12 +224,15 @@ async function resumeHook(token, payload) {
 	const [runId] = token.split(":");
 	if (!runId) throw new Error(`Invalid hook token: ${token}`);
 	const engine = hookRegistry.getEngine(runId);
-	if (!engine) throw new Error(`No engine registered for workflow ${runId}. Ensure the workflow was started with createWorkflow() and the engine is still running. For multi-worker deployments, ensure all workers use shared state or implement a custom resume endpoint.`);
+	if (engine) return resumeViaEngine(engine, runId, token, payload);
+	return resumeViaDb(runId, token, payload);
+}
+/** Resume using the in-memory engine reference (fast path) */
+async function resumeViaEngine(engine, runId, token, payload) {
 	const run = await engine.container.repository.getById(runId);
 	if (!run) throw new Error(`Workflow not found for token: ${token}`);
 	if (run.status !== "waiting") throw new Error(`Workflow ${runId} is not waiting (status: ${run.status})`);
-	const storedToken = (run.steps.find((s) => s.status === "waiting")?.waitingFor?.data)?.hookToken;
-	if (storedToken && storedToken !== token) throw new Error(`Invalid hook token for workflow ${runId}`);
+	validateHookToken(run, token);
 	const resumedRun = await engine.resume(runId, payload);
 	return {
 		runId: run._id,
@@ -203,11 +240,71 @@ async function resumeHook(token, payload) {
 	};
 }
 /**
+* Resume using direct MongoDB operations (durable fallback).
+* Works when the engine that started the workflow is gone (restart, different worker).
+*/
+async function resumeViaDb(runId, token, payload) {
+	const run = await workflowRunRepository.getById(runId);
+	if (!run) throw new Error(`Workflow not found for token: ${token}`);
+	if (run.status !== "waiting") throw new Error(`Workflow ${runId} is not waiting (status: ${run.status})`);
+	validateHookToken(run, token);
+	const stepIndex = run.steps.findIndex((s) => s.status === "waiting");
+	if (stepIndex === -1) throw new Error(`No waiting step found in workflow ${runId}`);
+	const now = /* @__PURE__ */ new Date();
+	const stepId = run.steps[stepIndex].stepId;
+	if ((await workflowRunRepository.updateOne({
+		_id: runId,
+		status: "waiting",
+		[`steps.${stepIndex}.status`]: "waiting"
+	}, {
+		$set: {
+			status: "running",
+			updatedAt: now,
+			lastHeartbeat: now,
+			[`steps.${stepIndex}.status`]: "done",
+			[`steps.${stepIndex}.endedAt`]: now,
+			[`steps.${stepIndex}.output`]: payload
+		},
+		$unset: { [`steps.${stepIndex}.waitingFor`]: "" }
+	}, { bypassTenant: true })).modifiedCount === 0) throw new Error(`Failed to resume workflow ${runId} — already resumed or cancelled`);
+	const allStepIds = run.steps.map((s) => s.stepId);
+	const currentIndex = allStepIds.indexOf(stepId);
+	const nextStepId = currentIndex < allStepIds.length - 1 ? allStepIds[currentIndex + 1] : null;
+	if (nextStepId) await workflowRunRepository.updateOne({ _id: runId }, { $set: {
+		currentStepId: nextStepId,
+		updatedAt: /* @__PURE__ */ new Date()
+	} }, { bypassTenant: true });
+	else await workflowRunRepository.updateOne({ _id: runId }, { $set: {
+		status: "done",
+		currentStepId: null,
+		endedAt: /* @__PURE__ */ new Date(),
+		updatedAt: /* @__PURE__ */ new Date(),
+		output: payload
+	} }, { bypassTenant: true });
+	const engine = workflowRegistry.getEngine(run.workflowId);
+	if (engine) {
+		engine.container.cache.delete(runId);
+		if (nextStepId) setImmediate(() => {
+			engine.execute(runId).catch(() => {});
+		});
+	} else if (nextStepId) await workflowRunRepository.updateOne({ _id: runId }, { $set: { lastHeartbeat: /* @__PURE__ */ new Date(0) } }, { bypassTenant: true });
+	const updated = await workflowRunRepository.getById(runId);
+	if (!updated) throw new Error(`Workflow ${runId} disappeared after resume`);
+	return {
+		runId,
+		run: updated
+	};
+}
+/** Validate hook token against stored token (security) */
+function validateHookToken(run, token) {
+	const storedToken = (run.steps.find((s) => s.status === "waiting")?.waitingFor?.data)?.hookToken;
+	if (storedToken && storedToken !== token) throw new Error(`Invalid hook token for workflow ${run._id}`);
+}
+/**
 * Generate a deterministic token for idempotent hooks
 *
 * @example
 * ```typescript
-* // Slack bot - same channel always gets same token
 * const token = hookToken('slack', channelId);
 * const hook = createHook(ctx, 'slack-message', { token });
 * ```
@@ -1099,4 +1196,4 @@ async function executeParallel(tasks, options = {}) {
 }
 
 //#endregion
-export { COMPUTED, CommonQueries, DataCorruptionError, ErrorCode, InvalidStateError, MaxRetriesExceededError, RUN_STATUS, RUN_STATUS_VALUES, STEP_STATUS, STEP_STATUS_VALUES, SchedulingService, StepNotFoundError, StepTimeoutError, TimezoneHandler, WaitSignal, WorkflowCache, WorkflowDefinitionModel, WorkflowEngine, WorkflowError, WorkflowEventBus, WorkflowNotFoundError, WorkflowQueryBuilder, WorkflowRunModel, canRewindTo, conditions, createCondition, createContainer, createHook, createWorkflow, createWorkflowRepository, deriveRunStatus, executeParallel, getExecutionPath, getStepTimeline, getStepUIStates, getWaitingInfo, getWorkflowProgress, globalEventBus, hookRegistry, hookToken, isConditionalStep, isRunStatus, isStepStatus, isStreamlineContainer, isTerminalState, isValidRunTransition, isValidStepTransition, resumeHook, shouldSkipStep, singleTenantPlugin, tenantFilterPlugin, timezoneHandler, workflowDefinitionRepository, workflowRunRepository };
+export { COMPUTED, CommonQueries, DataCorruptionError, ErrorCode, GotoSignal, InvalidStateError, MaxRetriesExceededError, RUN_STATUS, RUN_STATUS_VALUES, STEP_STATUS, STEP_STATUS_VALUES, SchedulingService, StepNotFoundError, StepTimeoutError, TimezoneHandler, WaitSignal, WorkflowCache, WorkflowDefinitionModel, WorkflowEngine, WorkflowError, WorkflowEventBus, WorkflowNotFoundError, WorkflowQueryBuilder, WorkflowRunModel, canRewindTo, conditions, createCondition, createContainer, createHook, createWorkflow, createWorkflowRepository, deriveRunStatus, executeParallel, getExecutionPath, getStepTimeline, getStepUIStates, getWaitingInfo, getWorkflowProgress, globalEventBus, hookRegistry, hookToken, isConditionalStep, isRunStatus, isStepStatus, isStreamlineContainer, isTerminalState, isValidRunTransition, isValidStepTransition, resumeHook, shouldSkipStep, singleTenantPlugin, tenantFilterPlugin, timezoneHandler, workflowDefinitionRepository, workflowRegistry, workflowRunRepository };

package/dist/integrations/fastify.d.mts

@@ -1,4 +1,4 @@
-import { _ as WorkflowHandlers, h as WorkflowDefinition } from "../types-DG85_LzF.mjs";
+import { _ as WorkflowHandlers, h as WorkflowDefinition } from "../types-DjgzSrNY.mjs";
 
 //#region src/integrations/fastify.d.ts
 interface WorkflowPluginOptions {

package/dist/integrations/fastify.mjs

@@ -1,4 +1,4 @@
-import { p as WorkflowEngine, t as createContainer } from "../container-BzpIMrrj.mjs";
+import { p as WorkflowEngine, t as createContainer } from "../container-BSxj_Or4.mjs";
 
 //#region src/integrations/fastify.ts
 async function workflowPlugin(fastify, options) {

package/dist/rolldown-runtime-95iHPtFO.mjs

@@ -0,0 +1,18 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+export { __exportAll as t };

package/dist/telemetry/index.d.mts

@@ -1,4 +1,4 @@
-import { t as WorkflowEventBus } from "../events-C0sZINZq.mjs";
+import { l as WorkflowEventBus } from "../events-DC0ddZZ9.mjs";
 import { Tracer } from "@opentelemetry/api";
 
 //#region src/telemetry/index.d.ts

package/dist/telemetry/index.mjs

@@ -1,4 +1,4 @@
-import { n as globalEventBus } from "../events-B5aTz7kD.mjs";
+import { n as globalEventBus } from "../events-CpesEn3I.mjs";
 
 //#region src/telemetry/index.ts
 const spans = /* @__PURE__ */ new Map();

package/dist/{types-DG85_LzF.d.mts → types-DjgzSrNY.d.mts}

@@ -74,7 +74,7 @@ interface WorkflowError {
   stack?: string;
 }
 interface WaitingFor {
-  type: 'human' | 'webhook' | 'timer' | 'event';
+  type: 'human' | 'webhook' | 'timer' | 'event' | 'childWorkflow';
   reason: string;
   resumeAt?: Date;
   eventName?: string;
@@ -225,6 +225,116 @@ interface StepContext<TContext = Record<string, unknown>> {
   heartbeat: () => Promise<void>;
   emit: (eventName: string, data: unknown) => void;
   log: (message: string, data?: unknown) => void;
+  /**
+   * Save a checkpoint for crash-safe batch processing (durable loop).
+   *
+   * On crash recovery, `getCheckpoint()` returns the last saved value,
+   * so the step resumes from where it left off instead of restarting.
+   *
+   * @example
+   * ```typescript
+   * async function processBatches(ctx) {
+   *   const batches = splitIntoBatches(ctx.input.data, 100);
+   *   const lastProcessed = ctx.getCheckpoint<number>() ?? -1;
+   *
+   *   for (let i = lastProcessed + 1; i < batches.length; i++) {
+   *     await processBatch(batches[i]);
+   *     await ctx.checkpoint(i);   // Survives crashes
+   *     await ctx.heartbeat();
+   *   }
+   *   return { processed: batches.length };
+   * }
+   * ```
+   */
+  checkpoint: (value: unknown) => Promise<void>;
+  /**
+   * Read the last checkpoint value saved by `checkpoint()`.
+   * Returns `undefined` on first execution (no prior crash).
+   */
+  getCheckpoint: <T = unknown>() => T | undefined;
+  /**
+   * Start a child workflow and durably wait for it to complete.
+   *
+   * The parent step enters a waiting state. When the child reaches a terminal
+   * state (done/failed/cancelled), the parent automatically resumes with the
+   * child's output as this step's output.
+   *
+   * Durable: survives process restarts. The scheduler picks up the parent
+   * when the child completes via the `childRunId` stored in waitingFor.
+   *
+   * @param workflowId - The child workflow's registered ID
+   * @param input - Input data for the child workflow
+   * @returns The child workflow's output (after it completes)
+   *
+   * @example
+   * ```typescript
+   * const pipeline = createWorkflow('pipeline', {
+   *   steps: {
+   *     validate: async (ctx) => { ... },
+   *     runSubPipeline: async (ctx) => {
+   *       return ctx.startChildWorkflow('sub-pipeline', { data: ctx.context.data });
+   *       // Parent waits here. Resumes when child completes.
+   *     },
+   *     finalize: async (ctx) => {
+   *       const childResult = ctx.getOutput('runSubPipeline');
+   *       return { done: true, childResult };
+   *     },
+   *   },
+   * });
+   * ```
+   */
+  startChildWorkflow: (workflowId: string, input: unknown) => Promise<never>;
+  /**
+   * Jump to a different step, breaking out of the linear sequence.
+   *
+   * Use for conditional branching, error recovery paths, or skip-ahead logic.
+   * The target step must exist in the workflow definition.
+   *
+   * @param stepId - The step ID to jump to
+   *
+   * @example
+   * ```typescript
+   * const workflow = createWorkflow('order', {
+   *   steps: {
+   *     validate: async (ctx) => {
+   *       if (!ctx.context.paymentValid) {
+   *         return ctx.goto('handleFailure'); // Skip to failure handler
+   *       }
+   *       return { valid: true };
+   *     },
+   *     process: async (ctx) => { ... },
+   *     handleFailure: async (ctx) => { ... },
+   *   },
+   * });
+   * ```
+   */
+  goto: (stepId: string) => Promise<never>;
+  /**
+   * Durable scatter/gather — execute tasks in parallel with crash recovery.
+   *
+   * Unlike `executeParallel()` (in-memory only), `scatter()` persists each
+   * task's completion to MongoDB via checkpoints. If the process crashes
+   * mid-scatter, only incomplete tasks re-execute on recovery.
+   *
+   * @param tasks - Named tasks to execute. Keys become result keys.
+   * @param options - Concurrency limit (default: Infinity)
+   * @returns Record of results keyed by task name
+   *
+   * @example
+   * ```typescript
+   * const results = await ctx.scatter({
+   *   user: () => fetchUser(ctx.context.userId),
+   *   orders: () => fetchOrders(ctx.context.userId),
+   *   recommendations: () => getRecommendations(ctx.context.userId),
+   * });
+   *
+   * // results.user, results.orders, results.recommendations
+   * // If crash after 'user' completes, only 'orders' and 'recommendations' re-run.
+   * ```
+   */
+  scatter: <T extends Record<string, () => Promise<unknown>>>(tasks: T, options?: {
+    concurrency?: number;
+  }) => Promise<{ [K in keyof T]: Awaited<ReturnType<T[K]>> }>;
 }
 type StepHandler<TOutput = unknown, TContext = Record<string, unknown>> = (ctx: StepContext<TContext>) => Promise<TOutput>;
 type WorkflowHandlers<TContext = Record<string, unknown>> = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@classytic/streamline",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "MongoDB-native durable workflow orchestration engine. Like Temporal but simpler - supports sleep, wait, retry, parallel execution, human-in-the-loop, and crash recovery. Perfect for payment gateways, approval flows, and scheduled tasks.",
   "type": "module",
   "sideEffects": false,
@@ -19,7 +19,8 @@
     "./telemetry": {
       "types": "./dist/telemetry/index.d.mts",
       "default": "./dist/telemetry/index.mjs"
-    }
+    },
+    "./package.json": "./package.json"
   },
   "files": [
     "dist",
@@ -73,9 +74,9 @@
     "url": "https://github.com/classytic/streamline/issues"
   },
   "peerDependencies": {
-    "@classytic/mongokit": "^3.2.3",
-    "mongoose": "^9.0.0",
-    "@opentelemetry/api": ">=1.0.0"
+    "@classytic/mongokit": ">=3.3.2",
+    "@opentelemetry/api": ">=1.0.0",
+    "mongoose": "^9.0.0"
   },
   "peerDependenciesMeta": {
     "@opentelemetry/api": {
@@ -83,17 +84,17 @@
     }
   },
   "devDependencies": {
-    "@classytic/mongokit": "^3.2.3",
+    "@classytic/mongokit": ">=3.3.2",
     "@opentelemetry/api": "^1.9.0",
     "@types/luxon": "^3.7.1",
-    "luxon": "^3.7.2",
-    "semver": "^7.7.3",
     "@types/node": "^22.0.0",
     "@types/semver": "^7.7.1",
     "@vitest/coverage-v8": "^3.0.0",
+    "luxon": "^3.7.2",
     "mongodb-memory-server": "^11.0.1",
-    "mongoose": "^9.0.0",
-    "tsdown": "^0.20.3",
+    "mongoose": "^9.3.3",
+    "semver": "^7.7.3",
+    "tsdown": "^0.21.7",
     "typescript": "^5.0.0",
     "vitest": "^3.0.0"
   },