effect-inngest 0.1.3 → 0.3.0-beta.0

package/dist/Event.d.ts

@@ -0,0 +1,43 @@
+import { Schema } from "effect";
+import { MakeOptions } from "effect/Schema";
+
+//#region src/Event.d.ts
+declare namespace Event_d_exports {
+  export { EventData, EventDefinition, EventEnvelope, EventType, isEventSchema, make };
+}
+declare const TypeId: unique symbol;
+interface EventOptions extends MakeOptions {
+  readonly id?: string;
+  readonly ts?: number;
+  readonly v?: string;
+}
+interface EventEnvelope<Name extends string, Data> extends EventOptions {
+  readonly name: Name;
+  readonly data: Data;
+}
+type EventFields<Name extends string, DataSchema extends Schema.Top> = {
+  readonly name: Schema.tag<Name>;
+  readonly data: DataSchema;
+  readonly id: Schema.optional<Schema.String>;
+  readonly ts: Schema.optional<Schema.Number>;
+  readonly v: Schema.optional<Schema.String>;
+};
+type EventStruct<Name extends string, DataSchema extends Schema.Top> = Schema.Struct<EventFields<Name, DataSchema>>;
+type EventConstructor<Name extends string, DataSchema extends Schema.Top> = abstract new (_: never) => EventEnvelope<Name, Schema.Schema.Type<DataSchema>>;
+type PayloadConstructor<Name extends string, DataSchema extends Schema.Top> = {
+  bivariance(data: Schema.Schema.Type<DataSchema>, options?: EventOptions): EventEnvelope<Name, Schema.Schema.Type<DataSchema>>;
+}["bivariance"];
+type EventDefinition<Name extends string = string, DataSchema extends Schema.Top = Schema.Top> = EventConstructor<Name, DataSchema> & Omit<Schema.Opaque<EventEnvelope<Name, Schema.Schema.Type<DataSchema>>, EventStruct<Name, DataSchema>, {}>, "make" | "~type.make"> & {
+  readonly [TypeId]: typeof TypeId;
+  readonly identifier: Name;
+  readonly schema: DataSchema;
+  readonly make: unknown extends Schema.Schema.Type<DataSchema> ? (data: never, options?: EventOptions) => EventEnvelope<Name, unknown> : PayloadConstructor<Name, DataSchema>;
+  readonly "~type.make": EventEnvelope<Name, Schema.Schema.Type<DataSchema>>;
+};
+type EventData<Event extends EventDefinition> = Event extends EventDefinition<any, infer S> ? Schema.Schema.Type<S> : never;
+type EventType<Event extends EventDefinition> = Event extends EventDefinition<infer Name, infer S> ? EventEnvelope<Name, Schema.Schema.Type<S>> : never;
+declare function make<const Name extends string>(name: Name): EventDefinition<Name, Schema.Struct<{}>>;
+declare function make<const Name extends string, const DataSchema extends Schema.Top>(name: Name, schema: DataSchema): EventDefinition<Name, DataSchema>;
+declare const isEventSchema: (value: unknown) => value is EventDefinition;
+//#endregion
+export { EventDefinition, EventType, Event_d_exports };

package/dist/Event.js

@@ -0,0 +1,46 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { Predicate, Schema } from "effect";
+//#region src/Event.ts
+/**
+* Public event definitions.
+*
+* Inngest events are protocol-shaped: `{ name, data, id?, ts?, v? }`.
+* The event name is the discriminator; user payload lives under `data`.
+*
+* @since 0.1.0
+*/
+var Event_exports = /* @__PURE__ */ __exportAll({
+	isEventSchema: () => isEventSchema,
+	make: () => make
+});
+const TypeId = Symbol.for("effect-inngest/Event");
+function make(name, schema = Schema.Struct({})) {
+	const fields = {
+		name: Schema.tag(name),
+		data: schema,
+		id: Schema.optional(Schema.String),
+		ts: Schema.optional(Schema.Number),
+		v: Schema.optional(Schema.String)
+	};
+	const Event = Schema.Opaque()(Schema.Struct(fields));
+	class InngestEvent {
+		static [TypeId] = TypeId;
+		static identifier = name;
+		static schema = schema;
+		static make(data, options) {
+			const { id, ts, v } = options ?? {};
+			return {
+				name,
+				data,
+				id,
+				ts,
+				v
+			};
+		}
+	}
+	Object.setPrototypeOf(InngestEvent, Event);
+	return InngestEvent;
+}
+const isEventSchema = (value) => Schema.isSchema(value) && Predicate.hasProperty(value, TypeId);
+//#endregion
+export { Event_exports, make };

package/dist/Events.d.ts

@@ -1,110 +1,82 @@
-import * as Schema from "effect/Schema";
+import { EventDefinition } from "./Event.js";
+import { Schema } from "effect";
 
 //#region src/Events.d.ts
 declare namespace Events_d_exports {
   export { FunctionCancelled, FunctionFailed, FunctionFinished, FunctionFinishedError, FunctionFinishedSuccess, FunctionInvoked, JsonError, ScheduledTimer };
 }
-declare const JsonError_base: Schema.Class<JsonError, {
-  name: typeof Schema.String;
-  message: typeof Schema.String;
-  stack: Schema.optional<typeof Schema.String>;
-  cause: Schema.optional<typeof Schema.Unknown>;
-}, Schema.Struct.Encoded<{
-  name: typeof Schema.String;
-  message: typeof Schema.String;
-  stack: Schema.optional<typeof Schema.String>;
-  cause: Schema.optional<typeof Schema.Unknown>;
-}>, never, {
-  readonly name: string;
-} & {
-  readonly message: string;
-} & {
-  readonly stack?: string | undefined;
-} & {
-  readonly cause?: unknown;
-}, {}, {}>;
+declare const JsonError_base: Schema.Class<JsonError, Schema.Struct<{
+  readonly name: Schema.String;
+  readonly message: Schema.String;
+  readonly stack: Schema.optional<Schema.String>;
+  readonly cause: Schema.optional<Schema.Unknown>;
+}>, {}>;
 /**
  * Error structure used in internal Inngest events.
  * @since 0.1.0
  */
 declare class JsonError extends JsonError_base {}
-declare const FunctionFailed_base: Schema.TaggedClass<FunctionFailed, "inngest/function.failed", {
-  readonly _tag: Schema.tag<"inngest/function.failed">;
-} & {
-  function_id: typeof Schema.String;
-  run_id: typeof Schema.String;
-  error: typeof JsonError;
-  event: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
-}>;
 /**
  * Sent when a function fails after exhausting all retries.
  * Trigger on this to handle failures (e.g., alerting, cleanup).
  * @since 0.1.0
  */
-declare class FunctionFailed extends FunctionFailed_base {}
-declare const FunctionFinishedError_base: Schema.TaggedClass<FunctionFinishedError, "inngest/function.finished", {
-  readonly _tag: Schema.tag<"inngest/function.finished">;
-} & {
-  function_id: typeof Schema.String;
-  run_id: typeof Schema.String;
-  correlation_id: Schema.optional<typeof Schema.String>;
-  error: typeof JsonError;
-}>;
-/**
- * Sent when a function finishes with an error.
- * @since 0.1.0
- */
-declare class FunctionFinishedError extends FunctionFinishedError_base {}
-declare const FunctionFinishedSuccess_base: Schema.TaggedClass<FunctionFinishedSuccess, "inngest/function.finished", {
-  readonly _tag: Schema.tag<"inngest/function.finished">;
-} & {
-  function_id: typeof Schema.String;
-  run_id: typeof Schema.String;
-  correlation_id: Schema.optional<typeof Schema.String>;
-  result: typeof Schema.Unknown;
-}>;
-/**
- * Sent when a function finishes successfully.
- * @since 0.1.0
- */
-declare class FunctionFinishedSuccess extends FunctionFinishedSuccess_base {}
+declare const FunctionFailed: EventDefinition<"inngest/function.failed", Schema.Struct<{
+  readonly function_id: Schema.String;
+  readonly run_id: Schema.String;
+  readonly error: typeof JsonError;
+  readonly event: Schema.$Record<Schema.String, Schema.Unknown>;
+}>>;
+declare const FunctionFinishedError: EventDefinition<"inngest/function.finished", Schema.Struct<{
+  readonly function_id: Schema.String;
+  readonly run_id: Schema.String;
+  readonly correlation_id: Schema.optional<Schema.String>;
+  readonly error: typeof JsonError;
+}>>;
+declare const FunctionFinishedSuccess: EventDefinition<"inngest/function.finished", Schema.Struct<{
+  readonly function_id: Schema.String;
+  readonly run_id: Schema.String;
+  readonly correlation_id: Schema.optional<Schema.String>;
+  readonly result: Schema.Unknown;
+}>>;
 /**
  * Union of both FunctionFinished variants.
  * @since 0.1.0
  */
-declare const FunctionFinished: Schema.Union<[typeof FunctionFinishedError, typeof FunctionFinishedSuccess]>;
+declare const FunctionFinished: EventDefinition<"inngest/function.finished", Schema.Union<readonly [Schema.Struct<{
+  readonly function_id: Schema.String;
+  readonly run_id: Schema.String;
+  readonly correlation_id: Schema.optional<Schema.String>;
+  readonly error: typeof JsonError;
+}>, Schema.Struct<{
+  readonly function_id: Schema.String;
+  readonly run_id: Schema.String;
+  readonly correlation_id: Schema.optional<Schema.String>;
+  readonly result: Schema.Unknown;
+}>]>>;
 type FunctionFinished = typeof FunctionFinished.Type;
-declare const FunctionCancelled_base: Schema.TaggedClass<FunctionCancelled, "inngest/function.cancelled", {
-  readonly _tag: Schema.tag<"inngest/function.cancelled">;
-} & {
-  function_id: typeof Schema.String;
-  run_id: typeof Schema.String;
-  correlation_id: Schema.optional<typeof Schema.String>;
-}>;
 /**
  * Sent when a function is cancelled.
  * @since 0.1.0
  */
-declare class FunctionCancelled extends FunctionCancelled_base {}
-declare const FunctionInvoked_base: Schema.TaggedClass<FunctionInvoked, "inngest/function.invoked", {
-  readonly _tag: Schema.tag<"inngest/function.invoked">;
-} & {
-  data: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
-}>;
+declare const FunctionCancelled: EventDefinition<"inngest/function.cancelled", Schema.Struct<{
+  readonly function_id: Schema.String;
+  readonly run_id: Schema.String;
+  readonly correlation_id: Schema.optional<Schema.String>;
+}>>;
 /**
  * Sent when a function is invoked via step.invoke().
  * @since 0.1.0
  */
-declare class FunctionInvoked extends FunctionInvoked_base {}
-declare const ScheduledTimer_base: Schema.TaggedClass<ScheduledTimer, "inngest/scheduled.timer", {
-  readonly _tag: Schema.tag<"inngest/scheduled.timer">;
-} & {
-  cron: typeof Schema.String;
-}>;
+declare const FunctionInvoked: EventDefinition<"inngest/function.invoked", Schema.StructWithRest<Schema.Struct<{
+  readonly _inngest: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>;
 /**
  * Sent when a cron trigger fires.
  * @since 0.1.0
  */
-declare class ScheduledTimer extends ScheduledTimer_base {}
+declare const ScheduledTimer: EventDefinition<"inngest/scheduled.timer", Schema.Struct<{
+  readonly cron: Schema.String;
+}>>;
 //#endregion
 export { Events_d_exports, FunctionCancelled, FunctionFailed, FunctionFinished, FunctionFinishedError, FunctionFinishedSuccess, FunctionInvoked, JsonError, ScheduledTimer };

package/dist/Events.js

@@ -1,6 +1,6 @@
-import { __exportAll } from "./_virtual/rolldown_runtime.js";
-import * as Schema from "effect/Schema";
-
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { make } from "./Event.js";
+import { Schema } from "effect";
 //#region src/Events.ts
 /**
 * Internal Inngest events that the platform sends automatically.
@@ -32,62 +32,57 @@ var JsonError = class extends Schema.Class("JsonError")({
 * Trigger on this to handle failures (e.g., alerting, cleanup).
 * @since 0.1.0
 */
-var FunctionFailed = class extends Schema.TaggedClass()("inngest/function.failed", {
+const FunctionFailed = make("inngest/function.failed", Schema.Struct({
 	function_id: Schema.String,
 	run_id: Schema.String,
 	error: JsonError,
-	event: Schema.Record({
-		key: Schema.String,
-		value: Schema.Unknown
-	})
-}) {};
+	event: Schema.Record(Schema.String, Schema.Unknown)
+}));
 /**
 * Sent when a function finishes with an error.
 * @since 0.1.0
 */
-var FunctionFinishedError = class extends Schema.TaggedClass()("inngest/function.finished", {
+const FunctionFinishedErrorData = Schema.Struct({
 	function_id: Schema.String,
 	run_id: Schema.String,
 	correlation_id: Schema.optional(Schema.String),
 	error: JsonError
-}) {};
+});
+const FunctionFinishedError = make("inngest/function.finished", FunctionFinishedErrorData);
 /**
 * Sent when a function finishes successfully.
 * @since 0.1.0
 */
-var FunctionFinishedSuccess = class extends Schema.TaggedClass()("inngest/function.finished", {
+const FunctionFinishedSuccessData = Schema.Struct({
 	function_id: Schema.String,
 	run_id: Schema.String,
 	correlation_id: Schema.optional(Schema.String),
 	result: Schema.Unknown
-}) {};
+});
+const FunctionFinishedSuccess = make("inngest/function.finished", FunctionFinishedSuccessData);
 /**
 * Union of both FunctionFinished variants.
 * @since 0.1.0
 */
-const FunctionFinished = Schema.Union(FunctionFinishedError, FunctionFinishedSuccess);
+const FunctionFinished = make("inngest/function.finished", Schema.Union([FunctionFinishedErrorData, FunctionFinishedSuccessData]));
 /**
 * Sent when a function is cancelled.
 * @since 0.1.0
 */
-var FunctionCancelled = class extends Schema.TaggedClass()("inngest/function.cancelled", {
+const FunctionCancelled = make("inngest/function.cancelled", Schema.Struct({
 	function_id: Schema.String,
 	run_id: Schema.String,
 	correlation_id: Schema.optional(Schema.String)
-}) {};
+}));
 /**
 * Sent when a function is invoked via step.invoke().
 * @since 0.1.0
 */
-var FunctionInvoked = class extends Schema.TaggedClass()("inngest/function.invoked", { data: Schema.optional(Schema.Record({
-	key: Schema.String,
-	value: Schema.Unknown
-})) }) {};
+const FunctionInvoked = make("inngest/function.invoked", Schema.StructWithRest(Schema.Struct({ _inngest: Schema.optionalKey(Schema.Record(Schema.String, Schema.Unknown)) }), [Schema.Record(Schema.String, Schema.Unknown)]));
 /**
 * Sent when a cron trigger fires.
 * @since 0.1.0
 */
-var ScheduledTimer = class extends Schema.TaggedClass()("inngest/scheduled.timer", { cron: Schema.String }) {};
-
+const ScheduledTimer = make("inngest/scheduled.timer", Schema.Struct({ cron: Schema.String }));
 //#endregion
-export { Events_exports, FunctionCancelled, FunctionFailed, FunctionFinished, FunctionFinishedError, FunctionFinishedSuccess, FunctionInvoked, JsonError, ScheduledTimer };
+export { Events_exports, FunctionCancelled, FunctionFailed, FunctionFinished, FunctionFinishedError, FunctionFinishedSuccess, FunctionInvoked, JsonError, ScheduledTimer };

package/dist/Function.d.ts

@@ -1,8 +1,11 @@
+import { CheckpointingOption } from "./internal/checkpoint/Config.js";
+import { EventDefinition, EventType } from "./Event.js";
 import { Duration, Schema } from "effect";
+import { Pipeable } from "effect/Pipeable";
 
 //#region src/Function.d.ts
 declare namespace Function_d_exports {
-  export { CronTrigger, EventTrigger, FunctionOptions, InngestFunction, Trigger, TriggerInput, TypeId, make };
+  export { CheckpointingOption, CronTrigger, EventTrigger, FunctionOptions, InngestFunction, Trigger, TriggerInput, TypeId, make };
 }
 /**
  * @since 0.1.0
@@ -14,9 +17,7 @@ declare const TypeId: unique symbol;
  * @category type ids
  */
 type TypeId = typeof TypeId;
-type EventSchema = Schema.Schema.Any & {
-  readonly _tag: string;
-};
+type EventSchema = EventDefinition;
 /**
  * An event-based trigger configuration.
  *
@@ -88,7 +89,7 @@ interface RateLimitOption {
   /**
    * The period of time to allow the function to run `limit` times.
    */
-  readonly period: Duration.DurationInput;
+  readonly period: Duration.Input;
 }
 interface ThrottleOption {
   /**
@@ -106,7 +107,7 @@ interface ThrottleOption {
    * The period of time for the rate limit. Run starts are evenly spaced through
    * the given period. The minimum granularity is 1 second.
    */
-  readonly period: Duration.DurationInput;
+  readonly period: Duration.Input;
   /**
    * The number of runs allowed to start in the given window in a single burst.
    * A burst > 1 bypasses smoothing for the burst and allows many runs to start
@@ -122,13 +123,13 @@ interface DebounceOption {
   /**
    * The period of time to delay after receiving the last trigger to run the function.
    */
-  readonly period: Duration.DurationInput;
+  readonly period: Duration.Input;
   /**
    * The maximum time that a debounce can be extended before running.
    * If events are continually received within the given period, a function
    * will always run after the given timeout period.
    */
-  readonly timeout?: Duration.DurationInput;
+  readonly timeout?: Duration.Input;
 }
 interface BatchEventsOption {
   /**
@@ -140,7 +141,7 @@ interface BatchEventsOption {
    * If timeout is reached, the function will be invoked with a batch
    * even if it's not filled up to `maxSize`.
    */
-  readonly timeout: Duration.DurationInput;
+  readonly timeout: Duration.Input;
   /**
    * An optional key to use for batching.
    */
@@ -169,13 +170,13 @@ interface TimeoutsOption {
    * This is, essentially, the amount of time that a function sits in the
    * queue before starting.
    */
-  readonly start?: Duration.DurationInput;
+  readonly start?: Duration.Input;
   /**
    * Finish represents the time between a function starting and the function
    * finishing. If a function takes longer than this time to finish, the
    * function is marked as cancelled.
    */
-  readonly finish?: Duration.DurationInput;
+  readonly finish?: Duration.Input;
 }
 interface SingletonOption {
   /**
@@ -208,7 +209,7 @@ interface CancellationOption {
    * specified, cancellation triggers are valid for up to a year or until the
    * function ends.
    */
-  readonly timeout?: Duration.DurationInput;
+  readonly timeout?: Duration.Input;
 }
 type Retries = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20;
 /**
@@ -278,6 +279,19 @@ interface FunctionOptions {
    * Batch events configuration.
    */
   readonly batchEvents?: BatchEventsOption;
+  /**
+   * Whether to use checkpointing for executions of this function. Overrides
+   * the client-level `checkpointing` setting.
+   *
+   * - `false` disables checkpointing for this function.
+   * - `true` enables checkpointing with safe defaults
+   *   (`bufferedSteps: 1`, `maxInterval: 0`, `maxRuntime: 10s`).
+   * - An object lets you tune `bufferedSteps`, `maxInterval`, `maxRuntime`.
+   *
+   * Defaults to inheriting from the client-level setting (which itself
+   * defaults to enabled with safe defaults).
+   */
+  readonly checkpointing?: CheckpointingOption;
 }
 interface RegistrationConfig {
   readonly appId: string;
@@ -329,7 +343,11 @@ interface FunctionRegistration {
     readonly period: string;
     readonly timeout?: string;
   };
-  readonly concurrency?: ReadonlyArray<{
+  readonly concurrency?: {
+    readonly key?: string;
+    readonly limit: number;
+    readonly scope?: string;
+  } | ReadonlyArray<{
     readonly key?: string;
     readonly limit: number;
     readonly scope?: string;
@@ -347,6 +365,11 @@ interface FunctionRegistration {
     readonly key?: string;
   };
   readonly idempotency?: string;
+  readonly checkpoint?: {
+    readonly batch_steps: number;
+    readonly batch_interval: string;
+    readonly max_runtime: string;
+  };
 }
 /**
  * An Inngest function definition.
@@ -354,7 +377,7 @@ interface FunctionRegistration {
  * @since 0.1.0
  * @category models
  */
-interface InngestFunction<Tag extends string, Triggers extends Trigger, Success extends Schema.Schema.Any, Options extends FunctionOptions = FunctionOptions> {
+interface InngestFunction<Tag extends string, Triggers extends Trigger, Success extends Schema.Codec<unknown, unknown, never, never>, Options extends FunctionOptions = FunctionOptions> extends Pipeable {
   readonly [TypeId]: TypeId;
   readonly _tag: Tag;
   readonly key: string;
@@ -368,12 +391,16 @@ interface InngestFunction<Tag extends string, Triggers extends Trigger, Success
  * @category models
  */
 declare namespace InngestFunction {
-  type Any = InngestFunction<string, Trigger, Schema.Schema.Any, FunctionOptions>;
+  type Any = InngestFunction<string, Trigger, Schema.Codec<any, any, never, never>, FunctionOptions>;
   type Tag<F> = F extends InngestFunction<infer T, any, any, any> ? T : never;
   type Triggers<F> = F extends InngestFunction<any, infer T, any, any> ? T : never;
   type Events<F> = F extends InngestFunction<any, infer T, any, any> ? (T extends EventTrigger<infer E> ? E : never) : never;
-  type EventType<F> = F extends InngestFunction<any, infer T, any, any> ? T extends EventTrigger<infer E> ? Schema.Schema.Type<E> : never : never;
-  type Success<F> = F extends InngestFunction<any, any, infer S, any> ? Schema.Schema.Type<S> : never;
+  type EventPayload<F> = EventType<Events<F>>;
+  type EventType<F> = Options<F> extends {
+    readonly batchEvents: BatchEventsOption;
+  } ? ReadonlyArray<EventPayload<F>> : EventPayload<F>;
+  type SuccessSchema<F> = F extends InngestFunction<any, any, infer S, any> ? S : never;
+  type Success<F> = Schema.Schema.Type<SuccessSchema<F>>;
   type Options<F> = F extends InngestFunction<any, any, any, infer O> ? O : never;
 }
 type NormalizeTriggers<T extends TriggerInput> = T extends ReadonlyArray<Trigger> ? T[number] : T;
@@ -410,9 +437,9 @@ type NormalizeTriggers<T extends TriggerInput> = T extends ReadonlyArray<Trigger
  * })
  * ```
  */
-declare function make<const Tag extends string, T extends TriggerInput, S extends Schema.Schema.Any, const O extends FunctionOptions = {}>(tag: Tag, options: {
+declare function make<const Tag extends string, T extends TriggerInput, S extends Schema.Codec<unknown, unknown, never, never>, const O extends FunctionOptions = {}>(tag: Tag, options: {
   readonly trigger: T;
   readonly success: S;
 } & O): InngestFunction<Tag, NormalizeTriggers<T>, S, O>;
 //#endregion
-export { CronTrigger, EventTrigger, FunctionOptions, Function_d_exports, InngestFunction, Trigger, TriggerInput, TypeId, make };
+export { type CheckpointingOption, CronTrigger, EventTrigger, FunctionOptions, Function_d_exports, InngestFunction, Trigger, TriggerInput, TypeId, make };

package/dist/Function.js

@@ -1,7 +1,8 @@
-import { __exportAll } from "./_virtual/rolldown_runtime.js";
-import { timeStr } from "./internal/helpers.js";
-import { Array, Duration, Predicate, Schema } from "effect";
-
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { InngestDuration } from "./internal/wire/Duration.js";
+import { resolveConfig, toRegistration } from "./internal/checkpoint/Config.js";
+import { Array, Duration, Option, Predicate, Schema } from "effect";
+import { pipeArguments } from "effect/Pipeable";
 //#region src/Function.ts
 /**
 * @since 0.1.0
@@ -16,12 +17,16 @@ var Function_exports = /* @__PURE__ */ __exportAll({
 */
 const TypeId = Symbol.for("effect-inngest/Function");
 const isEventTrigger = (t) => Predicate.hasProperty(t, "event");
+const encodeDuration = (input) => Schema.encodeSync(InngestDuration)(Duration.fromInputUnsafe(input));
 const Proto = {
 	[TypeId]: TypeId,
+	pipe() {
+		return pipeArguments(this, arguments);
+	},
 	toRegistration(config) {
 		const triggers = [];
 		for (const t of this.triggers) if (isEventTrigger(t)) triggers.push({
-			event: t.event._tag,
+			event: t.event.identifier,
 			expression: t.if
 		});
 		else triggers.push({ cron: t.cron });
@@ -29,33 +34,35 @@ const Proto = {
 		const cancel = opts.cancelOn?.map((c) => ({
 			event: c.event,
 			if: c.if,
-			timeout: c.timeout ? timeStr(c.timeout) : void 0
+			timeout: c.timeout ? encodeDuration(c.timeout) : void 0
 		}));
 		const timeouts = opts.timeouts?.start || opts.timeouts?.finish ? {
-			start: opts.timeouts.start ? timeStr(opts.timeouts.start) : void 0,
-			finish: opts.timeouts.finish ? timeStr(opts.timeouts.finish) : void 0
+			start: opts.timeouts.start ? encodeDuration(opts.timeouts.start) : void 0,
+			finish: opts.timeouts.finish ? encodeDuration(opts.timeouts.finish) : void 0
 		} : void 0;
 		const rateLimit = opts.rateLimit ? {
 			key: opts.rateLimit.key,
 			limit: opts.rateLimit.limit,
-			period: timeStr(opts.rateLimit.period)
+			period: encodeDuration(opts.rateLimit.period)
 		} : void 0;
 		const throttle = opts.throttle ? {
 			key: opts.throttle.key,
 			limit: opts.throttle.limit,
-			period: timeStr(opts.throttle.period),
+			period: encodeDuration(opts.throttle.period),
 			burst: opts.throttle.burst
 		} : void 0;
 		const debounce = opts.debounce ? {
 			key: opts.debounce.key,
-			period: timeStr(opts.debounce.period),
-			timeout: opts.debounce.timeout ? timeStr(opts.debounce.timeout) : void 0
+			period: encodeDuration(opts.debounce.period),
+			timeout: opts.debounce.timeout ? encodeDuration(opts.debounce.timeout) : void 0
 		} : void 0;
-		const concurrency = opts.concurrency != null ? typeof opts.concurrency === "number" ? [{ limit: opts.concurrency }] : Array.ensure(opts.concurrency).map((c) => ({
-			key: c.key,
-			limit: c.limit,
-			scope: c.scope
-		})) : void 0;
+		const serializeConcurrencyOption = (option) => ({
+			key: option.key,
+			limit: option.limit,
+			scope: option.scope
+		});
+		const isConcurrencyOptions = (value) => Array.isArray(value);
+		const concurrency = Option.fromNullishOr(opts.concurrency).pipe(Option.map((value) => Predicate.isNumber(value) ? { limit: value } : isConcurrencyOptions(value) ? Array.map(value, serializeConcurrencyOption) : serializeConcurrencyOption(value)), Option.getOrUndefined);
 		const priority = opts.priority ? { run: opts.priority.run } : void 0;
 		const singleton = opts.singleton ? {
 			key: opts.singleton.key,
@@ -63,10 +70,13 @@ const Proto = {
 		} : void 0;
 		const batchEvents = opts.batchEvents ? {
 			maxSize: opts.batchEvents.maxSize,
-			timeout: timeStr(opts.batchEvents.timeout),
+			timeout: encodeDuration(opts.batchEvents.timeout),
 			key: opts.batchEvents.key
 		} : void 0;
 		const idempotency = opts.idempotency;
+		const retries = Predicate.isNotUndefined(opts.retries) ? { attempts: opts.retries } : void 0;
+		const resolvedCheckpoint = Predicate.isNotUndefined(opts.checkpointing) ? resolveConfig(opts.checkpointing, void 0) : void 0;
+		const checkpoint = resolvedCheckpoint ? toRegistration(resolvedCheckpoint) : void 0;
 		const fnId = `${config.appId}-${this._tag}`;
 		const stepUrl = new URL(config.url);
 		stepUrl.searchParams.set("fnId", fnId);
@@ -82,7 +92,7 @@ const Proto = {
 					type: "http",
 					url: stepUrl.href
 				},
-				retries: { attempts: opts.retries ?? 3 }
+				retries
 			} },
 			cancel: cancel && cancel.length > 0 ? cancel : void 0,
 			timeouts,
@@ -93,7 +103,8 @@ const Proto = {
 			priority,
 			singleton,
 			batchEvents,
-			idempotency
+			idempotency,
+			checkpoint
 		};
 	}
 };
@@ -139,6 +150,5 @@ function make(tag, options) {
 	fn.options = options;
 	return fn;
 }
-
 //#endregion
-export { Function_exports, TypeId, make };
+export { Function_exports, TypeId, make };