feat(contract)!: drop zod meta-validation, ESM-only build, input-less signals/queries/updates

Wave 1 of the v8 review remediation (spec items 1-6):

- Activity-collision check now allows the same activity definition object to
  be referenced from several scopes (reference equality — the flat namespace
  stays unambiguous); real collisions (different objects, same name) recommend
  hoisting the shared activity to the contract's global "activities" block.
- defineContract rejects a global activity whose name equals a workflow name
  (they share the root of the worker implementations map).
- Replaced the zod-based contract meta-validation with a hand-rolled
  structural validator over unknown; zod moved from dependencies to
  devDependencies (tests still use it as a Standard Schema). The contract
  root is now strict: unknown top-level keys are rejected, matching the
  strict defaultOptions behavior.
- defineSignal/defineQuery/defineUpdate accept an omitted input: they
  materialize an UndefinedInputSchema (Standard Schema whose validated value
  is always undefined), so handler inputs infer as undefined without
  z.void() ceremony. Definition types keep a required input slot so the
  worker and client compile unchanged (their optional-payload surfaces land
  in Wave 3).
- Deleted the trivial InferContractWorkflows alias; fixed the stale
  "unthrown 4" comment in errors.ts to describe unthrown 5 semantics.
- Dropped the CJS build: ESM-only exports with types conditions (aligned
  with packages/testing), removed main/module/types top-level fields.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: btravers

packages/contract/package.json

@@ -23,53 +23,31 @@
   ],
   "type": "module",
   "sideEffects": false,
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.mts",
   "exports": {
     ".": {
-      "import": {
-        "types": "./dist/index.d.mts",
-        "default": "./dist/index.mjs"
-      },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      }
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
     },
     "./errors": {
-      "import": {
-        "types": "./dist/errors.d.mts",
-        "default": "./dist/errors.mjs"
-      },
-      "require": {
-        "types": "./dist/errors.d.cts",
-        "default": "./dist/errors.cjs"
-      }
+      "types": "./dist/errors.d.mts",
+      "import": "./dist/errors.mjs"
     },
     "./result-async": {
-      "import": {
-        "types": "./dist/result-async.d.mts",
-        "default": "./dist/result-async.mjs"
-      },
-      "require": {
-        "types": "./dist/result-async.d.cts",
-        "default": "./dist/result-async.cjs"
-      }
+      "types": "./dist/result-async.d.mts",
+      "import": "./dist/result-async.mjs"
     },
     "./package.json": "./package.json"
   },
   "scripts": {
-    "build": "tsdown src/index.ts src/errors.ts src/result-async.ts --format cjs,esm --dts --clean",
+    "build": "tsdown src/index.ts src/errors.ts src/result-async.ts --format esm --dts --clean",
     "build:docs": "typedoc",
-    "dev": "tsdown src/index.ts src/errors.ts src/result-async.ts --format cjs,esm --dts --watch",
+    "dev": "tsdown src/index.ts src/errors.ts src/result-async.ts --format esm --dts --watch",
     "test": "vitest run",
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@standard-schema/spec": "catalog:",
-    "zod": "catalog:"
+    "@standard-schema/spec": "catalog:"
   },
   "devDependencies": {
     "@btravstack/tsconfig": "catalog:",
@@ -84,7 +62,8 @@
     "typescript": "catalog:",
     "unthrown": "catalog:",
     "valibot": "catalog:",
-    "vitest": "catalog:"
+    "vitest": "catalog:",
+    "zod": "catalog:"
   },
   "peerDependencies": {
     "unthrown": "^5.0.0"

packages/contract/src/builder.spec.ts

@@ -1,7 +1,14 @@
 import { describe, expect, it } from "vitest";
 import { z } from "zod";
 
-import { defineContract } from "./builder.js";
+import {
+  defineActivity,
+  defineContract,
+  defineQuery,
+  defineSignal,
+  defineUpdate,
+  defineWorkflow,
+} from "./builder.js";
 
 describe("Contract Builder", () => {
   describe("defineContract", () => {
@@ -404,7 +411,7 @@ describe("Contract Builder", () => {
           },
         }),
       ).toThrow(
-        'workflow "processOrder" has activity "sendEmail" that conflicts with a global activity. Consider renaming the workflow-specific activity or removing the global activity "sendEmail".',
+        'workflow "processOrder" has activity "sendEmail" that conflicts with a different global activity of the same name. Activities share a single flat namespace at runtime — reference the shared definition from the contract\'s global "activities" block, or rename one of them.',
       );
     });
 
@@ -436,10 +443,129 @@ describe("Contract Builder", () => {
           },
         }),
       ).toThrow(
-        'workflow "processRefund" has activity "charge" that conflicts with the same-named activity in workflow "processOrder". Activities share a single flat namespace at runtime — rename one of them.',
+        'workflow "processRefund" has activity "charge" that conflicts with a different same-named activity in workflow "processOrder". Activities share a single flat namespace at runtime — hoist the shared activity to the contract\'s global "activities" block, or rename one of them.',
       );
     });
 
+    it("should allow the same activity object to be shared by two workflows", () => {
+      const charge = defineActivity({
+        input: z.object({ amount: z.number() }),
+        output: z.object({ transactionId: z.string() }),
+      });
+
+      expect(() =>
+        defineContract({
+          taskQueue: "test",
+          workflows: {
+            processOrder: {
+              input: z.object({}),
+              output: z.object({}),
+              activities: { charge },
+            },
+            processRefund: {
+              input: z.object({}),
+              output: z.object({}),
+              activities: { charge },
+            },
+          },
+        }),
+      ).not.toThrow();
+    });
+
+    it("should allow a workflow to reference the same object as a global activity", () => {
+      const sendEmail = defineActivity({
+        input: z.object({ to: z.string() }),
+        output: z.object({ sent: z.boolean() }),
+      });
+
+      expect(() =>
+        defineContract({
+          taskQueue: "test",
+          workflows: {
+            processOrder: {
+              input: z.object({}),
+              output: z.object({}),
+              activities: { sendEmail },
+            },
+          },
+          activities: { sendEmail },
+        }),
+      ).not.toThrow();
+    });
+
+    it("should throw when a global activity has the same name as a workflow", () => {
+      expect(() =>
+        defineContract({
+          taskQueue: "test",
+          workflows: {
+            processOrder: {
+              input: z.object({}),
+              output: z.object({}),
+            },
+          },
+          activities: {
+            processOrder: {
+              input: z.object({}),
+              output: z.object({}),
+            },
+          },
+        }),
+      ).toThrow(
+        'global activity "processOrder" has the same name as a workflow. Workflows and global activities share the root of the worker implementations map — rename one of them.',
+      );
+    });
+
+    it("should throw when a workflow has the same name as a global activity", () => {
+      // Same collision, declared the other way around: the activity name
+      // comes first alphabetically and the workflow map holds several keys.
+      expect(() =>
+        defineContract({
+          taskQueue: "test",
+          workflows: {
+            aWorkflow: {
+              input: z.object({}),
+              output: z.object({}),
+            },
+            sendEmail: {
+              input: z.object({}),
+              output: z.object({}),
+            },
+          },
+          activities: {
+            sendEmail: {
+              input: z.object({}),
+              output: z.object({}),
+            },
+          },
+        }),
+      ).toThrow(
+        'global activity "sendEmail" has the same name as a workflow. Workflows and global activities share the root of the worker implementations map — rename one of them.',
+      );
+    });
+
+    it("should allow a workflow-local activity to share a workflow's name", () => {
+      // Workflow-local activity implementations nest under their owning
+      // workflow in the worker implementations map, so they never collide
+      // with workflow names at the root.
+      expect(() =>
+        defineContract({
+          taskQueue: "test",
+          workflows: {
+            processOrder: {
+              input: z.object({}),
+              output: z.object({}),
+              activities: {
+                processOrder: {
+                  input: z.object({}),
+                  output: z.object({}),
+                },
+              },
+            },
+          },
+        }),
+      ).not.toThrow();
+    });
+
     it("should not misclassify a workflow named 'global' as the global activity scope", () => {
       // A workflow can legally be named "global" — the collision detector must
       // not confuse it with the global activity scope sentinel.
@@ -470,7 +596,7 @@ describe("Contract Builder", () => {
           },
         }),
       ).toThrow(
-        'workflow "other" has activity "send" that conflicts with the same-named activity in workflow "global". Activities share a single flat namespace at runtime — rename one of them.',
+        'workflow "other" has activity "send" that conflicts with a different same-named activity in workflow "global". Activities share a single flat namespace at runtime — hoist the shared activity to the contract\'s global "activities" block, or rename one of them.',
       );
     });
 
@@ -597,6 +723,43 @@ describe("Contract Builder", () => {
         }),
       ).not.toThrow();
     });
+
+    it("should throw on an unknown top-level key (strict root)", () => {
+      expect(() =>
+        defineContract({
+          taskQueue: "test",
+          workflows: {
+            test: {
+              input: z.object({}),
+              output: z.object({}),
+            },
+          },
+          // Deliberate typo of `activities` — TypeScript's generic inference
+          // absorbs the extra key, which is exactly why the runtime root
+          // check is strict.
+          activites: {},
+        }),
+      ).toThrow(
+        'contract has unknown key "activites" — allowed keys are "taskQueue", "workflows", "activities"',
+      );
+    });
+
+    it("should accept input-less signal/query/update definitions from the helpers", () => {
+      expect(() =>
+        defineContract({
+          taskQueue: "test",
+          workflows: {
+            wf: defineWorkflow({
+              input: z.object({}),
+              output: z.object({}),
+              signals: { shutdown: defineSignal() },
+              queries: { getStatus: defineQuery({ output: z.string() }) },
+              updates: { bump: defineUpdate({ output: z.number() }) },
+            }),
+          },
+        }),
+      ).not.toThrow();
+    });
   });
 
   describe("Edge Cases", () => {