@temporal-contract/contract 0.0.1 → 0.0.2

package/.turbo/turbo-build.log

@@ -1,17 +1,17 @@
 
-> @temporal-contract/contract@0.0.1 build /home/runner/work/temporal-contract/temporal-contract/packages/contract
+> @temporal-contract/contract@0.0.2 build /home/runner/work/temporal-contract/temporal-contract/packages/contract
 > tsdown src/index.ts --format cjs,esm --dts --clean
 
 ℹ tsdown v0.17.2 powered by rolldown v1.0.0-beta.53
 ℹ entry: src/index.ts
 ℹ tsconfig: tsconfig.json
 ℹ Build start
-ℹ [CJS] dist/index.cjs  5.96 kB │ gzip: 1.51 kB
-ℹ [CJS] 1 files, total: 5.96 kB
-ℹ [CJS] dist/index.d.cts  15.50 kB │ gzip: 2.50 kB
-ℹ [CJS] 1 files, total: 15.50 kB
-ℹ [ESM] dist/index.mjs     5.69 kB │ gzip: 1.49 kB
-ℹ [ESM] dist/index.d.mts  15.50 kB │ gzip: 2.50 kB
-ℹ [ESM] 2 files, total: 21.19 kB
-✔ Build complete in 2205ms
-✔ Build complete in 2206ms
+ℹ [CJS] dist/index.cjs  6.97 kB │ gzip: 1.69 kB
+ℹ [CJS] 1 files, total: 6.97 kB
+ℹ [CJS] dist/index.d.cts  15.66 kB │ gzip: 2.56 kB
+ℹ [CJS] 1 files, total: 15.66 kB
+✔ Build complete in 1491ms
+ℹ [ESM] dist/index.mjs     6.74 kB │ gzip: 1.67 kB
+ℹ [ESM] dist/index.d.mts  15.66 kB │ gzip: 2.56 kB
+ℹ [ESM] 2 files, total: 22.40 kB
+✔ Build complete in 1492ms

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @temporal-contract/contract
+
+## 0.0.2
+
+### Patch Changes
+
+- Release version 0.0.2

package/README.md

@@ -2,7 +2,7 @@
 
 > Contract builder and type definitions for Temporal workflows and activities
 
-**Core package** for defining type-safe contracts with Zod schemas.
+[![npm version](https://img.shields.io/npm/v/@temporal-contract/contract.svg?logo=npm)](https://www.npmjs.com/package/@temporal-contract/contract)
 
 ## Installation
 
@@ -10,98 +10,32 @@
 pnpm add @temporal-contract/contract zod
 ```
 
-## What's Included
-
-- **Contract builder** — `defineContract()` for creating type-safe contracts
-- **Type utilities** — Helper types for cleaner implementations
-- **Helper functions** — Optional helpers for standalone definitions
-
-## Usage
-
-```typescript
-import { z } from 'zod';
-import { defineContract } from '@temporal-contract/contract';
-
-export const myContract = defineContract({
-  taskQueue: 'my-service',
-  workflows: {
-    processOrder: {
-      input: z.object({
-        orderId: z.string(),
-        items: z.array(z.object({
-          productId: z.string(),
-          quantity: z.number(),
-        })),
-      }),
-      output: z.object({
-        status: z.enum(['success', 'failed']),
-        totalAmount: z.number(),
-      }),
-      activities: {
-        processPayment: {
-          input: z.object({ amount: z.number() }),
-          output: z.object({ transactionId: z.string() }),
-        },
-      },
-    },
-  },
-});
-```
-
-## Quick Start
-
-### Define a Contract
+## Quick Example
 
 ```typescript
 import { defineContract } from '@temporal-contract/contract';
 import { z } from 'zod';
 
 export const myContract = defineContract({
-  taskQueue: 'my-service',
-
-  // Global activities (available in all workflows)
-  activities: {
-    sendEmail: {
-      input: z.object({ to: z.string(), subject: z.string() }),
-      output: z.object({ sent: z.boolean() }),
-    },
-  },
-
-  // Workflows
+  taskQueue: 'orders',
   workflows: {
     processOrder: {
       input: z.object({ orderId: z.string() }),
-      output: z.object({ status: z.string() }),
-
-      // Workflow-specific activities
-      activities: {
-        processPayment: {
-          input: z.object({ amount: z.number() }),
-          output: z.object({ transactionId: z.string() }),
-        },
-      },
-    },
-  },
+      output: z.object({ success: z.boolean() }),
+      activities: { /* ... */ }
+    }
+  }
 });
 ```
 
-### Helper Functions (Optional)
+## Documentation
 
-For standalone definitions outside a contract:
+📖 **[Read the full documentation →](https://btravers.github.io/temporal-contract)**
 
-```typescript
-import { defineActivity, defineSignal, defineQuery, defineUpdate } from '@temporal-contract/contract';
+- [API Reference](https://btravers.github.io/temporal-contract/api/contract)
+- [Getting Started](https://btravers.github.io/temporal-contract/guide/getting-started)
+- [Core Concepts](https://btravers.github.io/temporal-contract/guide/core-concepts)
 
-// Standalone activity
-const sendEmail = defineActivity({
-  input: z.object({ to: z.string() }),
-  output: z.object({ sent: z.boolean() }),
-});
-
-// Signal, query, update
-const cancelOrder = defineSignal({ input: z.object({ reason: z.string() }) });
-const getStatus = defineQuery({ input: z.void(), output: z.object({ status: z.string() }) });
-const updateAmount = defineUpdate({ input: z.number(), output: z.boolean() });
-```
+## License
 
-## Type Utilities\n\nHelper types for implementing activities with full type inference:\n\n### Activity Handlers\n\n`typescript\nimport type { ActivityHandler, WorkflowActivityHandler } from '@temporal-contract/contract';\n\n// Global activity\nconst sendEmail: ActivityHandler<typeof myContract, 'sendEmail'> = \n  async ({ to, subject }) => {\n    await emailService.send({ to, subject });\n    return { sent: true };\n  };\n\n// Workflow-specific activity\nconst processPayment: WorkflowActivityHandler<typeof myContract, 'processOrder', 'processPayment'> = \n  async ({ amount }) => {\n    const txId = await paymentGateway.charge(amount);\n    return { transactionId: txId };\n  };\n`\n\n### Contract Introspection\n\n`typescript\nimport type { InferWorkflowNames, InferActivityNames } from '@temporal-contract/contract';\n\ntype Workflows = InferWorkflowNames<typeof myContract>;  // \"processOrder\" | ...\ntype Activities = InferActivityNames<typeof myContract>;  // \"sendEmail\" | ...\n`\n\nSee [Activity Handlers documentation](../../docs/ACTIVITY_HANDLERS.md) for details.\n\n---\n\n## Learn More\n\n- [Main README](../../README.md) \u2014 Quick start guide\n- [Worker Implementation](../../docs/CONTRACT_HANDLER.md) \u2014 Implementing workers\n- [Activity Handlers](../../docs/ACTIVITY_HANDLERS.md) \u2014 Type utility details\n\n## License\n\nMIT
+MIT

package/dist/index.cjs

@@ -2,6 +2,14 @@ let zod = require("zod");
 
 //#region src/builder.ts
 /**
+* Check if a value is a Standard Schema compatible schema
+*/
+function isStandardSchema(value) {
+	if (typeof value !== "object" && typeof value !== "function" || value === null || !("~standard" in value)) return false;
+	const standard = value["~standard"];
+	return typeof standard === "object" && standard !== null && standard["version"] === 1 && typeof standard["validate"] === "function";
+}
+/**
 * Schema for validating JavaScript identifiers (workflow names, activity names, etc.)
 * Allows: letters, digits, underscore, dollar sign
 * Must start with: letter, underscore, or dollar sign
@@ -26,36 +34,36 @@ const getCleanErrorMessage = (error) => {
 };
 /**
 * Schema for validating activity definitions
-* Checks that input and output are Zod schemas
+* Checks that input and output are Standard Schema compatible schemas
 */
 const activityDefinitionSchema = zod.z.object({
-	input: zod.z.instanceof(zod.z.ZodType, { message: "input must be a Zod schema" }),
-	output: zod.z.instanceof(zod.z.ZodType, { message: "output must be a Zod schema" })
+	input: zod.z.custom((val) => isStandardSchema(val), { message: "input must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)" }),
+	output: zod.z.custom((val) => isStandardSchema(val), { message: "output must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)" })
 });
 /**
 * Schema for validating signal definitions
 */
-const signalDefinitionSchema = zod.z.object({ input: zod.z.instanceof(zod.z.ZodType, { message: "input must be a Zod schema" }) });
+const signalDefinitionSchema = zod.z.object({ input: zod.z.custom((val) => isStandardSchema(val), { message: "input must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)" }) });
 /**
 * Schema for validating query definitions
 */
 const queryDefinitionSchema = zod.z.object({
-	input: zod.z.instanceof(zod.z.ZodType, { message: "input must be a Zod schema" }),
-	output: zod.z.instanceof(zod.z.ZodType, { message: "output must be a Zod schema" })
+	input: zod.z.custom((val) => isStandardSchema(val), { message: "input must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)" }),
+	output: zod.z.custom((val) => isStandardSchema(val), { message: "output must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)" })
 });
 /**
 * Schema for validating update definitions
 */
 const updateDefinitionSchema = zod.z.object({
-	input: zod.z.instanceof(zod.z.ZodType, { message: "input must be a Zod schema" }),
-	output: zod.z.instanceof(zod.z.ZodType, { message: "output must be a Zod schema" })
+	input: zod.z.custom((val) => isStandardSchema(val), { message: "input must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)" }),
+	output: zod.z.custom((val) => isStandardSchema(val), { message: "output must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)" })
 });
 /**
 * Schema for validating workflow definitions
 */
 const workflowDefinitionSchema = zod.z.object({
-	input: zod.z.instanceof(zod.z.ZodType, { message: "input must be a Zod schema" }),
-	output: zod.z.instanceof(zod.z.ZodType, { message: "output must be a Zod schema" }),
+	input: zod.z.custom((val) => isStandardSchema(val), { message: "input must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)" }),
+	output: zod.z.custom((val) => isStandardSchema(val), { message: "output must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)" }),
 	activities: zod.z.record(identifierSchema, activityDefinitionSchema).optional(),
 	signals: zod.z.record(identifierSchema, signalDefinitionSchema).optional(),
 	queries: zod.z.record(identifierSchema, queryDefinitionSchema).optional(),

package/dist/index.d.cts

@@ -1,36 +1,37 @@
-import { z } from "zod";
+import { StandardSchemaV1 } from "@standard-schema/spec";
 
 //#region src/types.d.ts
 
 /**
  * Base types for validation schemas
- * Constrained to avoid implicit any types
+ * Any schema that implements the Standard Schema specification
+ * This includes Zod, Valibot, ArkType, and other compatible libraries
  */
-type AnyZodSchema = z.ZodType<unknown, unknown>;
+type AnySchema = StandardSchemaV1;
 /**
  * Definition of an activity
  */
-interface ActivityDefinition<TInput extends AnyZodSchema = AnyZodSchema, TOutput extends AnyZodSchema = AnyZodSchema> {
+interface ActivityDefinition<TInput extends AnySchema = AnySchema, TOutput extends AnySchema = AnySchema> {
   readonly input: TInput;
   readonly output: TOutput;
 }
 /**
  * Definition of a signal
  */
-interface SignalDefinition<TInput extends AnyZodSchema = AnyZodSchema> {
+interface SignalDefinition<TInput extends AnySchema = AnySchema> {
   readonly input: TInput;
 }
 /**
  * Definition of a query
  */
-interface QueryDefinition<TInput extends AnyZodSchema = AnyZodSchema, TOutput extends AnyZodSchema = AnyZodSchema> {
+interface QueryDefinition<TInput extends AnySchema = AnySchema, TOutput extends AnySchema = AnySchema> {
   readonly input: TInput;
   readonly output: TOutput;
 }
 /**
  * Definition of an update
  */
-interface UpdateDefinition<TInput extends AnyZodSchema = AnyZodSchema, TOutput extends AnyZodSchema = AnyZodSchema> {
+interface UpdateDefinition<TInput extends AnySchema = AnySchema, TOutput extends AnySchema = AnySchema> {
   readonly input: TInput;
   readonly output: TOutput;
 }
@@ -38,8 +39,8 @@ interface UpdateDefinition<TInput extends AnyZodSchema = AnyZodSchema, TOutput e
  * Definition of a workflow
  */
 interface WorkflowDefinition<TActivities extends Record<string, ActivityDefinition> = Record<string, ActivityDefinition>, TSignals extends Record<string, SignalDefinition> = Record<string, SignalDefinition>, TQueries extends Record<string, QueryDefinition> = Record<string, QueryDefinition>, TUpdates extends Record<string, UpdateDefinition> = Record<string, UpdateDefinition>> {
-  readonly input: AnyZodSchema;
-  readonly output: AnyZodSchema;
+  readonly input: AnySchema;
+  readonly output: AnySchema;
   readonly activities?: TActivities;
   readonly signals?: TSignals;
   readonly queries?: TQueries;
@@ -55,32 +56,32 @@ interface ContractDefinition<TWorkflows extends Record<string, WorkflowDefinitio
 }
 /**
  * Infer input type from a definition (worker perspective)
- * Worker receives z.output (after input schema parsing/transformation)
+ * Worker receives the output type (after input schema parsing/transformation)
  */
 type WorkerInferInput<T extends {
-  input: AnyZodSchema;
-}> = z.output<T["input"]>;
+  input: AnySchema;
+}> = StandardSchemaV1.InferOutput<T["input"]>;
 /**
  * Infer output type from a definition (worker perspective)
- * Worker returns z.input (before output schema parsing/transformation)
+ * Worker returns the input type (before output schema parsing/transformation)
  */
 type WorkerInferOutput<T extends {
-  output: AnyZodSchema;
-}> = z.input<T["output"]>;
+  output: AnySchema;
+}> = StandardSchemaV1.InferInput<T["output"]>;
 /**
  * Infer input type from a definition (client perspective)
- * Client sends z.input (before input schema parsing/transformation)
+ * Client sends the input type (before input schema parsing/transformation)
  */
 type ClientInferInput<T extends {
-  input: AnyZodSchema;
-}> = z.input<T["input"]>;
+  input: AnySchema;
+}> = StandardSchemaV1.InferInput<T["input"]>;
 /**
  * Infer output type from a definition (client perspective)
- * Client receives z.output (after output schema parsing/transformation)
+ * Client receives the output type (after output schema parsing/transformation)
  */
 type ClientInferOutput<T extends {
-  output: AnyZodSchema;
-}> = z.output<T["output"]>;
+  output: AnySchema;
+}> = StandardSchemaV1.InferOutput<T["output"]>;
 /**
  * WORKER PERSPECTIVE
  * Worker receives z.output of input (parsed data) and returns z.input of output (raw data)
@@ -348,4 +349,4 @@ declare const defineWorkflow: <TWorkflow extends WorkflowDefinition>(definition:
  */
 declare const defineContract: <TContract extends ContractDefinition>(definition: TContract) => TContract;
 //#endregion
-export { type ActivityDefinition, type ActivityHandler, type AnyZodSchema, type ClientInferActivities, type ClientInferActivity, type ClientInferInput, type ClientInferOutput, type ClientInferQuery, type ClientInferSignal, type ClientInferUpdate, type ClientInferWorkflow, type ClientInferWorkflowActivities, type ClientInferWorkflowContextActivities, type ClientInferWorkflowQueries, type ClientInferWorkflowSignals, type ClientInferWorkflowUpdates, type ClientInferWorkflows, type ContractDefinition, type InferActivityNames, type InferContractWorkflows, type InferWorkflowNames, type QueryDefinition, type SignalDefinition, type UpdateDefinition, type WorkerInferActivities, type WorkerInferActivity, type WorkerInferInput, type WorkerInferOutput, type WorkerInferQuery, type WorkerInferSignal, type WorkerInferUpdate, type WorkerInferWorkflow, type WorkerInferWorkflowActivities, type WorkerInferWorkflowContextActivities, type WorkerInferWorkflowQueries, type WorkerInferWorkflowSignals, type WorkerInferWorkflowUpdates, type WorkerInferWorkflows, type WorkflowActivityHandler, type WorkflowDefinition, defineActivity, defineContract, defineQuery, defineSignal, defineUpdate, defineWorkflow };
+export { type ActivityDefinition, type ActivityHandler, type AnySchema, type ClientInferActivities, type ClientInferActivity, type ClientInferInput, type ClientInferOutput, type ClientInferQuery, type ClientInferSignal, type ClientInferUpdate, type ClientInferWorkflow, type ClientInferWorkflowActivities, type ClientInferWorkflowContextActivities, type ClientInferWorkflowQueries, type ClientInferWorkflowSignals, type ClientInferWorkflowUpdates, type ClientInferWorkflows, type ContractDefinition, type InferActivityNames, type InferContractWorkflows, type InferWorkflowNames, type QueryDefinition, type SignalDefinition, type UpdateDefinition, type WorkerInferActivities, type WorkerInferActivity, type WorkerInferInput, type WorkerInferOutput, type WorkerInferQuery, type WorkerInferSignal, type WorkerInferUpdate, type WorkerInferWorkflow, type WorkerInferWorkflowActivities, type WorkerInferWorkflowContextActivities, type WorkerInferWorkflowQueries, type WorkerInferWorkflowSignals, type WorkerInferWorkflowUpdates, type WorkerInferWorkflows, type WorkflowActivityHandler, type WorkflowDefinition, defineActivity, defineContract, defineQuery, defineSignal, defineUpdate, defineWorkflow };

package/dist/index.d.mts

@@ -1,36 +1,37 @@
-import { z } from "zod";
+import { StandardSchemaV1 } from "@standard-schema/spec";
 
 //#region src/types.d.ts
 
 /**
  * Base types for validation schemas
- * Constrained to avoid implicit any types
+ * Any schema that implements the Standard Schema specification
+ * This includes Zod, Valibot, ArkType, and other compatible libraries
  */
-type AnyZodSchema = z.ZodType<unknown, unknown>;
+type AnySchema = StandardSchemaV1;
 /**
  * Definition of an activity
  */
-interface ActivityDefinition<TInput extends AnyZodSchema = AnyZodSchema, TOutput extends AnyZodSchema = AnyZodSchema> {
+interface ActivityDefinition<TInput extends AnySchema = AnySchema, TOutput extends AnySchema = AnySchema> {
   readonly input: TInput;
   readonly output: TOutput;
 }
 /**
  * Definition of a signal
  */
-interface SignalDefinition<TInput extends AnyZodSchema = AnyZodSchema> {
+interface SignalDefinition<TInput extends AnySchema = AnySchema> {
   readonly input: TInput;
 }
 /**
  * Definition of a query
  */
-interface QueryDefinition<TInput extends AnyZodSchema = AnyZodSchema, TOutput extends AnyZodSchema = AnyZodSchema> {
+interface QueryDefinition<TInput extends AnySchema = AnySchema, TOutput extends AnySchema = AnySchema> {
   readonly input: TInput;
   readonly output: TOutput;
 }
 /**
  * Definition of an update
  */
-interface UpdateDefinition<TInput extends AnyZodSchema = AnyZodSchema, TOutput extends AnyZodSchema = AnyZodSchema> {
+interface UpdateDefinition<TInput extends AnySchema = AnySchema, TOutput extends AnySchema = AnySchema> {
   readonly input: TInput;
   readonly output: TOutput;
 }
@@ -38,8 +39,8 @@ interface UpdateDefinition<TInput extends AnyZodSchema = AnyZodSchema, TOutput e
  * Definition of a workflow
  */
 interface WorkflowDefinition<TActivities extends Record<string, ActivityDefinition> = Record<string, ActivityDefinition>, TSignals extends Record<string, SignalDefinition> = Record<string, SignalDefinition>, TQueries extends Record<string, QueryDefinition> = Record<string, QueryDefinition>, TUpdates extends Record<string, UpdateDefinition> = Record<string, UpdateDefinition>> {
-  readonly input: AnyZodSchema;
-  readonly output: AnyZodSchema;
+  readonly input: AnySchema;
+  readonly output: AnySchema;
   readonly activities?: TActivities;
   readonly signals?: TSignals;
   readonly queries?: TQueries;
@@ -55,32 +56,32 @@ interface ContractDefinition<TWorkflows extends Record<string, WorkflowDefinitio
 }
 /**
  * Infer input type from a definition (worker perspective)
- * Worker receives z.output (after input schema parsing/transformation)
+ * Worker receives the output type (after input schema parsing/transformation)
  */
 type WorkerInferInput<T extends {
-  input: AnyZodSchema;
-}> = z.output<T["input"]>;
+  input: AnySchema;
+}> = StandardSchemaV1.InferOutput<T["input"]>;
 /**
  * Infer output type from a definition (worker perspective)
- * Worker returns z.input (before output schema parsing/transformation)
+ * Worker returns the input type (before output schema parsing/transformation)
  */
 type WorkerInferOutput<T extends {
-  output: AnyZodSchema;
-}> = z.input<T["output"]>;
+  output: AnySchema;
+}> = StandardSchemaV1.InferInput<T["output"]>;
 /**
  * Infer input type from a definition (client perspective)
- * Client sends z.input (before input schema parsing/transformation)
+ * Client sends the input type (before input schema parsing/transformation)
  */
 type ClientInferInput<T extends {
-  input: AnyZodSchema;
-}> = z.input<T["input"]>;
+  input: AnySchema;
+}> = StandardSchemaV1.InferInput<T["input"]>;
 /**
  * Infer output type from a definition (client perspective)
- * Client receives z.output (after output schema parsing/transformation)
+ * Client receives the output type (after output schema parsing/transformation)
  */
 type ClientInferOutput<T extends {
-  output: AnyZodSchema;
-}> = z.output<T["output"]>;
+  output: AnySchema;
+}> = StandardSchemaV1.InferOutput<T["output"]>;
 /**
  * WORKER PERSPECTIVE
  * Worker receives z.output of input (parsed data) and returns z.input of output (raw data)
@@ -348,4 +349,4 @@ declare const defineWorkflow: <TWorkflow extends WorkflowDefinition>(definition:
  */
 declare const defineContract: <TContract extends ContractDefinition>(definition: TContract) => TContract;
 //#endregion
-export { type ActivityDefinition, type ActivityHandler, type AnyZodSchema, type ClientInferActivities, type ClientInferActivity, type ClientInferInput, type ClientInferOutput, type ClientInferQuery, type ClientInferSignal, type ClientInferUpdate, type ClientInferWorkflow, type ClientInferWorkflowActivities, type ClientInferWorkflowContextActivities, type ClientInferWorkflowQueries, type ClientInferWorkflowSignals, type ClientInferWorkflowUpdates, type ClientInferWorkflows, type ContractDefinition, type InferActivityNames, type InferContractWorkflows, type InferWorkflowNames, type QueryDefinition, type SignalDefinition, type UpdateDefinition, type WorkerInferActivities, type WorkerInferActivity, type WorkerInferInput, type WorkerInferOutput, type WorkerInferQuery, type WorkerInferSignal, type WorkerInferUpdate, type WorkerInferWorkflow, type WorkerInferWorkflowActivities, type WorkerInferWorkflowContextActivities, type WorkerInferWorkflowQueries, type WorkerInferWorkflowSignals, type WorkerInferWorkflowUpdates, type WorkerInferWorkflows, type WorkflowActivityHandler, type WorkflowDefinition, defineActivity, defineContract, defineQuery, defineSignal, defineUpdate, defineWorkflow };
+export { type ActivityDefinition, type ActivityHandler, type AnySchema, type ClientInferActivities, type ClientInferActivity, type ClientInferInput, type ClientInferOutput, type ClientInferQuery, type ClientInferSignal, type ClientInferUpdate, type ClientInferWorkflow, type ClientInferWorkflowActivities, type ClientInferWorkflowContextActivities, type ClientInferWorkflowQueries, type ClientInferWorkflowSignals, type ClientInferWorkflowUpdates, type ClientInferWorkflows, type ContractDefinition, type InferActivityNames, type InferContractWorkflows, type InferWorkflowNames, type QueryDefinition, type SignalDefinition, type UpdateDefinition, type WorkerInferActivities, type WorkerInferActivity, type WorkerInferInput, type WorkerInferOutput, type WorkerInferQuery, type WorkerInferSignal, type WorkerInferUpdate, type WorkerInferWorkflow, type WorkerInferWorkflowActivities, type WorkerInferWorkflowContextActivities, type WorkerInferWorkflowQueries, type WorkerInferWorkflowSignals, type WorkerInferWorkflowUpdates, type WorkerInferWorkflows, type WorkflowActivityHandler, type WorkflowDefinition, defineActivity, defineContract, defineQuery, defineSignal, defineUpdate, defineWorkflow };

package/dist/index.mjs

@@ -2,6 +2,14 @@ import { z } from "zod";
 
 //#region src/builder.ts
 /**
+* Check if a value is a Standard Schema compatible schema
+*/
+function isStandardSchema(value) {
+	if (typeof value !== "object" && typeof value !== "function" || value === null || !("~standard" in value)) return false;
+	const standard = value["~standard"];
+	return typeof standard === "object" && standard !== null && standard["version"] === 1 && typeof standard["validate"] === "function";
+}
+/**
 * Schema for validating JavaScript identifiers (workflow names, activity names, etc.)
 * Allows: letters, digits, underscore, dollar sign
 * Must start with: letter, underscore, or dollar sign
@@ -26,36 +34,36 @@ const getCleanErrorMessage = (error) => {
 };
 /**
 * Schema for validating activity definitions
-* Checks that input and output are Zod schemas
+* Checks that input and output are Standard Schema compatible schemas
 */
 const activityDefinitionSchema = z.object({
-	input: z.instanceof(z.ZodType, { message: "input must be a Zod schema" }),
-	output: z.instanceof(z.ZodType, { message: "output must be a Zod schema" })
+	input: z.custom((val) => isStandardSchema(val), { message: "input must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)" }),
+	output: z.custom((val) => isStandardSchema(val), { message: "output must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)" })
 });
 /**
 * Schema for validating signal definitions
 */
-const signalDefinitionSchema = z.object({ input: z.instanceof(z.ZodType, { message: "input must be a Zod schema" }) });
+const signalDefinitionSchema = z.object({ input: z.custom((val) => isStandardSchema(val), { message: "input must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)" }) });
 /**
 * Schema for validating query definitions
 */
 const queryDefinitionSchema = z.object({
-	input: z.instanceof(z.ZodType, { message: "input must be a Zod schema" }),
-	output: z.instanceof(z.ZodType, { message: "output must be a Zod schema" })
+	input: z.custom((val) => isStandardSchema(val), { message: "input must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)" }),
+	output: z.custom((val) => isStandardSchema(val), { message: "output must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)" })
 });
 /**
 * Schema for validating update definitions
 */
 const updateDefinitionSchema = z.object({
-	input: z.instanceof(z.ZodType, { message: "input must be a Zod schema" }),
-	output: z.instanceof(z.ZodType, { message: "output must be a Zod schema" })
+	input: z.custom((val) => isStandardSchema(val), { message: "input must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)" }),
+	output: z.custom((val) => isStandardSchema(val), { message: "output must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)" })
 });
 /**
 * Schema for validating workflow definitions
 */
 const workflowDefinitionSchema = z.object({
-	input: z.instanceof(z.ZodType, { message: "input must be a Zod schema" }),
-	output: z.instanceof(z.ZodType, { message: "output must be a Zod schema" }),
+	input: z.custom((val) => isStandardSchema(val), { message: "input must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)" }),
+	output: z.custom((val) => isStandardSchema(val), { message: "output must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)" }),
 	activities: z.record(identifierSchema, activityDefinitionSchema).optional(),
 	signals: z.record(identifierSchema, signalDefinitionSchema).optional(),
 	queries: z.record(identifierSchema, queryDefinitionSchema).optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temporal-contract/contract",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "type": "module",
   "description": "Contract builder for temporal-contract",
   "homepage": "https://github.com/btravers/temporal-contract#readme",
@@ -35,15 +35,18 @@
     },
     "./package.json": "./package.json"
   },
+  "dependencies": {
+    "@standard-schema/spec": "1.0.0",
+    "zod": "4.1.13"
+  },
   "devDependencies": {
+    "@vitest/coverage-v8": "4.0.15",
+    "arktype": "2.1.28",
     "tsdown": "0.17.2",
     "typescript": "5.9.3",
+    "valibot": "1.2.0",
     "vitest": "4.0.15",
-    "zod": "4.1.13",
-    "@temporal-contract/tsconfig": "0.0.1"
-  },
-  "peerDependencies": {
-    "zod": "^4.0.0"
+    "@temporal-contract/tsconfig": "0.0.2"
   },
   "scripts": {
     "dev": "tsdown src/index.ts --format cjs,esm --dts --watch",

package/src/builder.spec.ts

@@ -622,4 +622,96 @@ describe("Contract Builder", () => {
       ).toThrow("Contract error");
     });
   });
+
+  describe("Standard Schema compatibility", () => {
+    it("should work with Valibot schemas", async () => {
+      const v = await import("valibot");
+
+      const contract = defineContract({
+        taskQueue: "test-queue",
+        workflows: {
+          processOrder: {
+            input: v.object({ orderId: v.string() }),
+            output: v.object({ status: v.string() }),
+          },
+        },
+        activities: {
+          sendEmail: {
+            input: v.object({ to: v.string(), subject: v.string() }),
+            output: v.object({ sent: v.boolean() }),
+          },
+        },
+      });
+
+      expect(contract.taskQueue).toBe("test-queue");
+      expect(contract.workflows.processOrder).toBeDefined();
+      expect(contract.activities?.sendEmail).toBeDefined();
+
+      // Verify Standard Schema properties exist
+      expect(contract.workflows.processOrder.input["~standard"]).toBeDefined();
+      expect(contract.workflows.processOrder.input["~standard"].version).toBe(1);
+      expect(contract.workflows.processOrder.input["~standard"].vendor).toBe("valibot");
+    });
+
+    it("should work with ArkType schemas", async () => {
+      const { type } = await import("arktype");
+
+      const contract = defineContract({
+        taskQueue: "test-queue",
+        workflows: {
+          processOrder: {
+            input: type({ orderId: "string" }),
+            output: type({ status: "string" }),
+          },
+        },
+        activities: {
+          validatePayment: {
+            input: type({ amount: "number" }),
+            output: type({ valid: "boolean" }),
+          },
+        },
+      });
+
+      expect(contract.taskQueue).toBe("test-queue");
+      expect(contract.workflows.processOrder).toBeDefined();
+      expect(contract.activities?.validatePayment).toBeDefined();
+
+      // Verify Standard Schema properties exist
+      expect(contract.workflows.processOrder.input["~standard"]).toBeDefined();
+      expect(contract.workflows.processOrder.input["~standard"].version).toBe(1);
+      expect(contract.workflows.processOrder.input["~standard"].vendor).toBe("arktype");
+    });
+
+    it("should work with mixed validation libraries", async () => {
+      const v = await import("valibot");
+      const { type } = await import("arktype");
+
+      const contract = defineContract({
+        taskQueue: "test-queue",
+        workflows: {
+          processZod: {
+            input: z.object({ id: z.string() }),
+            output: z.object({ result: z.string() }),
+          },
+          processValibot: {
+            input: v.object({ id: v.string() }),
+            output: v.object({ result: v.string() }),
+          },
+          processArkType: {
+            input: type({ id: "string" }),
+            output: type({ result: "string" }),
+          },
+        },
+      });
+
+      expect(contract.workflows.processZod).toBeDefined();
+      expect(contract.workflows.processValibot).toBeDefined();
+      expect(contract.workflows.processArkType).toBeDefined();
+
+      // Verify each has correct vendor
+      expect(contract.workflows.processZod.input["~standard"].vendor).toBe("zod");
+      expect(contract.workflows.processValibot.input["~standard"].vendor).toBe("valibot");
+      expect(contract.workflows.processArkType.input["~standard"].vendor).toBe("arktype");
+    });
+  });
 });

package/src/builder.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import type { StandardSchemaV1 } from "@standard-schema/spec";
 import type {
   ActivityDefinition,
   ContractDefinition,
@@ -8,6 +9,29 @@ import type {
   WorkflowDefinition,
 } from "./types.js";
 
+/**
+ * Check if a value is a Standard Schema compatible schema
+ */
+function isStandardSchema(value: unknown): value is StandardSchemaV1 {
+  // Standard Schema can be either an object or a function (e.g., ArkType)
+  if (
+    (typeof value !== "object" && typeof value !== "function") ||
+    value === null ||
+    !("~standard" in value)
+  ) {
+    return false;
+  }
+
+  const standard = (value as Record<string, unknown>)["~standard"];
+
+  return (
+    typeof standard === "object" &&
+    standard !== null &&
+    (standard as Record<string, unknown>)["version"] === 1 &&
+    typeof (standard as Record<string, unknown>)["validate"] === "function"
+  );
+}
+
 /**
  * Schema for validating JavaScript identifiers (workflow names, activity names, etc.)
  * Allows: letters, digits, underscore, dollar sign
@@ -52,14 +76,14 @@ const getCleanErrorMessage = (error: z.ZodError): string => {
 
 /**
  * Schema for validating activity definitions
- * Checks that input and output are Zod schemas
+ * Checks that input and output are Standard Schema compatible schemas
  */
 const activityDefinitionSchema = z.object({
-  input: z.instanceof(z.ZodType, {
-    message: "input must be a Zod schema",
+  input: z.custom<StandardSchemaV1>((val) => isStandardSchema(val), {
+    message: "input must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)",
   }),
-  output: z.instanceof(z.ZodType, {
-    message: "output must be a Zod schema",
+  output: z.custom<StandardSchemaV1>((val) => isStandardSchema(val), {
+    message: "output must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)",
   }),
 });
 
@@ -67,8 +91,8 @@ const activityDefinitionSchema = z.object({
  * Schema for validating signal definitions
  */
 const signalDefinitionSchema = z.object({
-  input: z.instanceof(z.ZodType, {
-    message: "input must be a Zod schema",
+  input: z.custom<StandardSchemaV1>((val) => isStandardSchema(val), {
+    message: "input must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)",
   }),
 });
 
@@ -76,11 +100,11 @@ const signalDefinitionSchema = z.object({
  * Schema for validating query definitions
  */
 const queryDefinitionSchema = z.object({
-  input: z.instanceof(z.ZodType, {
-    message: "input must be a Zod schema",
+  input: z.custom<StandardSchemaV1>((val) => isStandardSchema(val), {
+    message: "input must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)",
   }),
-  output: z.instanceof(z.ZodType, {
-    message: "output must be a Zod schema",
+  output: z.custom<StandardSchemaV1>((val) => isStandardSchema(val), {
+    message: "output must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)",
   }),
 });
 
@@ -88,11 +112,11 @@ const queryDefinitionSchema = z.object({
  * Schema for validating update definitions
  */
 const updateDefinitionSchema = z.object({
-  input: z.instanceof(z.ZodType, {
-    message: "input must be a Zod schema",
+  input: z.custom<StandardSchemaV1>((val) => isStandardSchema(val), {
+    message: "input must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)",
   }),
-  output: z.instanceof(z.ZodType, {
-    message: "output must be a Zod schema",
+  output: z.custom<StandardSchemaV1>((val) => isStandardSchema(val), {
+    message: "output must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)",
   }),
 });
 
@@ -100,11 +124,11 @@ const updateDefinitionSchema = z.object({
  * Schema for validating workflow definitions
  */
 const workflowDefinitionSchema = z.object({
-  input: z.instanceof(z.ZodType, {
-    message: "input must be a Zod schema",
+  input: z.custom<StandardSchemaV1>((val) => isStandardSchema(val), {
+    message: "input must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)",
   }),
-  output: z.instanceof(z.ZodType, {
-    message: "output must be a Zod schema",
+  output: z.custom<StandardSchemaV1>((val) => isStandardSchema(val), {
+    message: "output must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)",
   }),
   activities: z.record(identifierSchema, activityDefinitionSchema).optional(),
   signals: z.record(identifierSchema, signalDefinitionSchema).optional(),

package/src/index.ts

@@ -8,7 +8,7 @@ export {
 } from "./builder.js";
 
 export type {
-  AnyZodSchema,
+  AnySchema,
   ActivityDefinition,
   SignalDefinition,
   QueryDefinition,

package/src/types.ts

@@ -1,17 +1,18 @@
-import type { z } from "zod";
+import type { StandardSchemaV1 } from "@standard-schema/spec";
 
 /**
  * Base types for validation schemas
- * Constrained to avoid implicit any types
+ * Any schema that implements the Standard Schema specification
+ * This includes Zod, Valibot, ArkType, and other compatible libraries
  */
-export type AnyZodSchema = z.ZodType<unknown, unknown>;
+export type AnySchema = StandardSchemaV1;
 
 /**
  * Definition of an activity
  */
 export interface ActivityDefinition<
-  TInput extends AnyZodSchema = AnyZodSchema,
-  TOutput extends AnyZodSchema = AnyZodSchema,
+  TInput extends AnySchema = AnySchema,
+  TOutput extends AnySchema = AnySchema,
 > {
   readonly input: TInput;
   readonly output: TOutput;
@@ -20,7 +21,7 @@ export interface ActivityDefinition<
 /**
  * Definition of a signal
  */
-export interface SignalDefinition<TInput extends AnyZodSchema = AnyZodSchema> {
+export interface SignalDefinition<TInput extends AnySchema = AnySchema> {
   readonly input: TInput;
 }
 
@@ -28,8 +29,8 @@ export interface SignalDefinition<TInput extends AnyZodSchema = AnyZodSchema> {
  * Definition of a query
  */
 export interface QueryDefinition<
-  TInput extends AnyZodSchema = AnyZodSchema,
-  TOutput extends AnyZodSchema = AnyZodSchema,
+  TInput extends AnySchema = AnySchema,
+  TOutput extends AnySchema = AnySchema,
 > {
   readonly input: TInput;
   readonly output: TOutput;
@@ -39,8 +40,8 @@ export interface QueryDefinition<
  * Definition of an update
  */
 export interface UpdateDefinition<
-  TInput extends AnyZodSchema = AnyZodSchema,
-  TOutput extends AnyZodSchema = AnyZodSchema,
+  TInput extends AnySchema = AnySchema,
+  TOutput extends AnySchema = AnySchema,
 > {
   readonly input: TInput;
   readonly output: TOutput;
@@ -55,8 +56,8 @@ export interface WorkflowDefinition<
   TQueries extends Record<string, QueryDefinition> = Record<string, QueryDefinition>,
   TUpdates extends Record<string, UpdateDefinition> = Record<string, UpdateDefinition>,
 > {
-  readonly input: AnyZodSchema;
-  readonly output: AnyZodSchema;
+  readonly input: AnySchema;
+  readonly output: AnySchema;
   readonly activities?: TActivities;
   readonly signals?: TSignals;
   readonly queries?: TQueries;
@@ -77,27 +78,35 @@ export interface ContractDefinition<
 
 /**
  * Infer input type from a definition (worker perspective)
- * Worker receives z.output (after input schema parsing/transformation)
+ * Worker receives the output type (after input schema parsing/transformation)
  */
-export type WorkerInferInput<T extends { input: AnyZodSchema }> = z.output<T["input"]>;
+export type WorkerInferInput<T extends { input: AnySchema }> = StandardSchemaV1.InferOutput<
+  T["input"]
+>;
 
 /**
  * Infer output type from a definition (worker perspective)
- * Worker returns z.input (before output schema parsing/transformation)
+ * Worker returns the input type (before output schema parsing/transformation)
  */
-export type WorkerInferOutput<T extends { output: AnyZodSchema }> = z.input<T["output"]>;
+export type WorkerInferOutput<T extends { output: AnySchema }> = StandardSchemaV1.InferInput<
+  T["output"]
+>;
 
 /**
  * Infer input type from a definition (client perspective)
- * Client sends z.input (before input schema parsing/transformation)
+ * Client sends the input type (before input schema parsing/transformation)
  */
-export type ClientInferInput<T extends { input: AnyZodSchema }> = z.input<T["input"]>;
+export type ClientInferInput<T extends { input: AnySchema }> = StandardSchemaV1.InferInput<
+  T["input"]
+>;
 
 /**
  * Infer output type from a definition (client perspective)
- * Client receives z.output (after output schema parsing/transformation)
+ * Client receives the output type (after output schema parsing/transformation)
  */
-export type ClientInferOutput<T extends { output: AnyZodSchema }> = z.output<T["output"]>;
+export type ClientInferOutput<T extends { output: AnySchema }> = StandardSchemaV1.InferOutput<
+  T["output"]
+>;
 
 /**
  * WORKER PERSPECTIVE

package/vitest.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    reporters: ["default"],
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "json", "json-summary", "html"],
+      include: ["src/**"],
+    },
+  },
+});