@abinnovision/nestjs-hatchet 0.3.1 → 0.4.0-beta.7

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.3.2](https://github.com/abinnovision/nestjs-commons/compare/nestjs-hatchet-v0.3.1...nestjs-hatchet-v0.3.2) (2026-01-28)
+
+
+### Bug Fixes
+
+* pass task options through to TaskWorkflowDeclaration ([#89](https://github.com/abinnovision/nestjs-commons/issues/89)) ([e45d19b](https://github.com/abinnovision/nestjs-commons/commit/e45d19bb7812755f3108c99900d897eeab7e24d5))
+
 ## [0.3.1](https://github.com/abinnovision/nestjs-commons/compare/nestjs-hatchet-v0.3.0...nestjs-hatchet-v0.3.1) (2026-01-10)
 
 

package/dist/__fixtures__/test-hosts.d.cts

@@ -0,0 +1,76 @@
+import type { TaskCtx, WorkflowCtx } from "../execution/index.js";
+declare const TestTask_base: {
+    new (): {
+        readonly __task_host_brand: void;
+        readonly __task_host_input: {
+            data: string;
+        };
+        readonly inputSchema: () => import("@standard-schema/spec").StandardSchemaV1<import("@hatchet-dev/typescript-sdk/index.js").JsonObject, {
+            data: string;
+        }> | undefined;
+    };
+};
+/** Standard TaskHost with string data schema */
+export declare class TestTask extends TestTask_base {
+    execute(ctx: TaskCtx<typeof this>): {
+        result: string;
+    };
+}
+declare const NoMethodsTask_base: {
+    new (): {
+        readonly __task_host_brand: void;
+        readonly __task_host_input: unknown;
+        readonly inputSchema: () => import("@standard-schema/spec").StandardSchemaV1<import("@hatchet-dev/typescript-sdk/index.js").JsonObject, unknown> | undefined;
+    };
+};
+/** TaskHost without any decorated methods (invalid) */
+export declare class NoMethodsTask extends NoMethodsTask_base {
+    notDecorated(): {};
+}
+declare const NoSchemaTask_base: {
+    new (): {
+        readonly __task_host_brand: void;
+        readonly __task_host_input: unknown;
+        readonly inputSchema: () => import("@standard-schema/spec").StandardSchemaV1<import("@hatchet-dev/typescript-sdk/index.js").JsonObject, unknown> | undefined;
+    };
+};
+/** TaskHost without input schema */
+export declare class NoSchemaTask extends NoSchemaTask_base {
+    execute(_ctx: TaskCtx<typeof this>): {
+        result: string;
+    };
+}
+declare const TestWorkflow_base: {
+    new (): {
+        readonly __workflow_host_brand: void;
+        readonly __workflow_host_input: {
+            id: string;
+        };
+        readonly inputSchema: () => import("@standard-schema/spec").StandardSchemaV1<import("@hatchet-dev/typescript-sdk/index.js").JsonObject, {
+            id: string;
+        }> | undefined;
+    };
+};
+/** Standard WorkflowHost with two-step DAG */
+export declare class TestWorkflow extends TestWorkflow_base {
+    step1(_ctx: WorkflowCtx<typeof this>): {
+        step: number;
+    };
+    step2(_ctx: WorkflowCtx<typeof this>): {
+        step: number;
+    };
+}
+declare const NoMethodsWorkflow_base: {
+    new (): {
+        readonly __workflow_host_brand: void;
+        readonly __workflow_host_input: unknown;
+        readonly inputSchema: () => import("@standard-schema/spec").StandardSchemaV1<import("@hatchet-dev/typescript-sdk/index.js").JsonObject, unknown> | undefined;
+    };
+};
+/** WorkflowHost without any decorated methods (invalid) */
+export declare class NoMethodsWorkflow extends NoMethodsWorkflow_base {
+    notDecorated(): {};
+}
+/** Sets design:paramtypes metadata for a method (needed in vitest) */
+export declare function setParamTypes(target: object, method: string, types: unknown[]): void;
+export {};

package/dist/__fixtures__/test-hosts.d.ts

@@ -1,11 +1,11 @@
-import type { TaskCtx, WorkflowCtx } from "../execution";
+import type { TaskCtx, WorkflowCtx } from "../execution/index.js";
 declare const TestTask_base: {
     new (): {
         readonly __task_host_brand: void;
         readonly __task_host_input: {
             data: string;
         };
-        readonly inputSchema: () => import("@standard-schema/spec").StandardSchemaV1<import("@hatchet-dev/typescript-sdk").JsonObject, {
+        readonly inputSchema: () => import("@standard-schema/spec").StandardSchemaV1<import("@hatchet-dev/typescript-sdk/index.js").JsonObject, {
             data: string;
         }> | undefined;
     };
@@ -20,7 +20,7 @@ declare const NoMethodsTask_base: {
     new (): {
         readonly __task_host_brand: void;
         readonly __task_host_input: unknown;
-        readonly inputSchema: () => import("@standard-schema/spec").StandardSchemaV1<import("@hatchet-dev/typescript-sdk").JsonObject, unknown> | undefined;
+        readonly inputSchema: () => import("@standard-schema/spec").StandardSchemaV1<import("@hatchet-dev/typescript-sdk/index.js").JsonObject, unknown> | undefined;
     };
 };
 /** TaskHost without any decorated methods (invalid) */
@@ -31,7 +31,7 @@ declare const NoSchemaTask_base: {
     new (): {
         readonly __task_host_brand: void;
         readonly __task_host_input: unknown;
-        readonly inputSchema: () => import("@standard-schema/spec").StandardSchemaV1<import("@hatchet-dev/typescript-sdk").JsonObject, unknown> | undefined;
+        readonly inputSchema: () => import("@standard-schema/spec").StandardSchemaV1<import("@hatchet-dev/typescript-sdk/index.js").JsonObject, unknown> | undefined;
     };
 };
 /** TaskHost without input schema */
@@ -46,7 +46,7 @@ declare const TestWorkflow_base: {
         readonly __workflow_host_input: {
             id: string;
         };
-        readonly inputSchema: () => import("@standard-schema/spec").StandardSchemaV1<import("@hatchet-dev/typescript-sdk").JsonObject, {
+        readonly inputSchema: () => import("@standard-schema/spec").StandardSchemaV1<import("@hatchet-dev/typescript-sdk/index.js").JsonObject, {
             id: string;
         }> | undefined;
     };
@@ -64,7 +64,7 @@ declare const NoMethodsWorkflow_base: {
     new (): {
         readonly __workflow_host_brand: void;
         readonly __workflow_host_input: unknown;
-        readonly inputSchema: () => import("@standard-schema/spec").StandardSchemaV1<import("@hatchet-dev/typescript-sdk").JsonObject, unknown> | undefined;
+        readonly inputSchema: () => import("@standard-schema/spec").StandardSchemaV1<import("@hatchet-dev/typescript-sdk/index.js").JsonObject, unknown> | undefined;
     };
 };
 /** WorkflowHost without any decorated methods (invalid) */

package/dist/abstracts/hosts.cjs

@@ -0,0 +1,58 @@
+//#region src/abstracts/hosts.ts
+/**
+* Marker class for Hatchet workflow host classes.
+*/ var WorkflowHost = class {
+	inputSchema;
+	__workflow_host_brand;
+	__workflow_host_input;
+	/**
+	* Constructor for the WorkflowHost class.
+	*
+	* @param inputSchema
+	* @protected
+	*/ constructor(inputSchema) {
+		this.inputSchema = inputSchema;
+	}
+};
+/**
+* Marker class for Hatchet task host classes.
+*/ var TaskHost = class {
+	inputSchema;
+	__task_host_brand;
+	__task_host_input;
+	/**
+	* Constructor for the TaskHost class.
+	*
+	* @param inputSchema
+	* @protected
+	*/ constructor(inputSchema) {
+		this.inputSchema = inputSchema;
+	}
+};
+/**
+* Creates a new WorkflowHost class with the provided input schema.
+*
+* @param input The input schema.
+*/ function workflowHost(input) {
+	return class WorkflowHostIntermediate extends WorkflowHost {
+		constructor() {
+			super(() => input);
+		}
+	};
+}
+/**
+* Creates a new TaskHost class with the provided input schema.
+*
+* @param input The input schema.
+*/ function taskHost(input) {
+	return class TaskHostIntermediate extends TaskHost {
+		constructor() {
+			super(() => input);
+		}
+	};
+}
+//#endregion
+exports.TaskHost = TaskHost;
+exports.WorkflowHost = WorkflowHost;
+exports.taskHost = taskHost;
+exports.workflowHost = workflowHost;

package/dist/abstracts/hosts.d.cts

@@ -0,0 +1,66 @@
+import type { InputType } from "@hatchet-dev/typescript-sdk";
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+/**
+ * Interface for classes that provide a schema for their input.
+ */
+export interface InputSchemaProvider<T> {
+    /**
+     * Returns the schema for the input of the host.
+     * If undefined, the input is not validated.
+     */
+    inputSchema: () => StandardSchemaV1<InputType, T> | undefined;
+}
+/**
+ * Marker class for Hatchet workflow host classes.
+ */
+export declare abstract class WorkflowHost<I> implements InputSchemaProvider<I> {
+    readonly inputSchema: InputSchemaProvider<I>["inputSchema"];
+    readonly __workflow_host_brand: void;
+    readonly __workflow_host_input: I;
+    /**
+     * Constructor for the WorkflowHost class.
+     *
+     * @param inputSchema
+     * @protected
+     */
+    protected constructor(inputSchema: InputSchemaProvider<I>["inputSchema"]);
+}
+/**
+ * Marker class for Hatchet task host classes.
+ */
+export declare abstract class TaskHost<I> implements InputSchemaProvider<I> {
+    readonly inputSchema: InputSchemaProvider<I>["inputSchema"];
+    readonly __task_host_brand: void;
+    readonly __task_host_input: I;
+    /**
+     * Constructor for the TaskHost class.
+     *
+     * @param inputSchema
+     * @protected
+     */
+    protected constructor(inputSchema: InputSchemaProvider<I>["inputSchema"]);
+}
+/**
+ * Creates a new WorkflowHost class with the provided input schema.
+ *
+ * @param input The input schema.
+ */
+export declare function workflowHost<I>(input?: ReturnType<InputSchemaProvider<I>["inputSchema"]>): {
+    new (): {
+        readonly __workflow_host_brand: void;
+        readonly __workflow_host_input: I;
+        readonly inputSchema: () => StandardSchemaV1<import("@hatchet-dev/typescript-sdk").JsonObject, I> | undefined;
+    };
+};
+/**
+ * Creates a new TaskHost class with the provided input schema.
+ *
+ * @param input The input schema.
+ */
+export declare function taskHost<I>(input?: ReturnType<InputSchemaProvider<I>["inputSchema"]>): {
+    new (): {
+        readonly __task_host_brand: void;
+        readonly __task_host_input: I;
+        readonly inputSchema: () => StandardSchemaV1<import("@hatchet-dev/typescript-sdk").JsonObject, I> | undefined;
+    };
+};

package/dist/abstracts/hosts.d.ts

@@ -45,7 +45,7 @@ export declare abstract class TaskHost<I> implements InputSchemaProvider<I> {
  *
  * @param input The input schema.
  */
-export declare function workflowHost<I>(input?: ReturnType<InputSchemaProvider<I>["inputSchema"]> | undefined): {
+export declare function workflowHost<I>(input?: ReturnType<InputSchemaProvider<I>["inputSchema"]>): {
     new (): {
         readonly __workflow_host_brand: void;
         readonly __workflow_host_input: I;
@@ -57,7 +57,7 @@ export declare function workflowHost<I>(input?: ReturnType<InputSchemaProvider<I
  *
  * @param input The input schema.
  */
-export declare function taskHost<I>(input?: ReturnType<InputSchemaProvider<I>["inputSchema"]> | undefined): {
+export declare function taskHost<I>(input?: ReturnType<InputSchemaProvider<I>["inputSchema"]>): {
     new (): {
         readonly __task_host_brand: void;
         readonly __task_host_input: I;

package/dist/abstracts/hosts.mjs

@@ -0,0 +1,55 @@
+//#region src/abstracts/hosts.ts
+/**
+* Marker class for Hatchet workflow host classes.
+*/ var WorkflowHost = class {
+	inputSchema;
+	__workflow_host_brand;
+	__workflow_host_input;
+	/**
+	* Constructor for the WorkflowHost class.
+	*
+	* @param inputSchema
+	* @protected
+	*/ constructor(inputSchema) {
+		this.inputSchema = inputSchema;
+	}
+};
+/**
+* Marker class for Hatchet task host classes.
+*/ var TaskHost = class {
+	inputSchema;
+	__task_host_brand;
+	__task_host_input;
+	/**
+	* Constructor for the TaskHost class.
+	*
+	* @param inputSchema
+	* @protected
+	*/ constructor(inputSchema) {
+		this.inputSchema = inputSchema;
+	}
+};
+/**
+* Creates a new WorkflowHost class with the provided input schema.
+*
+* @param input The input schema.
+*/ function workflowHost(input) {
+	return class WorkflowHostIntermediate extends WorkflowHost {
+		constructor() {
+			super(() => input);
+		}
+	};
+}
+/**
+* Creates a new TaskHost class with the provided input schema.
+*
+* @param input The input schema.
+*/ function taskHost(input) {
+	return class TaskHostIntermediate extends TaskHost {
+		constructor() {
+			super(() => input);
+		}
+	};
+}
+//#endregion
+export { TaskHost, WorkflowHost, taskHost, workflowHost };

package/dist/abstracts/index.d.cts

@@ -0,0 +1 @@
+export * from "./hosts.js";

package/dist/abstracts/index.d.ts

@@ -1 +1 @@
-export * from "./hosts";
+export * from "./hosts.js";

package/dist/client/client.cjs

@@ -0,0 +1,80 @@
+const require_event_definition = require("../events/event-definition.cjs");
+const require_adapter_factory = require("../execution/host-run/adapter-factory.cjs");
+let _nestjs_common = require("@nestjs/common");
+let _hatchet_dev_typescript_sdk = require("@hatchet-dev/typescript-sdk");
+//#region src/client/client.ts
+function _ts_decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+var Client = class {
+	client;
+	run;
+	constructor(client) {
+		this.client = client;
+		this.run = require_adapter_factory.createHostRunForAdmin(client);
+	}
+	/**
+	* Access to the underlying HatchetClient SDK.
+	* Use for advanced features not wrapped by this library.
+	*/ get sdk() {
+		return this.client;
+	}
+	/**
+	* Emit a single event.
+	*
+	* @param event The event definition to emit.
+	* @param input The event payload (must match the event's schema).
+	* @param options Optional emit configuration.
+	* @returns The emitted event.
+	*
+	* @example
+	* ```typescript
+	* await client.emit(UserCreatedEvent, { userId: "123", email: "user@example.com" });
+	* ```
+	*/ async emit(event, input, options) {
+		return await this.client.events.push(event.name, {
+			...input,
+			[require_event_definition.EVENT_MARKER]: event.name
+		}, options);
+	}
+	/**
+	* Emit multiple events of the same type.
+	*
+	* @param event The event definition to emit.
+	* @param inputs Array of event payloads.
+	* @param options Optional emit configuration.
+	* @returns Array of emitted events.
+	*
+	* @example
+	* ```typescript
+	* await client.emitBulk(OrderPlacedEvent, [
+	*   { orderId: "1", userId: "123", total: 100 },
+	*   { orderId: "2", userId: "456", total: 200 },
+	* ]);
+	* ```
+	*/ async emitBulk(event, inputs, options) {
+		if (inputs.length === 0) return [];
+		return (await this.client.events.bulkPush(event.name, inputs.map((input) => ({ payload: {
+			...input,
+			[require_event_definition.EVENT_MARKER]: event.name
+		} })), options)).events;
+	}
+};
+Client = _ts_decorate([
+	(0, _nestjs_common.Injectable)(),
+	_ts_metadata("design:type", Function),
+	_ts_metadata("design:paramtypes", [typeof _hatchet_dev_typescript_sdk.HatchetClient === "undefined" ? Object : _hatchet_dev_typescript_sdk.HatchetClient])
+], Client);
+//#endregion
+Object.defineProperty(exports, "Client", {
+	enumerable: true,
+	get: function() {
+		return Client;
+	}
+});

package/dist/client/{client.service.d.ts → client.d.cts}

@@ -1,20 +1,9 @@
 import { HatchetClient } from "@hatchet-dev/typescript-sdk";
-import { type AnyEventDefinition, type EventInput } from "../events";
-import { HostRunFn } from "../interaction";
-import type { Event } from "@hatchet-dev/typescript-sdk/protoc/events";
-/**
- * Options for emitting events.
- */
-export interface EmitOptions {
-    /**
-     * Additional metadata to attach to the event.
-     */
-    additionalMetadata?: Record<string, string>;
-    /**
-     * Namespace for the event.
-     */
-    namespace?: string;
-}
+import type { AnyEventDefinition, EventInput } from "../events/index.js";
+import type { HostRunFn } from "../execution/index.js";
+type EventClient = HatchetClient["events"];
+type EventEmitOptions = Parameters<EventClient["push"]>[2];
+type Event = Awaited<ReturnType<EventClient["push"]>>;
 export declare class Client {
     private readonly client;
     readonly run: HostRunFn;
@@ -37,7 +26,7 @@ export declare class Client {
      * await client.emit(UserCreatedEvent, { userId: "123", email: "user@example.com" });
      * ```
      */
-    emit<E extends AnyEventDefinition>(event: E, input: EventInput<E>, options?: EmitOptions): Promise<Event>;
+    emit<E extends AnyEventDefinition>(event: E, input: EventInput<E>, options?: EventEmitOptions): Promise<Event>;
     /**
      * Emit multiple events of the same type.
      *
@@ -54,5 +43,6 @@ export declare class Client {
      * ]);
      * ```
      */
-    emitBulk<E extends AnyEventDefinition>(event: E, inputs: EventInput<E>[], options?: EmitOptions): Promise<Event[]>;
+    emitBulk<E extends AnyEventDefinition>(event: E, inputs: EventInput<E>[], options?: EventEmitOptions): Promise<Event[]>;
 }
+export {};

package/dist/client/client.d.ts

@@ -1,12 +1,9 @@
 import { HatchetClient } from "@hatchet-dev/typescript-sdk";
-import { PushEventOptions } from "@hatchet-dev/typescript-sdk/clients/event/event-client";
-import type { AnyEventDefinition, EventInput } from "../events";
-import type { HostRunFn } from "../execution";
-import type { Event } from "@hatchet-dev/typescript-sdk/protoc/events";
-/**
- * Options for emitting events.
- */
-type EmitOptions = PushEventOptions;
+import type { AnyEventDefinition, EventInput } from "../events/index.js";
+import type { HostRunFn } from "../execution/index.js";
+type EventClient = HatchetClient["events"];
+type EventEmitOptions = Parameters<EventClient["push"]>[2];
+type Event = Awaited<ReturnType<EventClient["push"]>>;
 export declare class Client {
     private readonly client;
     readonly run: HostRunFn;
@@ -29,7 +26,7 @@ export declare class Client {
      * await client.emit(UserCreatedEvent, { userId: "123", email: "user@example.com" });
      * ```
      */
-    emit<E extends AnyEventDefinition>(event: E, input: EventInput<E>, options?: EmitOptions): Promise<Event>;
+    emit<E extends AnyEventDefinition>(event: E, input: EventInput<E>, options?: EventEmitOptions): Promise<Event>;
     /**
      * Emit multiple events of the same type.
      *
@@ -46,6 +43,6 @@ export declare class Client {
      * ]);
      * ```
      */
-    emitBulk<E extends AnyEventDefinition>(event: E, inputs: EventInput<E>[], options?: EmitOptions): Promise<Event[]>;
+    emitBulk<E extends AnyEventDefinition>(event: E, inputs: EventInput<E>[], options?: EventEmitOptions): Promise<Event[]>;
 }
 export {};

package/dist/client/client.mjs

@@ -0,0 +1,75 @@
+import { EVENT_MARKER } from "../events/event-definition.mjs";
+import { createHostRunForAdmin } from "../execution/host-run/adapter-factory.mjs";
+import { Injectable } from "@nestjs/common";
+import { HatchetClient } from "@hatchet-dev/typescript-sdk";
+//#region src/client/client.ts
+function _ts_decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+var Client = class {
+	client;
+	run;
+	constructor(client) {
+		this.client = client;
+		this.run = createHostRunForAdmin(client);
+	}
+	/**
+	* Access to the underlying HatchetClient SDK.
+	* Use for advanced features not wrapped by this library.
+	*/ get sdk() {
+		return this.client;
+	}
+	/**
+	* Emit a single event.
+	*
+	* @param event The event definition to emit.
+	* @param input The event payload (must match the event's schema).
+	* @param options Optional emit configuration.
+	* @returns The emitted event.
+	*
+	* @example
+	* ```typescript
+	* await client.emit(UserCreatedEvent, { userId: "123", email: "user@example.com" });
+	* ```
+	*/ async emit(event, input, options) {
+		return await this.client.events.push(event.name, {
+			...input,
+			[EVENT_MARKER]: event.name
+		}, options);
+	}
+	/**
+	* Emit multiple events of the same type.
+	*
+	* @param event The event definition to emit.
+	* @param inputs Array of event payloads.
+	* @param options Optional emit configuration.
+	* @returns Array of emitted events.
+	*
+	* @example
+	* ```typescript
+	* await client.emitBulk(OrderPlacedEvent, [
+	*   { orderId: "1", userId: "123", total: 100 },
+	*   { orderId: "2", userId: "456", total: 200 },
+	* ]);
+	* ```
+	*/ async emitBulk(event, inputs, options) {
+		if (inputs.length === 0) return [];
+		return (await this.client.events.bulkPush(event.name, inputs.map((input) => ({ payload: {
+			...input,
+			[EVENT_MARKER]: event.name
+		} })), options)).events;
+	}
+};
+Client = _ts_decorate([
+	Injectable(),
+	_ts_metadata("design:type", Function),
+	_ts_metadata("design:paramtypes", [typeof HatchetClient === "undefined" ? Object : HatchetClient])
+], Client);
+//#endregion
+export { Client };

package/dist/client/index.cjs

@@ -0,0 +1 @@
+require("./client.cjs");

package/dist/client/index.d.cts

@@ -0,0 +1 @@
+export * from "./client.js";

package/dist/client/index.d.ts

@@ -1 +1 @@
-export * from "./client";
+export * from "./client.js";

package/dist/client/index.mjs

@@ -0,0 +1,2 @@
+import "./client.mjs";
+export {};

package/dist/events/event-definition.cjs

@@ -0,0 +1,61 @@
+//#region src/events/event-definition.ts
+/**
+* Marker embedded in event payload to identify an event type.
+* Used by isCtx() type guard to determine which event triggered the workflow.
+*/ const EVENT_MARKER = "__event_name";
+/**
+* Type-safe event definition.
+* Use with Client.emit() to publish events.
+*
+* @template TName The literal string type of the event name.
+* @template TSchema The StandardSchema type for input validation.
+*/ var EventDefinition = class {
+	name;
+	schema;
+	/**
+	* Phantom types for input/output inference.
+	* Do not access at runtime - will throw.
+	*/ __types;
+	constructor(name, schema) {
+		this.name = name;
+		this.schema = schema;
+		Object.defineProperty(this, "__types", { get() {
+			throw new Error("__types is a phantom property for type inference only");
+		} });
+	}
+	/**
+	* Type guard: checks if the context was triggered by this event.
+	* Validates the input against the event schema and throws if malformed.
+	*
+	* @param ctx The context to check (TaskCtx, WorkflowCtx, HelperCtx, or SDK Context).
+	* @returns True if the context input contains the event marker matching this event.
+	* @throws Error if the event marker matches but the payload fails schema validation.
+	*/ isCtx(ctx) {
+		if (typeof ctx.input !== "object" || ctx.input === null || !("__event_name" in ctx.input) || ctx.input["__event_name"] !== this.name) return false;
+		const result = this.schema["~standard"].validate(ctx.input);
+		if (result instanceof Promise) throw new Error(`Event '${this.name}' schema validation must be synchronous. Use a sync schema.`);
+		if ("issues" in result && result.issues) throw new Error(`Event '${this.name}' payload is malformed: ${JSON.stringify(result.issues)}`);
+		return true;
+	}
+};
+/**
+* Factory function to create a type-safe event definition.
+*
+* @param name The event name (e.g., "user:created").
+* @param schema A StandardSchema-compatible schema (e.g., Zod schema).
+* @returns A new EventDefinition instance.
+*
+* @example
+* ```typescript
+* import { z } from "zod";
+*
+* const UserCreatedEvent = defineEvent("user:created", z.object({
+*   userId: z.string(),
+*   email: z.string().email(),
+* }));
+* ```
+*/ const defineEvent = (name, schema) => new EventDefinition(name, schema);
+//#endregion
+exports.EVENT_MARKER = EVENT_MARKER;
+exports.EventDefinition = EventDefinition;
+exports.defineEvent = defineEvent;