@temporal-contract/contract 0.0.5 → 0.0.7

package/dist/index.cjs

@@ -2,6 +2,217 @@ let zod = require("zod");
 
 //#region src/builder.ts
 /**
+* Define a Temporal activity with type-safe input and output schemas.
+*
+* Activities are the building blocks of Temporal workflows that execute business logic
+* and interact with external services. This function preserves TypeScript types while
+* providing a consistent structure for activity definitions.
+*
+* @template TActivity - The activity definition type with input/output schemas
+* @param definition - The activity definition containing input and output schemas
+* @returns The same definition with preserved types for type inference
+*
+* @example
+* ```typescript
+* import { defineActivity } from '@temporal-contract/contract';
+* import { z } from 'zod';
+*
+* export const sendEmail = defineActivity({
+*   input: z.object({
+*     to: z.string().email(),
+*     subject: z.string(),
+*     body: z.string(),
+*   }),
+*   output: z.object({
+*     messageId: z.string(),
+*     sentAt: z.date(),
+*   }),
+* });
+* ```
+*/
+function defineActivity(definition) {
+	return definition;
+}
+/**
+* Define a Temporal signal with type-safe input schema.
+*
+* Signals are asynchronous messages sent to running workflows to update their state
+* or trigger certain behaviors. This function ensures type safety for signal payloads.
+*
+* @template TSignal - The signal definition type with input schema
+* @param definition - The signal definition containing input schema
+* @returns The same definition with preserved types for type inference
+*
+* @example
+* ```typescript
+* import { defineSignal } from '@temporal-contract/contract';
+* import { z } from 'zod';
+*
+* export const approveOrder = defineSignal({
+*   input: z.object({
+*     orderId: z.string(),
+*     approvedBy: z.string(),
+*   }),
+* });
+* ```
+*/
+function defineSignal(definition) {
+	return definition;
+}
+/**
+* Define a Temporal query with type-safe input and output schemas.
+*
+* Queries allow you to read the current state of a running workflow without
+* modifying it. They are synchronous and should not perform any mutations.
+*
+* @template TQuery - The query definition type with input/output schemas
+* @param definition - The query definition containing input and output schemas
+* @returns The same definition with preserved types for type inference
+*
+* @example
+* ```typescript
+* import { defineQuery } from '@temporal-contract/contract';
+* import { z } from 'zod';
+*
+* export const getOrderStatus = defineQuery({
+*   input: z.object({ orderId: z.string() }),
+*   output: z.object({
+*     status: z.enum(['pending', 'processing', 'completed', 'failed']),
+*     updatedAt: z.date(),
+*   }),
+* });
+* ```
+*/
+function defineQuery(definition) {
+	return definition;
+}
+/**
+* Define a Temporal update with type-safe input and output schemas.
+*
+* Updates are similar to signals but return a value and wait for the workflow
+* to process them before completing. They provide a synchronous way to modify
+* workflow state and get immediate feedback.
+*
+* @template TUpdate - The update definition type with input/output schemas
+* @param definition - The update definition containing input and output schemas
+* @returns The same definition with preserved types for type inference
+*
+* @example
+* ```typescript
+* import { defineUpdate } from '@temporal-contract/contract';
+* import { z } from 'zod';
+*
+* export const updateOrderQuantity = defineUpdate({
+*   input: z.object({
+*     orderId: z.string(),
+*     newQuantity: z.number().positive(),
+*   }),
+*   output: z.object({
+*     success: z.boolean(),
+*     totalPrice: z.number(),
+*   }),
+* });
+* ```
+*/
+function defineUpdate(definition) {
+	return definition;
+}
+/**
+* Define a Temporal workflow with type-safe input, output, and associated operations.
+*
+* Workflows are durable functions that orchestrate activities, handle timeouts,
+* and manage long-running processes. This function provides type safety for the
+* entire workflow definition including activities, signals, queries, and updates.
+*
+* @template TWorkflow - The workflow definition type with all associated schemas
+* @param definition - The workflow definition containing input, output, and operations
+* @returns The same definition with preserved types for type inference
+*
+* @example
+* ```typescript
+* import { defineWorkflow, defineActivity, defineSignal } from '@temporal-contract/contract';
+* import { z } from 'zod';
+*
+* export const processOrder = defineWorkflow({
+*   input: z.object({ orderId: z.string() }),
+*   output: z.object({ success: z.boolean() }),
+*   activities: {
+*     validatePayment: defineActivity({
+*       input: z.object({ orderId: z.string() }),
+*       output: z.object({ valid: z.boolean() }),
+*     }),
+*   },
+*   signals: {
+*     cancel: defineSignal({
+*       input: z.object({ reason: z.string() }),
+*     }),
+*   },
+* });
+* ```
+*/
+function defineWorkflow(definition) {
+	return definition;
+}
+/**
+* Define a complete Temporal contract with type-safe workflows and activities.
+*
+* A contract is the central definition that ties together your Temporal application's
+* workflows and activities. It provides:
+* - Type safety across client, worker, and workflow code
+* - Automatic validation at runtime
+* - Compile-time verification of implementations
+* - Clear API boundaries and documentation
+*
+* The contract validates the structure and ensures:
+* - Task queue is specified
+* - At least one workflow is defined
+* - Valid JavaScript identifiers are used
+* - No conflicts between global and workflow-specific activities
+* - All schemas implement the Standard Schema specification
+*
+* @template TContract - The contract definition type
+* @param definition - The complete contract definition
+* @returns The same definition with preserved types for type inference
+* @throws {Error} If the contract structure is invalid
+*
+* @example
+* ```typescript
+* import { defineContract } from '@temporal-contract/contract';
+* import { z } from 'zod';
+*
+* export const myContract = defineContract({
+*   taskQueue: 'orders',
+*   workflows: {
+*     processOrder: {
+*       input: z.object({ orderId: z.string() }),
+*       output: z.object({ success: z.boolean() }),
+*       activities: {
+*         chargePayment: {
+*           input: z.object({ amount: z.number() }),
+*           output: z.object({ transactionId: z.string() }),
+*         },
+*       },
+*     },
+*   },
+*   // Optional global activities shared across workflows
+*   activities: {
+*     logEvent: {
+*       input: z.object({ message: z.string() }),
+*       output: z.void(),
+*     },
+*   },
+* });
+* ```
+*/
+function defineContract(definition) {
+	const validationResult = contractValidationSchema.safeParse(definition);
+	if (!validationResult.success) {
+		const cleanMessage = getCleanErrorMessage(validationResult.error);
+		throw new Error(`Contract validation failed: ${cleanMessage}`);
+	}
+	return definition;
+}
+/**
 * Check if a value is a Standard Schema compatible schema
 */
 function isStandardSchema(value) {
@@ -18,7 +229,7 @@ const identifierSchema = zod.z.string().min(1).regex(/^[a-zA-Z_$][a-zA-Z0-9_$]*$
 /**
 * Extract clean error message from Zod validation error
 */
-const getCleanErrorMessage = (error) => {
+function getCleanErrorMessage(error) {
 	try {
 		const parsed = JSON.parse(error.message);
 		if (Array.isArray(parsed) && parsed.length > 0) {
@@ -31,7 +242,7 @@ const getCleanErrorMessage = (error) => {
 		}
 	} catch {}
 	return error.message;
-};
+}
 /**
 * Schema for validating activity definitions
 * Checks that input and output are Standard Schema compatible schemas
@@ -88,106 +299,6 @@ const contractValidationSchema = zod.z.object({
 		}
 	}
 });
-/**
-* Builder for creating activity definitions
-*
-* @example
-* ```ts
-* const myActivity = defineActivity({
-*   input: z.tuple([z.object({ name: z.string() })]),
-*   output: z.object({ greeting: z.string() }),
-* });
-* ```
-*/
-const defineActivity = (definition) => {
-	return definition;
-};
-/**
-* Builder for creating signal definitions
-*
-* @example
-* ```ts
-* const mySignal = defineSignal({
-*   input: z.object({ message: z.string() }),
-* });
-* ```
-*/
-const defineSignal = (definition) => {
-	return definition;
-};
-/**
-* Builder for creating query definitions
-*
-* @example
-* ```ts
-* const myQuery = defineQuery({
-*   input: z.object({ id: z.string() }),
-*   output: z.object({ status: z.string() }),
-* });
-* ```
-*/
-const defineQuery = (definition) => {
-	return definition;
-};
-/**
-* Builder for creating update definitions
-*
-* @example
-* ```ts
-* const myUpdate = defineUpdate({
-*   input: z.object({ value: z.number() }),
-*   output: z.object({ newValue: z.number() }),
-* });
-* ```
-*/
-const defineUpdate = (definition) => {
-	return definition;
-};
-/**
-* Builder for creating workflow definitions
-*
-* @example
-* ```ts
-* const myWorkflow = defineWorkflow({
-*   input: z.tuple([z.object({ orderId: z.string() })]),
-*   output: z.object({ status: z.string() }),
-*   activities: {
-*     processPayment: defineActivity({
-*       input: z.tuple([z.object({ amount: z.number() })]),
-*       output: z.object({ success: z.boolean() }),
-*     }),
-*   },
-* });
-* ```
-*/
-const defineWorkflow = (definition) => {
-	return definition;
-};
-/**
-* Builder for creating a complete contract
-*
-* @example
-* ```ts
-* const myContract = defineContract({
-*   taskQueue: 'my-service',
-*   workflows: {
-*     processOrder: defineWorkflow({ ... }),
-*     sendNotification: defineWorkflow({ ... }),
-*   },
-*   activities: {
-*     sendEmail: defineActivity({ ... }),
-*   },
-* });
-* ```
-*/
-const defineContract = (definition) => {
-	const validationResult = contractValidationSchema.safeParse(definition);
-	if (!validationResult.success) {
-		const cleanMessage = getCleanErrorMessage(validationResult.error);
-		throw new Error(`Contract error: ${cleanMessage}`);
-	}
-	return definition;
-};
 
 //#endregion
 //#region src/nexus-types.ts

package/dist/index.d.cts

@@ -89,88 +89,199 @@ type InferContractWorkflows<TContract extends ContractDefinition> = TContract["w
 //#endregion
 //#region src/builder.d.ts
 /**
- * Builder for creating activity definitions
+ * Define a Temporal activity with type-safe input and output schemas.
+ *
+ * Activities are the building blocks of Temporal workflows that execute business logic
+ * and interact with external services. This function preserves TypeScript types while
+ * providing a consistent structure for activity definitions.
+ *
+ * @template TActivity - The activity definition type with input/output schemas
+ * @param definition - The activity definition containing input and output schemas
+ * @returns The same definition with preserved types for type inference
  *
  * @example
- * ```ts
- * const myActivity = defineActivity({
- *   input: z.tuple([z.object({ name: z.string() })]),
- *   output: z.object({ greeting: z.string() }),
+ * ```typescript
+ * import { defineActivity } from '@temporal-contract/contract';
+ * import { z } from 'zod';
+ *
+ * export const sendEmail = defineActivity({
+ *   input: z.object({
+ *     to: z.string().email(),
+ *     subject: z.string(),
+ *     body: z.string(),
+ *   }),
+ *   output: z.object({
+ *     messageId: z.string(),
+ *     sentAt: z.date(),
+ *   }),
  * });
  * ```
  */
-declare const defineActivity: <TActivity extends ActivityDefinition>(definition: TActivity) => TActivity;
+declare function defineActivity<TActivity extends ActivityDefinition>(definition: TActivity): TActivity;
 /**
- * Builder for creating signal definitions
+ * Define a Temporal signal with type-safe input schema.
+ *
+ * Signals are asynchronous messages sent to running workflows to update their state
+ * or trigger certain behaviors. This function ensures type safety for signal payloads.
+ *
+ * @template TSignal - The signal definition type with input schema
+ * @param definition - The signal definition containing input schema
+ * @returns The same definition with preserved types for type inference
  *
  * @example
- * ```ts
- * const mySignal = defineSignal({
- *   input: z.object({ message: z.string() }),
+ * ```typescript
+ * import { defineSignal } from '@temporal-contract/contract';
+ * import { z } from 'zod';
+ *
+ * export const approveOrder = defineSignal({
+ *   input: z.object({
+ *     orderId: z.string(),
+ *     approvedBy: z.string(),
+ *   }),
  * });
  * ```
  */
-declare const defineSignal: <TSignal extends SignalDefinition>(definition: TSignal) => TSignal;
+declare function defineSignal<TSignal extends SignalDefinition>(definition: TSignal): TSignal;
 /**
- * Builder for creating query definitions
+ * Define a Temporal query with type-safe input and output schemas.
+ *
+ * Queries allow you to read the current state of a running workflow without
+ * modifying it. They are synchronous and should not perform any mutations.
+ *
+ * @template TQuery - The query definition type with input/output schemas
+ * @param definition - The query definition containing input and output schemas
+ * @returns The same definition with preserved types for type inference
  *
  * @example
- * ```ts
- * const myQuery = defineQuery({
- *   input: z.object({ id: z.string() }),
- *   output: z.object({ status: z.string() }),
+ * ```typescript
+ * import { defineQuery } from '@temporal-contract/contract';
+ * import { z } from 'zod';
+ *
+ * export const getOrderStatus = defineQuery({
+ *   input: z.object({ orderId: z.string() }),
+ *   output: z.object({
+ *     status: z.enum(['pending', 'processing', 'completed', 'failed']),
+ *     updatedAt: z.date(),
+ *   }),
  * });
  * ```
  */
-declare const defineQuery: <TQuery extends QueryDefinition>(definition: TQuery) => TQuery;
+declare function defineQuery<TQuery extends QueryDefinition>(definition: TQuery): TQuery;
 /**
- * Builder for creating update definitions
+ * Define a Temporal update with type-safe input and output schemas.
+ *
+ * Updates are similar to signals but return a value and wait for the workflow
+ * to process them before completing. They provide a synchronous way to modify
+ * workflow state and get immediate feedback.
+ *
+ * @template TUpdate - The update definition type with input/output schemas
+ * @param definition - The update definition containing input and output schemas
+ * @returns The same definition with preserved types for type inference
  *
  * @example
- * ```ts
- * const myUpdate = defineUpdate({
- *   input: z.object({ value: z.number() }),
- *   output: z.object({ newValue: z.number() }),
+ * ```typescript
+ * import { defineUpdate } from '@temporal-contract/contract';
+ * import { z } from 'zod';
+ *
+ * export const updateOrderQuantity = defineUpdate({
+ *   input: z.object({
+ *     orderId: z.string(),
+ *     newQuantity: z.number().positive(),
+ *   }),
+ *   output: z.object({
+ *     success: z.boolean(),
+ *     totalPrice: z.number(),
+ *   }),
  * });
  * ```
  */
-declare const defineUpdate: <TUpdate extends UpdateDefinition>(definition: TUpdate) => TUpdate;
+declare function defineUpdate<TUpdate extends UpdateDefinition>(definition: TUpdate): TUpdate;
 /**
- * Builder for creating workflow definitions
+ * Define a Temporal workflow with type-safe input, output, and associated operations.
+ *
+ * Workflows are durable functions that orchestrate activities, handle timeouts,
+ * and manage long-running processes. This function provides type safety for the
+ * entire workflow definition including activities, signals, queries, and updates.
+ *
+ * @template TWorkflow - The workflow definition type with all associated schemas
+ * @param definition - The workflow definition containing input, output, and operations
+ * @returns The same definition with preserved types for type inference
  *
  * @example
- * ```ts
- * const myWorkflow = defineWorkflow({
- *   input: z.tuple([z.object({ orderId: z.string() })]),
- *   output: z.object({ status: z.string() }),
+ * ```typescript
+ * import { defineWorkflow, defineActivity, defineSignal } from '@temporal-contract/contract';
+ * import { z } from 'zod';
+ *
+ * export const processOrder = defineWorkflow({
+ *   input: z.object({ orderId: z.string() }),
+ *   output: z.object({ success: z.boolean() }),
  *   activities: {
- *     processPayment: defineActivity({
- *       input: z.tuple([z.object({ amount: z.number() })]),
- *       output: z.object({ success: z.boolean() }),
+ *     validatePayment: defineActivity({
+ *       input: z.object({ orderId: z.string() }),
+ *       output: z.object({ valid: z.boolean() }),
+ *     }),
+ *   },
+ *   signals: {
+ *     cancel: defineSignal({
+ *       input: z.object({ reason: z.string() }),
  *     }),
  *   },
  * });
  * ```
  */
-declare const defineWorkflow: <TWorkflow extends WorkflowDefinition>(definition: TWorkflow) => TWorkflow;
+declare function defineWorkflow<TWorkflow extends WorkflowDefinition>(definition: TWorkflow): TWorkflow;
 /**
- * Builder for creating a complete contract
+ * Define a complete Temporal contract with type-safe workflows and activities.
+ *
+ * A contract is the central definition that ties together your Temporal application's
+ * workflows and activities. It provides:
+ * - Type safety across client, worker, and workflow code
+ * - Automatic validation at runtime
+ * - Compile-time verification of implementations
+ * - Clear API boundaries and documentation
+ *
+ * The contract validates the structure and ensures:
+ * - Task queue is specified
+ * - At least one workflow is defined
+ * - Valid JavaScript identifiers are used
+ * - No conflicts between global and workflow-specific activities
+ * - All schemas implement the Standard Schema specification
+ *
+ * @template TContract - The contract definition type
+ * @param definition - The complete contract definition
+ * @returns The same definition with preserved types for type inference
+ * @throws {Error} If the contract structure is invalid
  *
  * @example
- * ```ts
- * const myContract = defineContract({
- *   taskQueue: 'my-service',
+ * ```typescript
+ * import { defineContract } from '@temporal-contract/contract';
+ * import { z } from 'zod';
+ *
+ * export const myContract = defineContract({
+ *   taskQueue: 'orders',
  *   workflows: {
- *     processOrder: defineWorkflow({ ... }),
- *     sendNotification: defineWorkflow({ ... }),
+ *     processOrder: {
+ *       input: z.object({ orderId: z.string() }),
+ *       output: z.object({ success: z.boolean() }),
+ *       activities: {
+ *         chargePayment: {
+ *           input: z.object({ amount: z.number() }),
+ *           output: z.object({ transactionId: z.string() }),
+ *         },
+ *       },
+ *     },
  *   },
+ *   // Optional global activities shared across workflows
  *   activities: {
- *     sendEmail: defineActivity({ ... }),
+ *     logEvent: {
+ *       input: z.object({ message: z.string() }),
+ *       output: z.void(),
+ *     },
  *   },
  * });
  * ```
  */
-declare const defineContract: <TContract extends ContractDefinition>(definition: TContract) => TContract;
+declare function defineContract<TContract extends ContractDefinition>(definition: TContract): TContract;
 //#endregion
 //#region src/nexus-types.d.ts
 /**

package/dist/index.d.mts

@@ -89,88 +89,199 @@ type InferContractWorkflows<TContract extends ContractDefinition> = TContract["w
 //#endregion
 //#region src/builder.d.ts
 /**
- * Builder for creating activity definitions
+ * Define a Temporal activity with type-safe input and output schemas.
+ *
+ * Activities are the building blocks of Temporal workflows that execute business logic
+ * and interact with external services. This function preserves TypeScript types while
+ * providing a consistent structure for activity definitions.
+ *
+ * @template TActivity - The activity definition type with input/output schemas
+ * @param definition - The activity definition containing input and output schemas
+ * @returns The same definition with preserved types for type inference
  *
  * @example
- * ```ts
- * const myActivity = defineActivity({
- *   input: z.tuple([z.object({ name: z.string() })]),
- *   output: z.object({ greeting: z.string() }),
+ * ```typescript
+ * import { defineActivity } from '@temporal-contract/contract';
+ * import { z } from 'zod';
+ *
+ * export const sendEmail = defineActivity({
+ *   input: z.object({
+ *     to: z.string().email(),
+ *     subject: z.string(),
+ *     body: z.string(),
+ *   }),
+ *   output: z.object({
+ *     messageId: z.string(),
+ *     sentAt: z.date(),
+ *   }),
  * });
  * ```
  */
-declare const defineActivity: <TActivity extends ActivityDefinition>(definition: TActivity) => TActivity;
+declare function defineActivity<TActivity extends ActivityDefinition>(definition: TActivity): TActivity;
 /**
- * Builder for creating signal definitions
+ * Define a Temporal signal with type-safe input schema.
+ *
+ * Signals are asynchronous messages sent to running workflows to update their state
+ * or trigger certain behaviors. This function ensures type safety for signal payloads.
+ *
+ * @template TSignal - The signal definition type with input schema
+ * @param definition - The signal definition containing input schema
+ * @returns The same definition with preserved types for type inference
  *
  * @example
- * ```ts
- * const mySignal = defineSignal({
- *   input: z.object({ message: z.string() }),
+ * ```typescript
+ * import { defineSignal } from '@temporal-contract/contract';
+ * import { z } from 'zod';
+ *
+ * export const approveOrder = defineSignal({
+ *   input: z.object({
+ *     orderId: z.string(),
+ *     approvedBy: z.string(),
+ *   }),
  * });
  * ```
  */
-declare const defineSignal: <TSignal extends SignalDefinition>(definition: TSignal) => TSignal;
+declare function defineSignal<TSignal extends SignalDefinition>(definition: TSignal): TSignal;
 /**
- * Builder for creating query definitions
+ * Define a Temporal query with type-safe input and output schemas.
+ *
+ * Queries allow you to read the current state of a running workflow without
+ * modifying it. They are synchronous and should not perform any mutations.
+ *
+ * @template TQuery - The query definition type with input/output schemas
+ * @param definition - The query definition containing input and output schemas
+ * @returns The same definition with preserved types for type inference
  *
  * @example
- * ```ts
- * const myQuery = defineQuery({
- *   input: z.object({ id: z.string() }),
- *   output: z.object({ status: z.string() }),
+ * ```typescript
+ * import { defineQuery } from '@temporal-contract/contract';
+ * import { z } from 'zod';
+ *
+ * export const getOrderStatus = defineQuery({
+ *   input: z.object({ orderId: z.string() }),
+ *   output: z.object({
+ *     status: z.enum(['pending', 'processing', 'completed', 'failed']),
+ *     updatedAt: z.date(),
+ *   }),
  * });
  * ```
  */
-declare const defineQuery: <TQuery extends QueryDefinition>(definition: TQuery) => TQuery;
+declare function defineQuery<TQuery extends QueryDefinition>(definition: TQuery): TQuery;
 /**
- * Builder for creating update definitions
+ * Define a Temporal update with type-safe input and output schemas.
+ *
+ * Updates are similar to signals but return a value and wait for the workflow
+ * to process them before completing. They provide a synchronous way to modify
+ * workflow state and get immediate feedback.
+ *
+ * @template TUpdate - The update definition type with input/output schemas
+ * @param definition - The update definition containing input and output schemas
+ * @returns The same definition with preserved types for type inference
  *
  * @example
- * ```ts
- * const myUpdate = defineUpdate({
- *   input: z.object({ value: z.number() }),
- *   output: z.object({ newValue: z.number() }),
+ * ```typescript
+ * import { defineUpdate } from '@temporal-contract/contract';
+ * import { z } from 'zod';
+ *
+ * export const updateOrderQuantity = defineUpdate({
+ *   input: z.object({
+ *     orderId: z.string(),
+ *     newQuantity: z.number().positive(),
+ *   }),
+ *   output: z.object({
+ *     success: z.boolean(),
+ *     totalPrice: z.number(),
+ *   }),
  * });
  * ```
  */
-declare const defineUpdate: <TUpdate extends UpdateDefinition>(definition: TUpdate) => TUpdate;
+declare function defineUpdate<TUpdate extends UpdateDefinition>(definition: TUpdate): TUpdate;
 /**
- * Builder for creating workflow definitions
+ * Define a Temporal workflow with type-safe input, output, and associated operations.
+ *
+ * Workflows are durable functions that orchestrate activities, handle timeouts,
+ * and manage long-running processes. This function provides type safety for the
+ * entire workflow definition including activities, signals, queries, and updates.
+ *
+ * @template TWorkflow - The workflow definition type with all associated schemas
+ * @param definition - The workflow definition containing input, output, and operations
+ * @returns The same definition with preserved types for type inference
  *
  * @example
- * ```ts
- * const myWorkflow = defineWorkflow({
- *   input: z.tuple([z.object({ orderId: z.string() })]),
- *   output: z.object({ status: z.string() }),
+ * ```typescript
+ * import { defineWorkflow, defineActivity, defineSignal } from '@temporal-contract/contract';
+ * import { z } from 'zod';
+ *
+ * export const processOrder = defineWorkflow({
+ *   input: z.object({ orderId: z.string() }),
+ *   output: z.object({ success: z.boolean() }),
  *   activities: {
- *     processPayment: defineActivity({
- *       input: z.tuple([z.object({ amount: z.number() })]),
- *       output: z.object({ success: z.boolean() }),
+ *     validatePayment: defineActivity({
+ *       input: z.object({ orderId: z.string() }),
+ *       output: z.object({ valid: z.boolean() }),
+ *     }),
+ *   },
+ *   signals: {
+ *     cancel: defineSignal({
+ *       input: z.object({ reason: z.string() }),
  *     }),
  *   },
  * });
  * ```
  */
-declare const defineWorkflow: <TWorkflow extends WorkflowDefinition>(definition: TWorkflow) => TWorkflow;
+declare function defineWorkflow<TWorkflow extends WorkflowDefinition>(definition: TWorkflow): TWorkflow;
 /**
- * Builder for creating a complete contract
+ * Define a complete Temporal contract with type-safe workflows and activities.
+ *
+ * A contract is the central definition that ties together your Temporal application's
+ * workflows and activities. It provides:
+ * - Type safety across client, worker, and workflow code
+ * - Automatic validation at runtime
+ * - Compile-time verification of implementations
+ * - Clear API boundaries and documentation
+ *
+ * The contract validates the structure and ensures:
+ * - Task queue is specified
+ * - At least one workflow is defined
+ * - Valid JavaScript identifiers are used
+ * - No conflicts between global and workflow-specific activities
+ * - All schemas implement the Standard Schema specification
+ *
+ * @template TContract - The contract definition type
+ * @param definition - The complete contract definition
+ * @returns The same definition with preserved types for type inference
+ * @throws {Error} If the contract structure is invalid
  *
  * @example
- * ```ts
- * const myContract = defineContract({
- *   taskQueue: 'my-service',
+ * ```typescript
+ * import { defineContract } from '@temporal-contract/contract';
+ * import { z } from 'zod';
+ *
+ * export const myContract = defineContract({
+ *   taskQueue: 'orders',
  *   workflows: {
- *     processOrder: defineWorkflow({ ... }),
- *     sendNotification: defineWorkflow({ ... }),
+ *     processOrder: {
+ *       input: z.object({ orderId: z.string() }),
+ *       output: z.object({ success: z.boolean() }),
+ *       activities: {
+ *         chargePayment: {
+ *           input: z.object({ amount: z.number() }),
+ *           output: z.object({ transactionId: z.string() }),
+ *         },
+ *       },
+ *     },
  *   },
+ *   // Optional global activities shared across workflows
  *   activities: {
- *     sendEmail: defineActivity({ ... }),
+ *     logEvent: {
+ *       input: z.object({ message: z.string() }),
+ *       output: z.void(),
+ *     },
  *   },
  * });
  * ```
  */
-declare const defineContract: <TContract extends ContractDefinition>(definition: TContract) => TContract;
+declare function defineContract<TContract extends ContractDefinition>(definition: TContract): TContract;
 //#endregion
 //#region src/nexus-types.d.ts
 /**

package/dist/index.mjs

@@ -2,6 +2,217 @@ import { z } from "zod";
 
 //#region src/builder.ts
 /**
+* Define a Temporal activity with type-safe input and output schemas.
+*
+* Activities are the building blocks of Temporal workflows that execute business logic
+* and interact with external services. This function preserves TypeScript types while
+* providing a consistent structure for activity definitions.
+*
+* @template TActivity - The activity definition type with input/output schemas
+* @param definition - The activity definition containing input and output schemas
+* @returns The same definition with preserved types for type inference
+*
+* @example
+* ```typescript
+* import { defineActivity } from '@temporal-contract/contract';
+* import { z } from 'zod';
+*
+* export const sendEmail = defineActivity({
+*   input: z.object({
+*     to: z.string().email(),
+*     subject: z.string(),
+*     body: z.string(),
+*   }),
+*   output: z.object({
+*     messageId: z.string(),
+*     sentAt: z.date(),
+*   }),
+* });
+* ```
+*/
+function defineActivity(definition) {
+	return definition;
+}
+/**
+* Define a Temporal signal with type-safe input schema.
+*
+* Signals are asynchronous messages sent to running workflows to update their state
+* or trigger certain behaviors. This function ensures type safety for signal payloads.
+*
+* @template TSignal - The signal definition type with input schema
+* @param definition - The signal definition containing input schema
+* @returns The same definition with preserved types for type inference
+*
+* @example
+* ```typescript
+* import { defineSignal } from '@temporal-contract/contract';
+* import { z } from 'zod';
+*
+* export const approveOrder = defineSignal({
+*   input: z.object({
+*     orderId: z.string(),
+*     approvedBy: z.string(),
+*   }),
+* });
+* ```
+*/
+function defineSignal(definition) {
+	return definition;
+}
+/**
+* Define a Temporal query with type-safe input and output schemas.
+*
+* Queries allow you to read the current state of a running workflow without
+* modifying it. They are synchronous and should not perform any mutations.
+*
+* @template TQuery - The query definition type with input/output schemas
+* @param definition - The query definition containing input and output schemas
+* @returns The same definition with preserved types for type inference
+*
+* @example
+* ```typescript
+* import { defineQuery } from '@temporal-contract/contract';
+* import { z } from 'zod';
+*
+* export const getOrderStatus = defineQuery({
+*   input: z.object({ orderId: z.string() }),
+*   output: z.object({
+*     status: z.enum(['pending', 'processing', 'completed', 'failed']),
+*     updatedAt: z.date(),
+*   }),
+* });
+* ```
+*/
+function defineQuery(definition) {
+	return definition;
+}
+/**
+* Define a Temporal update with type-safe input and output schemas.
+*
+* Updates are similar to signals but return a value and wait for the workflow
+* to process them before completing. They provide a synchronous way to modify
+* workflow state and get immediate feedback.
+*
+* @template TUpdate - The update definition type with input/output schemas
+* @param definition - The update definition containing input and output schemas
+* @returns The same definition with preserved types for type inference
+*
+* @example
+* ```typescript
+* import { defineUpdate } from '@temporal-contract/contract';
+* import { z } from 'zod';
+*
+* export const updateOrderQuantity = defineUpdate({
+*   input: z.object({
+*     orderId: z.string(),
+*     newQuantity: z.number().positive(),
+*   }),
+*   output: z.object({
+*     success: z.boolean(),
+*     totalPrice: z.number(),
+*   }),
+* });
+* ```
+*/
+function defineUpdate(definition) {
+	return definition;
+}
+/**
+* Define a Temporal workflow with type-safe input, output, and associated operations.
+*
+* Workflows are durable functions that orchestrate activities, handle timeouts,
+* and manage long-running processes. This function provides type safety for the
+* entire workflow definition including activities, signals, queries, and updates.
+*
+* @template TWorkflow - The workflow definition type with all associated schemas
+* @param definition - The workflow definition containing input, output, and operations
+* @returns The same definition with preserved types for type inference
+*
+* @example
+* ```typescript
+* import { defineWorkflow, defineActivity, defineSignal } from '@temporal-contract/contract';
+* import { z } from 'zod';
+*
+* export const processOrder = defineWorkflow({
+*   input: z.object({ orderId: z.string() }),
+*   output: z.object({ success: z.boolean() }),
+*   activities: {
+*     validatePayment: defineActivity({
+*       input: z.object({ orderId: z.string() }),
+*       output: z.object({ valid: z.boolean() }),
+*     }),
+*   },
+*   signals: {
+*     cancel: defineSignal({
+*       input: z.object({ reason: z.string() }),
+*     }),
+*   },
+* });
+* ```
+*/
+function defineWorkflow(definition) {
+	return definition;
+}
+/**
+* Define a complete Temporal contract with type-safe workflows and activities.
+*
+* A contract is the central definition that ties together your Temporal application's
+* workflows and activities. It provides:
+* - Type safety across client, worker, and workflow code
+* - Automatic validation at runtime
+* - Compile-time verification of implementations
+* - Clear API boundaries and documentation
+*
+* The contract validates the structure and ensures:
+* - Task queue is specified
+* - At least one workflow is defined
+* - Valid JavaScript identifiers are used
+* - No conflicts between global and workflow-specific activities
+* - All schemas implement the Standard Schema specification
+*
+* @template TContract - The contract definition type
+* @param definition - The complete contract definition
+* @returns The same definition with preserved types for type inference
+* @throws {Error} If the contract structure is invalid
+*
+* @example
+* ```typescript
+* import { defineContract } from '@temporal-contract/contract';
+* import { z } from 'zod';
+*
+* export const myContract = defineContract({
+*   taskQueue: 'orders',
+*   workflows: {
+*     processOrder: {
+*       input: z.object({ orderId: z.string() }),
+*       output: z.object({ success: z.boolean() }),
+*       activities: {
+*         chargePayment: {
+*           input: z.object({ amount: z.number() }),
+*           output: z.object({ transactionId: z.string() }),
+*         },
+*       },
+*     },
+*   },
+*   // Optional global activities shared across workflows
+*   activities: {
+*     logEvent: {
+*       input: z.object({ message: z.string() }),
+*       output: z.void(),
+*     },
+*   },
+* });
+* ```
+*/
+function defineContract(definition) {
+	const validationResult = contractValidationSchema.safeParse(definition);
+	if (!validationResult.success) {
+		const cleanMessage = getCleanErrorMessage(validationResult.error);
+		throw new Error(`Contract validation failed: ${cleanMessage}`);
+	}
+	return definition;
+}
+/**
 * Check if a value is a Standard Schema compatible schema
 */
 function isStandardSchema(value) {
@@ -18,7 +229,7 @@ const identifierSchema = z.string().min(1).regex(/^[a-zA-Z_$][a-zA-Z0-9_$]*$/, "
 /**
 * Extract clean error message from Zod validation error
 */
-const getCleanErrorMessage = (error) => {
+function getCleanErrorMessage(error) {
 	try {
 		const parsed = JSON.parse(error.message);
 		if (Array.isArray(parsed) && parsed.length > 0) {
@@ -31,7 +242,7 @@ const getCleanErrorMessage = (error) => {
 		}
 	} catch {}
 	return error.message;
-};
+}
 /**
 * Schema for validating activity definitions
 * Checks that input and output are Standard Schema compatible schemas
@@ -88,106 +299,6 @@ const contractValidationSchema = z.object({
 		}
 	}
 });
-/**
-* Builder for creating activity definitions
-*
-* @example
-* ```ts
-* const myActivity = defineActivity({
-*   input: z.tuple([z.object({ name: z.string() })]),
-*   output: z.object({ greeting: z.string() }),
-* });
-* ```
-*/
-const defineActivity = (definition) => {
-	return definition;
-};
-/**
-* Builder for creating signal definitions
-*
-* @example
-* ```ts
-* const mySignal = defineSignal({
-*   input: z.object({ message: z.string() }),
-* });
-* ```
-*/
-const defineSignal = (definition) => {
-	return definition;
-};
-/**
-* Builder for creating query definitions
-*
-* @example
-* ```ts
-* const myQuery = defineQuery({
-*   input: z.object({ id: z.string() }),
-*   output: z.object({ status: z.string() }),
-* });
-* ```
-*/
-const defineQuery = (definition) => {
-	return definition;
-};
-/**
-* Builder for creating update definitions
-*
-* @example
-* ```ts
-* const myUpdate = defineUpdate({
-*   input: z.object({ value: z.number() }),
-*   output: z.object({ newValue: z.number() }),
-* });
-* ```
-*/
-const defineUpdate = (definition) => {
-	return definition;
-};
-/**
-* Builder for creating workflow definitions
-*
-* @example
-* ```ts
-* const myWorkflow = defineWorkflow({
-*   input: z.tuple([z.object({ orderId: z.string() })]),
-*   output: z.object({ status: z.string() }),
-*   activities: {
-*     processPayment: defineActivity({
-*       input: z.tuple([z.object({ amount: z.number() })]),
-*       output: z.object({ success: z.boolean() }),
-*     }),
-*   },
-* });
-* ```
-*/
-const defineWorkflow = (definition) => {
-	return definition;
-};
-/**
-* Builder for creating a complete contract
-*
-* @example
-* ```ts
-* const myContract = defineContract({
-*   taskQueue: 'my-service',
-*   workflows: {
-*     processOrder: defineWorkflow({ ... }),
-*     sendNotification: defineWorkflow({ ... }),
-*   },
-*   activities: {
-*     sendEmail: defineActivity({ ... }),
-*   },
-* });
-* ```
-*/
-const defineContract = (definition) => {
-	const validationResult = contractValidationSchema.safeParse(definition);
-	if (!validationResult.success) {
-		const cleanMessage = getCleanErrorMessage(validationResult.error);
-		throw new Error(`Contract error: ${cleanMessage}`);
-	}
-	return definition;
-};
 
 //#endregion
 //#region src/nexus-types.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temporal-contract/contract",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Contract builder for temporal-contract",
   "keywords": [
     "contract",
@@ -17,7 +17,7 @@
     "directory": "packages/contract"
   },
   "license": "MIT",
-  "author": "Benoit TRAVERS <benoit.travers.frgmail.com>",
+  "author": "Benoit TRAVERS <benoit.travers.fr@gmail.com>",
   "type": "module",
   "exports": {
     ".": {
@@ -45,11 +45,11 @@
   "devDependencies": {
     "@vitest/coverage-v8": "4.0.16",
     "arktype": "2.1.29",
-    "tsdown": "0.18.0",
+    "tsdown": "0.18.1",
     "typescript": "5.9.3",
     "valibot": "1.2.0",
     "vitest": "4.0.16",
-    "@temporal-contract/tsconfig": "0.0.5"
+    "@temporal-contract/tsconfig": "0.0.7"
   },
   "scripts": {
     "build": "tsdown src/index.ts --format cjs,esm --dts --clean",