@temporal-contract/client 0.0.2 → 0.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temporal-contract/client",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "type": "module",
   "description": "Client utilities for consuming temporal-contract workflows",
   "homepage": "https://github.com/btravers/temporal-contract#readme",
@@ -36,9 +36,12 @@
     },
     "./package.json": "./package.json"
   },
+  "files": [
+    "dist"
+  ],
   "dependencies": {
     "@standard-schema/spec": "1.0.0",
-    "@temporal-contract/contract": "0.0.2"
+    "@temporal-contract/contract": "0.0.3"
   },
   "devDependencies": {
     "@temporalio/client": "1.13.2",
@@ -48,7 +51,7 @@
     "typescript": "5.9.3",
     "vitest": "4.0.15",
     "zod": "4.1.13",
-    "@temporal-contract/tsconfig": "0.0.2"
+    "@temporal-contract/tsconfig": "0.0.3"
   },
   "peerDependencies": {
     "@temporalio/client": ">=1.13.0 <2.0.0"

package/.turbo/turbo-build.log

@@ -1,17 +0,0 @@
-
-> @temporal-contract/client@0.0.2 build /home/runner/work/temporal-contract/temporal-contract/packages/client
-> 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  8.83 kB │ gzip: 1.84 kB
-ℹ [CJS] 1 files, total: 8.83 kB
-ℹ [CJS] dist/index.d.cts  7.02 kB │ gzip: 1.67 kB
-ℹ [CJS] 1 files, total: 7.02 kB
-✔ Build complete in 4263ms
-ℹ [ESM] dist/index.mjs    8.60 kB │ gzip: 1.81 kB
-ℹ [ESM] dist/index.d.mts  7.02 kB │ gzip: 1.67 kB
-ℹ [ESM] 2 files, total: 15.62 kB
-✔ Build complete in 4270ms

package/CHANGELOG.md

@@ -1,9 +0,0 @@
-# @temporal-contract/client
-
-## 0.0.2
-
-### Patch Changes
-
-- Release version 0.0.2
-- Updated dependencies
-  - @temporal-contract/contract@0.0.2

package/src/client.spec.ts

@@ -1,564 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { z } from "zod";
-import { defineContract } from "@temporal-contract/contract";
-import { TypedClient } from "./client.js";
-import {
-  WorkflowNotFoundError,
-  WorkflowValidationError,
-  QueryValidationError,
-  SignalValidationError,
-  UpdateValidationError,
-} from "./errors.js";
-
-// Create mock workflow object
-const createMockWorkflow = () => ({
-  start: vi.fn(),
-  execute: vi.fn(),
-  getHandle: vi.fn(),
-});
-
-// Mock Temporal Client
-const mockWorkflow = createMockWorkflow();
-
-vi.mock("@temporalio/client", () => ({
-  Client: class {
-    workflow = mockWorkflow;
-  },
-  WorkflowHandle: vi.fn(),
-}));
-
-describe("TypedClient", () => {
-  const testContract = defineContract({
-    taskQueue: "test-queue",
-    workflows: {
-      testWorkflow: {
-        input: z.tuple([z.string(), z.number()]),
-        output: z.object({ result: z.string() }),
-        queries: {
-          getStatus: {
-            input: z.tuple([]),
-            output: z.string(),
-          },
-        },
-        signals: {
-          updateProgress: {
-            input: z.tuple([z.number()]),
-          },
-        },
-        updates: {
-          setConfig: {
-            input: z.tuple([z.object({ value: z.string() })]),
-            output: z.boolean(),
-          },
-        },
-      },
-      simpleWorkflow: {
-        input: z.tuple([z.string()]),
-        output: z.string(),
-      },
-    },
-  });
-
-  let typedClient: TypedClient<typeof testContract>;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    typedClient = TypedClient.create(testContract, { namespace: "default" });
-  });
-
-  describe("TypedClient.create", () => {
-    it("should create a typed client instance", () => {
-      expect(typedClient).toBeInstanceOf(TypedClient);
-    });
-  });
-
-  describe("startWorkflow", () => {
-    it("should start a workflow with valid input", async () => {
-      const mockHandle = {
-        workflowId: "test-123",
-        result: vi.fn().mockResolvedValue({ result: "success" }),
-        query: vi.fn(),
-        signal: vi.fn(),
-        executeUpdate: vi.fn(),
-        terminate: vi.fn(),
-        cancel: vi.fn(),
-      };
-
-      mockWorkflow.start.mockResolvedValue(mockHandle);
-
-      const handle = await typedClient.startWorkflow("testWorkflow", {
-        workflowId: "test-123",
-        args: ["hello", 42],
-      });
-
-      expect(mockWorkflow.start).toHaveBeenCalledWith("testWorkflow", {
-        workflowId: "test-123",
-        taskQueue: "test-queue",
-        args: [["hello", 42]],
-      });
-
-      expect(handle.workflowId).toBe("test-123");
-    });
-
-    it("should throw WorkflowNotFoundError for unknown workflow", async () => {
-      await expect(
-        // @ts-expect-error Testing invalid workflow name
-        typedClient.startWorkflow("unknownWorkflow", {
-          workflowId: "test-123",
-          args: ["test"],
-        }),
-      ).rejects.toThrow(WorkflowNotFoundError);
-    });
-
-    it("should throw WorkflowValidationError for invalid input", async () => {
-      await expect(
-        typedClient.startWorkflow("testWorkflow", {
-          workflowId: "test-123",
-          // @ts-expect-error Testing invalid input
-          args: ["hello", "not-a-number"],
-        }),
-      ).rejects.toThrow(WorkflowValidationError);
-    });
-
-    it("should pass Temporal options to underlying client", async () => {
-      const mockHandle = {
-        workflowId: "test-123",
-        result: vi.fn().mockResolvedValue({ result: "success" }),
-        query: vi.fn(),
-        signal: vi.fn(),
-        executeUpdate: vi.fn(),
-        terminate: vi.fn(),
-        cancel: vi.fn(),
-      };
-
-      mockWorkflow.start.mockResolvedValue(mockHandle);
-
-      await typedClient.startWorkflow("testWorkflow", {
-        workflowId: "test-123",
-        args: ["hello", 42],
-        workflowExecutionTimeout: "1 day",
-        retry: { maximumAttempts: 3 },
-        memo: { userId: "user-123" },
-      });
-
-      expect(mockWorkflow.start).toHaveBeenCalledWith("testWorkflow", {
-        workflowId: "test-123",
-        taskQueue: "test-queue",
-        args: [["hello", 42]],
-        workflowExecutionTimeout: "1 day",
-        retry: { maximumAttempts: 3 },
-        memo: { userId: "user-123" },
-      });
-    });
-  });
-
-  describe("executeWorkflow", () => {
-    it("should execute a workflow with valid input and output", async () => {
-      mockWorkflow.execute.mockResolvedValue({ result: "success" });
-
-      const result = await typedClient.executeWorkflow("testWorkflow", {
-        workflowId: "test-123",
-        args: ["hello", 42],
-      });
-
-      expect(mockWorkflow.execute).toHaveBeenCalledWith("testWorkflow", {
-        workflowId: "test-123",
-        taskQueue: "test-queue",
-        args: [["hello", 42]],
-      });
-
-      expect(result).toEqual({ result: "success" });
-    });
-
-    it("should throw WorkflowNotFoundError for unknown workflow", async () => {
-      await expect(
-        // @ts-expect-error Testing invalid workflow name
-        typedClient.executeWorkflow("unknownWorkflow", {
-          workflowId: "test-123",
-          args: ["test"],
-        }),
-      ).rejects.toThrow(WorkflowNotFoundError);
-    });
-
-    it("should throw WorkflowValidationError for invalid input", async () => {
-      await expect(
-        typedClient.executeWorkflow("testWorkflow", {
-          workflowId: "test-123",
-          // @ts-expect-error Testing invalid input
-          args: ["hello", "not-a-number"],
-        }),
-      ).rejects.toThrow(WorkflowValidationError);
-    });
-
-    it("should throw WorkflowValidationError for invalid output", async () => {
-      mockWorkflow.execute.mockResolvedValue({ wrongField: "value" });
-
-      await expect(
-        typedClient.executeWorkflow("testWorkflow", {
-          workflowId: "test-123",
-          args: ["hello", 42],
-        }),
-      ).rejects.toThrow(WorkflowValidationError);
-    });
-
-    it("should pass Temporal options to underlying client", async () => {
-      mockWorkflow.execute.mockResolvedValue({ result: "success" });
-
-      await typedClient.executeWorkflow("testWorkflow", {
-        workflowId: "test-123",
-        args: ["hello", 42],
-        workflowExecutionTimeout: "1 day",
-        cronSchedule: "0 0 * * *",
-      });
-
-      expect(mockWorkflow.execute).toHaveBeenCalledWith("testWorkflow", {
-        workflowId: "test-123",
-        taskQueue: "test-queue",
-        args: [["hello", 42]],
-        workflowExecutionTimeout: "1 day",
-        cronSchedule: "0 0 * * *",
-      });
-    });
-  });
-
-  describe("getHandle", () => {
-    it("should get a handle to an existing workflow", async () => {
-      const mockHandle = {
-        workflowId: "test-123",
-        result: vi.fn().mockResolvedValue({ result: "success" }),
-        query: vi.fn(),
-        signal: vi.fn(),
-        executeUpdate: vi.fn(),
-        terminate: vi.fn(),
-        cancel: vi.fn(),
-      };
-
-      mockWorkflow.getHandle.mockReturnValue(mockHandle);
-
-      const handle = await typedClient.getHandle("testWorkflow", "test-123");
-
-      expect(mockWorkflow.getHandle).toHaveBeenCalledWith("test-123");
-      expect(handle.workflowId).toBe("test-123");
-    });
-
-    it("should throw WorkflowNotFoundError for unknown workflow", async () => {
-      await expect(
-        // @ts-expect-error Testing invalid workflow name
-        typedClient.getHandle("unknownWorkflow", "test-123"),
-      ).rejects.toThrow(WorkflowNotFoundError);
-    });
-  });
-
-  describe("TypedWorkflowHandle", () => {
-    let mockHandle: {
-      workflowId: string;
-      result: ReturnType<typeof vi.fn>;
-      query: ReturnType<typeof vi.fn>;
-      signal: ReturnType<typeof vi.fn>;
-      executeUpdate: ReturnType<typeof vi.fn>;
-      terminate: ReturnType<typeof vi.fn>;
-      cancel: ReturnType<typeof vi.fn>;
-      describe?: ReturnType<typeof vi.fn>;
-      fetchHistory?: ReturnType<typeof vi.fn>;
-    };
-
-    beforeEach(async () => {
-      mockHandle = {
-        workflowId: "test-123",
-        result: vi.fn().mockResolvedValue({ result: "success" }),
-        query: vi.fn(),
-        signal: vi.fn(),
-        executeUpdate: vi.fn(),
-        terminate: vi.fn(),
-        cancel: vi.fn(),
-        describe: vi.fn(),
-        fetchHistory: vi.fn(),
-      };
-
-      mockWorkflow.start.mockResolvedValue(mockHandle);
-    });
-
-    describe("result", () => {
-      it("should return validated workflow result", async () => {
-        const handle = await typedClient.startWorkflow("testWorkflow", {
-          workflowId: "test-123",
-          args: ["hello", 42],
-        });
-
-        const result = await handle.result();
-
-        expect(mockHandle.result).toHaveBeenCalled();
-        expect(result).toEqual({ result: "success" });
-      });
-
-      it("should throw WorkflowValidationError for invalid output", async () => {
-        mockHandle.result.mockResolvedValue({ wrongField: "value" });
-
-        const handle = await typedClient.startWorkflow("testWorkflow", {
-          workflowId: "test-123",
-          args: ["hello", 42],
-        });
-
-        await expect(handle.result()).rejects.toThrow(WorkflowValidationError);
-      });
-    });
-
-    describe("queries", () => {
-      it("should execute typed query with valid input and output", async () => {
-        mockHandle.query.mockResolvedValue("running");
-
-        const handle = await typedClient.startWorkflow("testWorkflow", {
-          workflowId: "test-123",
-          args: ["hello", 42],
-        });
-
-        const status = await handle.queries.getStatus([]);
-
-        expect(mockHandle.query).toHaveBeenCalledWith("getStatus", []);
-        expect(status).toBe("running");
-      });
-
-      it("should throw QueryValidationError for invalid input", async () => {
-        const handle = await typedClient.startWorkflow("testWorkflow", {
-          workflowId: "test-123",
-          args: ["hello", 42],
-        });
-
-        await expect(
-          // @ts-expect-error Testing invalid query input
-          handle.queries.getStatus(["invalid"]),
-        ).rejects.toThrow(QueryValidationError);
-      });
-
-      it("should throw QueryValidationError for invalid output", async () => {
-        mockHandle.query.mockResolvedValue(123);
-
-        const handle = await typedClient.startWorkflow("testWorkflow", {
-          workflowId: "test-123",
-          args: ["hello", 42],
-        });
-
-        await expect(handle.queries.getStatus([])).rejects.toThrow(QueryValidationError);
-      });
-    });
-
-    describe("signals", () => {
-      it("should send typed signal with valid input", async () => {
-        const handle = await typedClient.startWorkflow("testWorkflow", {
-          workflowId: "test-123",
-          args: ["hello", 42],
-        });
-
-        await handle.signals.updateProgress([50]);
-
-        expect(mockHandle.signal).toHaveBeenCalledWith("updateProgress", [50]);
-      });
-
-      it("should throw SignalValidationError for invalid input", async () => {
-        const handle = await typedClient.startWorkflow("testWorkflow", {
-          workflowId: "test-123",
-          args: ["hello", 42],
-        });
-
-        await expect(
-          // @ts-expect-error Testing invalid signal input
-          handle.signals.updateProgress(["not-a-number"]),
-        ).rejects.toThrow(SignalValidationError);
-      });
-    });
-
-    describe("updates", () => {
-      it("should execute typed update with valid input and output", async () => {
-        mockHandle.executeUpdate.mockResolvedValue(true);
-
-        const handle = await typedClient.startWorkflow("testWorkflow", {
-          workflowId: "test-123",
-          args: ["hello", 42],
-        });
-
-        const result = await handle.updates.setConfig([{ value: "new-config" }]);
-
-        expect(mockHandle.executeUpdate).toHaveBeenCalledWith("setConfig", {
-          args: [[{ value: "new-config" }]],
-        });
-        expect(result).toBe(true);
-      });
-
-      it("should throw UpdateValidationError for invalid input", async () => {
-        const handle = await typedClient.startWorkflow("testWorkflow", {
-          workflowId: "test-123",
-          args: ["hello", 42],
-        });
-
-        await expect(
-          // @ts-expect-error Testing invalid update input
-          handle.updates.setConfig([{ wrongField: "value" }]),
-        ).rejects.toThrow(UpdateValidationError);
-      });
-
-      it("should throw UpdateValidationError for invalid output", async () => {
-        mockHandle.executeUpdate.mockResolvedValue("not-a-boolean");
-
-        const handle = await typedClient.startWorkflow("testWorkflow", {
-          workflowId: "test-123",
-          args: ["hello", 42],
-        });
-
-        await expect(handle.updates.setConfig([{ value: "new-config" }])).rejects.toThrow(
-          UpdateValidationError,
-        );
-      });
-    });
-
-    describe("terminate", () => {
-      it("should terminate workflow", async () => {
-        const handle = await typedClient.startWorkflow("testWorkflow", {
-          workflowId: "test-123",
-          args: ["hello", 42],
-        });
-
-        await handle.terminate("test reason");
-
-        expect(mockHandle.terminate).toHaveBeenCalledWith("test reason");
-      });
-
-      it("should terminate workflow without reason", async () => {
-        const handle = await typedClient.startWorkflow("testWorkflow", {
-          workflowId: "test-123",
-          args: ["hello", 42],
-        });
-
-        await handle.terminate();
-
-        expect(mockHandle.terminate).toHaveBeenCalledWith(undefined);
-      });
-    });
-
-    describe("cancel", () => {
-      it("should cancel workflow", async () => {
-        const handle = await typedClient.startWorkflow("testWorkflow", {
-          workflowId: "test-123",
-          args: ["hello", 42],
-        });
-
-        await handle.cancel();
-
-        expect(mockHandle.cancel).toHaveBeenCalled();
-      });
-    });
-
-    describe("describe", () => {
-      it("should call describe on underlying handle", async () => {
-        const mockDescription = {
-          workflowExecutionInfo: {
-            workflowExecution: { workflowId: "test-123", runId: "run-123" },
-            type: { name: "testWorkflow" },
-            startTime: new Date(),
-            status: "RUNNING" as const,
-          },
-        };
-
-        mockHandle.describe = vi.fn().mockResolvedValue(mockDescription);
-
-        const handle = await typedClient.startWorkflow("testWorkflow", {
-          workflowId: "test-123",
-          args: ["hello", 42],
-        });
-
-        const description = await handle.describe();
-
-        expect(mockHandle.describe).toHaveBeenCalled();
-        expect(description).toEqual(mockDescription);
-      });
-    });
-
-    describe("fetchHistory", () => {
-      it("should call fetchHistory on underlying handle", async () => {
-        const mockHistoryIterator = (async function* () {
-          yield { eventId: 1n, eventType: "WorkflowExecutionStarted" };
-          yield { eventId: 2n, eventType: "WorkflowTaskScheduled" };
-        })();
-
-        mockHandle.fetchHistory = vi.fn().mockReturnValue(mockHistoryIterator);
-
-        const handle = await typedClient.startWorkflow("testWorkflow", {
-          workflowId: "test-123",
-          args: ["hello", 42],
-        });
-
-        const history = handle.fetchHistory();
-
-        expect(mockHandle.fetchHistory).toHaveBeenCalled();
-        expect(history).toBeDefined();
-      });
-    });
-  });
-
-  describe("edge cases", () => {
-    it("should handle workflow with no queries", async () => {
-      const mockHandle = {
-        workflowId: "simple-123",
-        result: vi.fn().mockResolvedValue("done"),
-        query: vi.fn(),
-        signal: vi.fn(),
-        executeUpdate: vi.fn(),
-        terminate: vi.fn(),
-        cancel: vi.fn(),
-      };
-
-      mockWorkflow.start.mockResolvedValue(mockHandle);
-
-      const handle = await typedClient.startWorkflow("simpleWorkflow", {
-        workflowId: "simple-123",
-        args: ["test"],
-      });
-
-      expect(handle.queries).toBeDefined();
-      expect(Object.keys(handle.queries)).toHaveLength(0);
-    });
-
-    it("should handle workflow with no signals", async () => {
-      const mockHandle = {
-        workflowId: "simple-123",
-        result: vi.fn().mockResolvedValue("done"),
-        query: vi.fn(),
-        signal: vi.fn(),
-        executeUpdate: vi.fn(),
-        terminate: vi.fn(),
-        cancel: vi.fn(),
-      };
-
-      mockWorkflow.start.mockResolvedValue(mockHandle);
-
-      const handle = await typedClient.startWorkflow("simpleWorkflow", {
-        workflowId: "simple-123",
-        args: ["test"],
-      });
-
-      expect(handle.signals).toBeDefined();
-      expect(Object.keys(handle.signals)).toHaveLength(0);
-    });
-
-    it("should handle workflow with no updates", async () => {
-      const mockHandle = {
-        workflowId: "simple-123",
-        result: vi.fn().mockResolvedValue("done"),
-        query: vi.fn(),
-        signal: vi.fn(),
-        executeUpdate: vi.fn(),
-        terminate: vi.fn(),
-        cancel: vi.fn(),
-      };
-
-      mockWorkflow.start.mockResolvedValue(mockHandle);
-
-      const handle = await typedClient.startWorkflow("simpleWorkflow", {
-        workflowId: "simple-123",
-        args: ["test"],
-      });
-
-      expect(handle.updates).toBeDefined();
-      expect(Object.keys(handle.updates)).toHaveLength(0);
-    });
-  });
-});

package/src/client.ts

@@ -1,366 +0,0 @@
-import { Client, WorkflowHandle } from "@temporalio/client";
-import type { ClientOptions, WorkflowStartOptions, WorkflowOptions } from "@temporalio/client";
-import type {
-  ClientInferInput,
-  ClientInferOutput,
-  ClientInferWorkflowQueries,
-  ClientInferWorkflowSignals,
-  ClientInferWorkflowUpdates,
-  ContractDefinition,
-  WorkflowDefinition,
-  QueryDefinition,
-  SignalDefinition,
-  UpdateDefinition,
-} from "@temporal-contract/contract";
-import {
-  WorkflowNotFoundError,
-  WorkflowValidationError,
-  QueryValidationError,
-  SignalValidationError,
-  UpdateValidationError,
-} from "./errors.js";
-
-/**
- * Extended options for starting workflows with Temporal-specific features
- * Combines required workflowId with optional Temporal workflow options
- */
-export type TypedWorkflowStartOptions = Pick<
-  WorkflowStartOptions,
-  | "workflowId"
-  | "workflowIdReusePolicy"
-  | "workflowExecutionTimeout"
-  | "workflowRunTimeout"
-  | "workflowTaskTimeout"
-  | "retry"
-  | "memo"
-  | "searchAttributes"
-  | "cronSchedule"
-> &
-  Pick<WorkflowOptions, "workflowId">;
-
-/**
- * Typed workflow handle with validated results, queries, signals and updates
- */
-export interface TypedWorkflowHandle<TWorkflow extends WorkflowDefinition> {
-  workflowId: string;
-
-  /**
-   * Type-safe queries based on workflow definition
-   */
-  queries: ClientInferWorkflowQueries<TWorkflow>;
-
-  /**
-   * Type-safe signals based on workflow definition
-   */
-  signals: ClientInferWorkflowSignals<TWorkflow>;
-
-  /**
-   * Type-safe updates based on workflow definition
-   */
-  updates: ClientInferWorkflowUpdates<TWorkflow>;
-
-  result: () => Promise<ClientInferOutput<TWorkflow>>;
-  terminate: (reason?: string) => Promise<void>;
-  cancel: () => Promise<void>;
-
-  /**
-   * Get workflow execution description including status and metadata
-   *
-   * @example
-   * ```ts
-   * const handle = await client.getHandle('processOrder', 'order-123');
-   * const description = await handle.describe();
-   * console.log(description.workflowExecutionInfo.status); // RUNNING, COMPLETED, etc.
-   * ```
-   */
-  describe: () => ReturnType<WorkflowHandle["describe"]>;
-
-  /**
-   * Fetch the workflow execution history
-   *
-   * @example
-   * ```ts
-   * const handle = await client.getHandle('processOrder', 'order-123');
-   * const history = handle.fetchHistory();
-   * for await (const event of history) {
-   *   console.log(event);
-   * }
-   * ```
-   */
-  fetchHistory: () => ReturnType<WorkflowHandle["fetchHistory"]>;
-}
-
-/**
- * Typed Temporal client based on a contract
- *
- * Provides type-safe methods to start and execute workflows
- * defined in the contract.
- */
-export class TypedClient<TContract extends ContractDefinition> {
-  private constructor(
-    private readonly contract: TContract,
-    private readonly client: Client,
-  ) {}
-
-  /**
-   * Create a typed Temporal client from a contract
-   *
-   * @example
-   * ```ts
-   * const connection = await Connection.connect();
-   * const client = TypedClient.create(myContract, {
-   *   connection,
-   *   namespace: 'default',
-   * });
-   *
-   * const result = await client.executeWorkflow('processOrder', {
-   *   workflowId: 'order-123',
-   *   args: [...],
-   * });
-   * ```
-   */
-  static create<TContract extends ContractDefinition>(
-    contract: TContract,
-    options: ClientOptions,
-  ): TypedClient<TContract> {
-    const client = new Client(options);
-    return new TypedClient(contract, client);
-  }
-
-  /**
-   * Start a workflow and return a typed handle
-   *
-   * @example
-   * ```ts
-   * const handle = await client.startWorkflow('processOrder', {
-   *   workflowId: 'order-123',
-   *   args: ['ORD-123', 'CUST-456', [{ productId: 'PROD-1', quantity: 2 }]],
-   *   workflowExecutionTimeout: '1 day',
-   *   retry: { maximumAttempts: 3 },
-   * });
-   *
-   * const result = await handle.result();
-   * ```
-   */
-  async startWorkflow<TWorkflowName extends keyof TContract["workflows"]>(
-    workflowName: TWorkflowName,
-    {
-      args,
-      ...temporalOptions
-    }: TypedWorkflowStartOptions & {
-      args: ClientInferInput<TContract["workflows"][TWorkflowName]>;
-    },
-  ): Promise<TypedWorkflowHandle<TContract["workflows"][TWorkflowName]>> {
-    const definition = this.contract.workflows[workflowName as string];
-
-    if (!definition) {
-      throw new WorkflowNotFoundError(
-        String(workflowName),
-        Object.keys(this.contract.workflows) as string[],
-      );
-    }
-
-    // Validate input with Standard Schema
-    const inputResult = await definition.input["~standard"].validate(args);
-    if (inputResult.issues) {
-      throw new WorkflowValidationError(String(workflowName), "input", inputResult.issues);
-    }
-    const validatedInput = inputResult.value as ClientInferInput<
-      TContract["workflows"][TWorkflowName]
-    >;
-
-    // Start workflow (Temporal expects args as array, so wrap single parameter)
-    const handle = await this.client.workflow.start(workflowName as string, {
-      ...temporalOptions,
-      taskQueue: this.contract.taskQueue,
-      args: [validatedInput],
-    });
-
-    return this.createTypedHandle(handle, definition) as TypedWorkflowHandle<
-      TContract["workflows"][TWorkflowName]
-    >;
-  }
-
-  /**
-   * Execute a workflow (start and wait for result)
-   *
-   * @example
-   * ```ts
-   * const result = await client.executeWorkflow('processOrder', {
-   *   workflowId: 'order-123',
-   *   args: ['ORD-123', 'CUST-456', [{ productId: 'PROD-1', quantity: 2 }]],
-   *   workflowExecutionTimeout: '1 day',
-   *   retry: { maximumAttempts: 3 },
-   * });
-   *
-   * console.log(result.status); // fully typed!
-   * ```
-   */
-  async executeWorkflow<TWorkflowName extends keyof TContract["workflows"]>(
-    workflowName: TWorkflowName,
-    {
-      args,
-      ...temporalOptions
-    }: TypedWorkflowStartOptions & {
-      args: ClientInferInput<TContract["workflows"][TWorkflowName]>;
-    },
-  ): Promise<ClientInferOutput<TContract["workflows"][TWorkflowName]>> {
-    const definition = this.contract.workflows[workflowName as string];
-
-    if (!definition) {
-      throw new WorkflowNotFoundError(
-        String(workflowName),
-        Object.keys(this.contract.workflows) as string[],
-      );
-    }
-
-    // Validate input with Standard Schema
-    const inputResult = await definition.input["~standard"].validate(args);
-    if (inputResult.issues) {
-      throw new WorkflowValidationError(String(workflowName), "input", inputResult.issues);
-    }
-    const validatedInput = inputResult.value as ClientInferInput<
-      TContract["workflows"][TWorkflowName]
-    >;
-
-    // Execute workflow (Temporal expects args as array, so wrap single parameter)
-    const result = await this.client.workflow.execute(workflowName as string, {
-      ...temporalOptions,
-      taskQueue: this.contract.taskQueue,
-      args: [validatedInput],
-    });
-
-    // Validate output with Standard Schema
-    const outputResult = await definition.output["~standard"].validate(result);
-    if (outputResult.issues) {
-      throw new WorkflowValidationError(String(workflowName), "output", outputResult.issues);
-    }
-
-    return outputResult.value as ClientInferOutput<TContract["workflows"][TWorkflowName]>;
-  }
-
-  /**
-   * Get a handle to an existing workflow
-   *
-   * @example
-   * ```ts
-   * const handle = await client.getHandle('processOrder', 'order-123');
-   * const result = await handle.result();
-   * ```
-   */
-  async getHandle<TWorkflowName extends keyof TContract["workflows"]>(
-    workflowName: TWorkflowName,
-    workflowId: string,
-  ): Promise<TypedWorkflowHandle<TContract["workflows"][TWorkflowName]>> {
-    const definition = this.contract.workflows[workflowName as string];
-
-    if (!definition) {
-      throw new WorkflowNotFoundError(
-        String(workflowName),
-        Object.keys(this.contract.workflows) as string[],
-      );
-    }
-
-    const handle = this.client.workflow.getHandle(workflowId);
-    return this.createTypedHandle(handle, definition) as TypedWorkflowHandle<
-      TContract["workflows"][TWorkflowName]
-    >;
-  }
-
-  private createTypedHandle<TWorkflow extends WorkflowDefinition>(
-    handle: WorkflowHandle,
-    definition: TWorkflow,
-  ): TypedWorkflowHandle<TWorkflow> {
-    // Create typed queries proxy
-    const queries = {} as ClientInferWorkflowQueries<TWorkflow>;
-    for (const [queryName, queryDef] of Object.entries(definition.queries ?? {}) as Array<
-      [string, QueryDefinition]
-    >) {
-      (queries as Record<string, unknown>)[queryName] = async (
-        args: ClientInferInput<typeof queryDef>,
-      ) => {
-        const inputResult = await queryDef.input["~standard"].validate(args);
-        if (inputResult.issues) {
-          throw new QueryValidationError(queryName, "input", inputResult.issues);
-        }
-
-        const result = await handle.query(queryName as string, inputResult.value);
-
-        const outputResult = await queryDef.output["~standard"].validate(result);
-        if (outputResult.issues) {
-          throw new QueryValidationError(queryName, "output", outputResult.issues);
-        }
-
-        return outputResult.value;
-      };
-    }
-
-    // Create typed signals proxy
-    const signals = {} as ClientInferWorkflowSignals<TWorkflow>;
-    for (const [signalName, signalDef] of Object.entries(definition.signals ?? {}) as Array<
-      [string, SignalDefinition]
-    >) {
-      (signals as Record<string, unknown>)[signalName] = async (
-        args: ClientInferInput<typeof signalDef>,
-      ) => {
-        const inputResult = await signalDef.input["~standard"].validate(args);
-        if (inputResult.issues) {
-          throw new SignalValidationError(signalName, inputResult.issues);
-        }
-        await handle.signal(signalName as string, inputResult.value);
-      };
-    }
-
-    // Create typed updates proxy
-    const updates = {} as ClientInferWorkflowUpdates<TWorkflow>;
-    for (const [updateName, updateDef] of Object.entries(definition.updates ?? {}) as Array<
-      [string, UpdateDefinition]
-    >) {
-      (updates as Record<string, unknown>)[updateName] = async (
-        args: ClientInferInput<typeof updateDef>,
-      ) => {
-        const inputResult = await updateDef.input["~standard"].validate(args);
-        if (inputResult.issues) {
-          throw new UpdateValidationError(updateName, "input", inputResult.issues);
-        }
-
-        const result = await handle.executeUpdate(updateName as string, {
-          args: [inputResult.value],
-        });
-
-        const outputResult = await updateDef.output["~standard"].validate(result);
-        if (outputResult.issues) {
-          throw new UpdateValidationError(updateName, "output", outputResult.issues);
-        }
-
-        return outputResult.value;
-      };
-    }
-
-    const typedHandle: TypedWorkflowHandle<TWorkflow> = {
-      workflowId: handle.workflowId,
-      queries,
-      signals,
-      updates,
-      result: async () => {
-        const result = await handle.result();
-        // Validate output with Standard Schema
-        const outputResult = await definition.output["~standard"].validate(result);
-        if (outputResult.issues) {
-          throw new WorkflowValidationError(handle.workflowId, "output", outputResult.issues);
-        }
-        return outputResult.value as ClientInferOutput<TWorkflow>;
-      },
-      terminate: async (reason?: string) => {
-        await handle.terminate(reason);
-      },
-      cancel: async () => {
-        await handle.cancel();
-      },
-      describe: () => handle.describe(),
-      fetchHistory: () => handle.fetchHistory(),
-    };
-
-    return typedHandle;
-  }
-}

package/src/errors.ts

@@ -1,91 +0,0 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec";
-
-/**
- * Base error class for typed client errors
- */
-export class TypedClientError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "TypedClientError";
-    // Maintains proper stack trace for where our error was thrown (only available on V8)
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, this.constructor);
-    }
-  }
-}
-
-/**
- * Error thrown when a workflow is not found in the contract
- */
-export class WorkflowNotFoundError extends TypedClientError {
-  constructor(
-    public readonly workflowName: string,
-    public readonly availableWorkflows: readonly string[] = [],
-  ) {
-    const message =
-      availableWorkflows.length > 0
-        ? `Workflow "${workflowName}" not found in contract. Available workflows: ${availableWorkflows.join(", ")}`
-        : `Workflow "${workflowName}" not found in contract`;
-    super(message);
-    this.name = "WorkflowNotFoundError";
-  }
-}
-
-/**
- * Error thrown when workflow input or output validation fails
- */
-export class WorkflowValidationError extends TypedClientError {
-  constructor(
-    public readonly workflowName: string,
-    public readonly phase: "input" | "output",
-    public readonly issues: ReadonlyArray<StandardSchemaV1.Issue>,
-  ) {
-    const message = issues.map((issue) => issue.message).join("; ");
-    super(`Validation failed for workflow "${workflowName}" ${phase}: ${message}`);
-    this.name = "WorkflowValidationError";
-  }
-}
-
-/**
- * Error thrown when query input or output validation fails
- */
-export class QueryValidationError extends TypedClientError {
-  constructor(
-    public readonly queryName: string,
-    public readonly phase: "input" | "output",
-    public readonly issues: ReadonlyArray<StandardSchemaV1.Issue>,
-  ) {
-    const message = issues.map((issue) => issue.message).join("; ");
-    super(`Validation failed for query "${queryName}" ${phase}: ${message}`);
-    this.name = "QueryValidationError";
-  }
-}
-
-/**
- * Error thrown when signal input validation fails
- */
-export class SignalValidationError extends TypedClientError {
-  constructor(
-    public readonly signalName: string,
-    public readonly issues: ReadonlyArray<StandardSchemaV1.Issue>,
-  ) {
-    const message = issues.map((issue) => issue.message).join("; ");
-    super(`Validation failed for signal "${signalName}" input: ${message}`);
-    this.name = "SignalValidationError";
-  }
-}
-
-/**
- * Error thrown when update input or output validation fails
- */
-export class UpdateValidationError extends TypedClientError {
-  constructor(
-    public readonly updateName: string,
-    public readonly phase: "input" | "output",
-    public readonly issues: ReadonlyArray<StandardSchemaV1.Issue>,
-  ) {
-    const message = issues.map((issue) => issue.message).join("; ");
-    super(`Validation failed for update "${updateName}" ${phase}: ${message}`);
-    this.name = "UpdateValidationError";
-  }
-}

package/src/index.ts

@@ -1,9 +0,0 @@
-export { TypedClient, type TypedWorkflowHandle, type TypedWorkflowStartOptions } from "./client.js";
-export {
-  TypedClientError,
-  WorkflowNotFoundError,
-  WorkflowValidationError,
-  QueryValidationError,
-  SignalValidationError,
-  UpdateValidationError,
-} from "./errors.js";

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "@temporal-contract/tsconfig/base.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src",
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"],
-}

package/vitest.config.ts

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