typed-bridge 2.1.1 → 2.1.3

package/dist/demo/bridge/index.d.ts

@@ -166,6 +166,63 @@ declare const _default: {
         updatedAt: import("zod").ZodDate;
     }, import("zod/v4/core").$strip>>>;
     'order.list': () => Promise<order.Order[]>;
+    'order.resolve': (args: import("zod").infer<import("zod").ZodObject<{
+        id: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>>, context: {
+        requestedAt: number;
+        userId: number;
+    }) => Promise<import("zod").infer<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        status: import("zod").ZodLiteral<"found">;
+        order: import("zod").ZodObject<{
+            id: import("zod").ZodNumber;
+            customerName: import("zod").ZodString;
+            orderStatus: import("zod").ZodEnum<{
+                pending: "pending";
+                confirmed: "confirmed";
+                shipped: "shipped";
+                delivered: "delivered";
+                cancelled: "cancelled";
+            }>;
+            total: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        status: import("zod").ZodLiteral<"not_found">;
+    }, import("zod/v4/core").$strip>], "status">>>;
+    'order.statusFilter': (args: import("zod").infer<import("zod").ZodObject<{
+        status: import("zod").ZodEnum<{
+            pending: "pending";
+            confirmed: "confirmed";
+            shipped: "shipped";
+            delivered: "delivered";
+            cancelled: "cancelled";
+        }>;
+    }, import("zod/v4/core").$strip>>, context: {
+        requestedAt: number;
+        userId: number;
+    }) => Promise<import("zod").infer<import("zod").ZodObject<{
+        orders: import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodNumber;
+            status: import("zod").ZodEnum<{
+                pending: "pending";
+                confirmed: "confirmed";
+                shipped: "shipped";
+                delivered: "delivered";
+                cancelled: "cancelled";
+            }>;
+            total: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>>;
+    'order.tag': (args: import("zod").infer<import("zod").ZodObject<{
+        orderId: import("zod").ZodNumber;
+        tag: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>;
+    }, import("zod/v4/core").$strip>>, context: {
+        requestedAt: number;
+        userId: number;
+    }) => Promise<import("zod").infer<import("zod").ZodObject<{
+        orderId: import("zod").ZodNumber;
+        tag: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>;
+        appliedAt: import("zod").ZodDate;
+    }, import("zod/v4/core").$strip>>>;
     'order.primitives': (args: import("zod").infer<import("zod").ZodObject<{
         key: import("zod").ZodString;
     }, import("zod/v4/core").$strip>>) => Promise<import("zod").infer<import("zod").ZodObject<{

package/dist/demo/bridge/index.js

@@ -49,5 +49,8 @@ exports.default = {
     'order.fetch': order.fetch,
     'order.update': order.update,
     'order.list': order.list,
+    'order.resolve': order.resolve,
+    'order.statusFilter': order.statusFilter,
+    'order.tag': order.tag,
     'order.primitives': order.primitives
 };

package/dist/demo/bridge/order/index.d.ts

@@ -1,4 +1,4 @@
-import { $z } from '../../..';
+import { z } from '../../..';
 import * as types from './types';
 export interface OrderItem {
     productId: number;
@@ -31,9 +31,12 @@ type Context = {
     requestedAt: number;
     userId: number;
 };
-export declare const create: (args: $z.infer<typeof types.create.args>, context: Context) => Promise<$z.infer<typeof types.create.res>>;
-export declare const fetch: (args: $z.infer<typeof types.fetch.args>, context: Context) => Promise<$z.infer<typeof types.fetch.res>>;
-export declare const update: (args: $z.infer<typeof types.update.args>, context: Context) => Promise<$z.infer<typeof types.update.res>>;
+export declare const create: (args: z.infer<typeof types.create.args>, context: Context) => Promise<z.infer<typeof types.create.res>>;
+export declare const fetch: (args: z.infer<typeof types.fetch.args>, context: Context) => Promise<z.infer<typeof types.fetch.res>>;
+export declare const update: (args: z.infer<typeof types.update.args>, context: Context) => Promise<z.infer<typeof types.update.res>>;
 export declare const list: () => Promise<Order[]>;
-export declare const primitives: (args: $z.infer<typeof types.primitives.args>) => Promise<$z.infer<typeof types.primitives.res>>;
+export declare const resolve: (args: z.infer<typeof types.resolve.args>, context: Context) => Promise<z.infer<typeof types.resolve.res>>;
+export declare const statusFilter: (args: z.infer<typeof types.statusFilter.args>, context: Context) => Promise<z.infer<typeof types.statusFilter.res>>;
+export declare const tag: (args: z.infer<typeof types.tag.args>, context: Context) => Promise<z.infer<typeof types.tag.res>>;
+export declare const primitives: (args: z.infer<typeof types.primitives.args>) => Promise<z.infer<typeof types.primitives.res>>;
 export {};

package/dist/demo/bridge/order/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.primitives = exports.list = exports.update = exports.fetch = exports.create = void 0;
+exports.primitives = exports.tag = exports.statusFilter = exports.resolve = exports.list = exports.update = exports.fetch = exports.create = void 0;
 const types = __importStar(require("./types"));
 let nextId = 1;
 const orders = [];
@@ -51,7 +51,9 @@ const create = async (args, context) => {
         total: items.reduce((sum, i) => sum + i.price * i.quantity, 0),
         items,
         shippingAddress: { ...args.shippingAddress, country: args.shippingAddress.country ?? 'US' },
-        billingAddress: args.billingAddress ? { ...args.billingAddress, country: args.billingAddress.country ?? 'US' } : null,
+        billingAddress: args.billingAddress
+            ? { ...args.billingAddress, country: args.billingAddress.country ?? 'US' }
+            : null,
         isGift: args.isGift,
         giftMessage: args.giftMessage,
         createdAt: new Date(),
@@ -94,6 +96,43 @@ const list = async () => {
     return orders;
 };
 exports.list = list;
+const resolve = async (args, context) => {
+    args = types.resolve.args.parse(args);
+    const order = orders.find(o => o.id === args.id);
+    if (!order)
+        return { status: 'not_found' };
+    return {
+        status: 'found',
+        order: {
+            id: order.id,
+            customerName: `Customer #${order.customerId}`,
+            orderStatus: order.status,
+            total: order.total
+        }
+    };
+};
+exports.resolve = resolve;
+const statusFilter = async (args, context) => {
+    args = types.statusFilter.args.parse(args);
+    return {
+        orders: orders
+            .filter(o => o.status === args.status)
+            .map(o => ({ id: o.id, status: o.status, total: o.total }))
+    };
+};
+exports.statusFilter = statusFilter;
+const orderTags = new Map();
+const tag = async (args, context) => {
+    args = types.tag.args.parse(args);
+    const order = orders.find(o => o.id === args.orderId);
+    if (!order)
+        throw new Error(`Order with ID ${args.orderId} not found`);
+    const tags = orderTags.get(args.orderId) || [];
+    tags.push(args.tag);
+    orderTags.set(args.orderId, tags);
+    return { orderId: args.orderId, tag: args.tag, appliedAt: new Date() };
+};
+exports.tag = tag;
 const primitives = async (args) => {
     args = types.primitives.args.parse(args);
     return {

package/dist/demo/bridge/order/types.d.ts

@@ -1,130 +1,187 @@
-import { $z } from '../../..';
+import { z } from '../../..';
 export declare const create: {
-    args: $z.ZodObject<{
-        customerId: $z.ZodNumber;
-        items: $z.ZodArray<$z.ZodObject<{
-            productId: $z.ZodNumber;
-            quantity: $z.ZodNumber;
-            price: $z.ZodNumber;
-            notes: $z.ZodOptional<$z.ZodString>;
-            discount: $z.ZodNullable<$z.ZodNumber>;
-        }, $z.core.$strip>>;
-        shippingAddress: $z.ZodObject<{
-            street: $z.ZodString;
-            city: $z.ZodString;
-            state: $z.ZodString;
-            zip: $z.ZodString;
-            country: $z.ZodDefault<$z.ZodString>;
-        }, $z.core.$strip>;
-        billingAddress: $z.ZodNullable<$z.ZodObject<{
-            street: $z.ZodString;
-            city: $z.ZodString;
-            state: $z.ZodString;
-            zip: $z.ZodString;
-            country: $z.ZodDefault<$z.ZodString>;
-        }, $z.core.$strip>>;
-        couponCode: $z.ZodOptional<$z.ZodNullable<$z.ZodString>>;
-        scheduledDate: $z.ZodOptional<$z.ZodDate>;
-        isGift: $z.ZodBoolean;
-        giftMessage: $z.ZodNullable<$z.ZodString>;
-    }, $z.core.$strip>;
-    res: $z.ZodObject<{
-        id: $z.ZodNumber;
-        status: $z.ZodString;
-        total: $z.ZodNumber;
-        items: $z.ZodArray<$z.ZodObject<{
-            productId: $z.ZodNumber;
-            quantity: $z.ZodNumber;
-            price: $z.ZodNumber;
-            notes: $z.ZodOptional<$z.ZodString>;
-            discount: $z.ZodNullable<$z.ZodNumber>;
-        }, $z.core.$strip>>;
-        createdAt: $z.ZodDate;
-    }, $z.core.$strip>;
+    args: z.ZodObject<{
+        customerId: z.ZodNumber;
+        items: z.ZodArray<z.ZodObject<{
+            productId: z.ZodNumber;
+            quantity: z.ZodNumber;
+            price: z.ZodNumber;
+            notes: z.ZodOptional<z.ZodString>;
+            discount: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>;
+        shippingAddress: z.ZodObject<{
+            street: z.ZodString;
+            city: z.ZodString;
+            state: z.ZodString;
+            zip: z.ZodString;
+            country: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>;
+        billingAddress: z.ZodNullable<z.ZodObject<{
+            street: z.ZodString;
+            city: z.ZodString;
+            state: z.ZodString;
+            zip: z.ZodString;
+            country: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>;
+        couponCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        scheduledDate: z.ZodOptional<z.ZodDate>;
+        isGift: z.ZodBoolean;
+        giftMessage: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    res: z.ZodObject<{
+        id: z.ZodNumber;
+        status: z.ZodString;
+        total: z.ZodNumber;
+        items: z.ZodArray<z.ZodObject<{
+            productId: z.ZodNumber;
+            quantity: z.ZodNumber;
+            price: z.ZodNumber;
+            notes: z.ZodOptional<z.ZodString>;
+            discount: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>;
+        createdAt: z.ZodDate;
+    }, z.core.$strip>;
 };
 export declare const fetch: {
-    args: $z.ZodObject<{
-        id: $z.ZodNumber;
-    }, $z.core.$strip>;
-    res: $z.ZodObject<{
-        id: $z.ZodNumber;
-        customerId: $z.ZodNumber;
-        status: $z.ZodString;
-        total: $z.ZodNumber;
-        items: $z.ZodArray<$z.ZodObject<{
-            productId: $z.ZodNumber;
-            quantity: $z.ZodNumber;
-            price: $z.ZodNumber;
-            notes: $z.ZodOptional<$z.ZodString>;
-            discount: $z.ZodNullable<$z.ZodNumber>;
-        }, $z.core.$strip>>;
-        shippingAddress: $z.ZodObject<{
-            street: $z.ZodString;
-            city: $z.ZodString;
-            state: $z.ZodString;
-            zip: $z.ZodString;
-            country: $z.ZodDefault<$z.ZodString>;
-        }, $z.core.$strip>;
-        billingAddress: $z.ZodNullable<$z.ZodObject<{
-            street: $z.ZodString;
-            city: $z.ZodString;
-            state: $z.ZodString;
-            zip: $z.ZodString;
-            country: $z.ZodDefault<$z.ZodString>;
-        }, $z.core.$strip>>;
-        isGift: $z.ZodBoolean;
-        giftMessage: $z.ZodNullable<$z.ZodString>;
-        createdAt: $z.ZodDate;
-        updatedAt: $z.ZodNullable<$z.ZodDate>;
-    }, $z.core.$strip>;
+    args: z.ZodObject<{
+        id: z.ZodNumber;
+    }, z.core.$strip>;
+    res: z.ZodObject<{
+        id: z.ZodNumber;
+        customerId: z.ZodNumber;
+        status: z.ZodString;
+        total: z.ZodNumber;
+        items: z.ZodArray<z.ZodObject<{
+            productId: z.ZodNumber;
+            quantity: z.ZodNumber;
+            price: z.ZodNumber;
+            notes: z.ZodOptional<z.ZodString>;
+            discount: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>;
+        shippingAddress: z.ZodObject<{
+            street: z.ZodString;
+            city: z.ZodString;
+            state: z.ZodString;
+            zip: z.ZodString;
+            country: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>;
+        billingAddress: z.ZodNullable<z.ZodObject<{
+            street: z.ZodString;
+            city: z.ZodString;
+            state: z.ZodString;
+            zip: z.ZodString;
+            country: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>;
+        isGift: z.ZodBoolean;
+        giftMessage: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodNullable<z.ZodDate>;
+    }, z.core.$strip>;
 };
 export declare const update: {
-    args: $z.ZodObject<{
-        id: $z.ZodNumber;
-        status: $z.ZodOptional<$z.ZodString>;
-        shippingAddress: $z.ZodOptional<$z.ZodObject<{
-            street: $z.ZodString;
-            city: $z.ZodString;
-            state: $z.ZodString;
-            zip: $z.ZodString;
-            country: $z.ZodDefault<$z.ZodString>;
-        }, $z.core.$strip>>;
-        giftMessage: $z.ZodOptional<$z.ZodNullable<$z.ZodString>>;
-    }, $z.core.$strip>;
-    res: $z.ZodObject<{
-        id: $z.ZodNumber;
-        status: $z.ZodString;
-        updatedAt: $z.ZodDate;
-    }, $z.core.$strip>;
+    args: z.ZodObject<{
+        id: z.ZodNumber;
+        status: z.ZodOptional<z.ZodString>;
+        shippingAddress: z.ZodOptional<z.ZodObject<{
+            street: z.ZodString;
+            city: z.ZodString;
+            state: z.ZodString;
+            zip: z.ZodString;
+            country: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>;
+        giftMessage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+    res: z.ZodObject<{
+        id: z.ZodNumber;
+        status: z.ZodString;
+        updatedAt: z.ZodDate;
+    }, z.core.$strip>;
+};
+export declare const resolve: {
+    args: z.ZodObject<{
+        id: z.ZodNumber;
+    }, z.core.$strip>;
+    res: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"found">;
+        order: z.ZodObject<{
+            id: z.ZodNumber;
+            customerName: z.ZodString;
+            orderStatus: z.ZodEnum<{
+                pending: "pending";
+                confirmed: "confirmed";
+                shipped: "shipped";
+                delivered: "delivered";
+                cancelled: "cancelled";
+            }>;
+            total: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"not_found">;
+    }, z.core.$strip>], "status">;
+};
+export declare const statusFilter: {
+    args: z.ZodObject<{
+        status: z.ZodEnum<{
+            pending: "pending";
+            confirmed: "confirmed";
+            shipped: "shipped";
+            delivered: "delivered";
+            cancelled: "cancelled";
+        }>;
+    }, z.core.$strip>;
+    res: z.ZodObject<{
+        orders: z.ZodArray<z.ZodObject<{
+            id: z.ZodNumber;
+            status: z.ZodEnum<{
+                pending: "pending";
+                confirmed: "confirmed";
+                shipped: "shipped";
+                delivered: "delivered";
+                cancelled: "cancelled";
+            }>;
+            total: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+};
+export declare const tag: {
+    args: z.ZodObject<{
+        orderId: z.ZodNumber;
+        tag: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    }, z.core.$strip>;
+    res: z.ZodObject<{
+        orderId: z.ZodNumber;
+        tag: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        appliedAt: z.ZodDate;
+    }, z.core.$strip>;
 };
 export declare const primitives: {
-    args: $z.ZodObject<{
-        key: $z.ZodString;
-    }, $z.core.$strip>;
-    res: $z.ZodObject<{
-        str: $z.ZodString;
-        num: $z.ZodNumber;
-        bool: $z.ZodBoolean;
-        date: $z.ZodDate;
-        nul: $z.ZodNull;
-        undef: $z.ZodUndefined;
-        unk: $z.ZodUnknown;
-        whatever: $z.ZodAny;
-        optStr: $z.ZodOptional<$z.ZodString>;
-        nullStr: $z.ZodNullable<$z.ZodString>;
-        defStr: $z.ZodDefault<$z.ZodString>;
-        optNullStr: $z.ZodOptional<$z.ZodNullable<$z.ZodString>>;
-        nullOptStr: $z.ZodNullable<$z.ZodOptional<$z.ZodString>>;
-        tags: $z.ZodArray<$z.ZodString>;
-        scores: $z.ZodNullable<$z.ZodArray<$z.ZodNumber>>;
-        optDates: $z.ZodOptional<$z.ZodArray<$z.ZodDate>>;
-        nested: $z.ZodObject<{
-            a: $z.ZodNumber;
-            b: $z.ZodOptional<$z.ZodString>;
-            c: $z.ZodObject<{
-                d: $z.ZodBoolean;
-                e: $z.ZodNullable<$z.ZodArray<$z.ZodString>>;
-            }, $z.core.$strip>;
-        }, $z.core.$strip>;
-    }, $z.core.$strip>;
+    args: z.ZodObject<{
+        key: z.ZodString;
+    }, z.core.$strip>;
+    res: z.ZodObject<{
+        str: z.ZodString;
+        num: z.ZodNumber;
+        bool: z.ZodBoolean;
+        date: z.ZodDate;
+        nul: z.ZodNull;
+        undef: z.ZodUndefined;
+        unk: z.ZodUnknown;
+        whatever: z.ZodAny;
+        optStr: z.ZodOptional<z.ZodString>;
+        nullStr: z.ZodNullable<z.ZodString>;
+        defStr: z.ZodDefault<z.ZodString>;
+        optNullStr: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        nullOptStr: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        tags: z.ZodArray<z.ZodString>;
+        scores: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+        optDates: z.ZodOptional<z.ZodArray<z.ZodDate>>;
+        nested: z.ZodObject<{
+            a: z.ZodNumber;
+            b: z.ZodOptional<z.ZodString>;
+            c: z.ZodObject<{
+                d: z.ZodBoolean;
+                e: z.ZodNullable<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
 };

package/dist/demo/bridge/order/types.js

@@ -1,103 +1,149 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.primitives = exports.update = exports.fetch = exports.create = void 0;
+exports.primitives = exports.tag = exports.statusFilter = exports.resolve = exports.update = exports.fetch = exports.create = void 0;
 const __1 = require("../../..");
 // --- Reusable schemas ---
-const addressSchema = __1.$z.object({
-    street: __1.$z.string(),
-    city: __1.$z.string(),
-    state: __1.$z.string(),
-    zip: __1.$z.string(),
-    country: __1.$z.string().default('US') // ZodDefault<ZodString> → string
+const addressSchema = __1.z.object({
+    street: __1.z.string(),
+    city: __1.z.string(),
+    state: __1.z.string(),
+    zip: __1.z.string(),
+    country: __1.z.string().default('US') // ZodDefault<ZodString> → string
 });
-const orderItemSchema = __1.$z.object({
-    productId: __1.$z.number(),
-    quantity: __1.$z.number().min(1),
-    price: __1.$z.number(),
-    notes: __1.$z.string().optional(), // ZodOptional<ZodString> → string?
-    discount: __1.$z.number().nullable() // ZodNullable<ZodNumber> → number | null
+const orderItemSchema = __1.z.object({
+    productId: __1.z.number(),
+    quantity: __1.z.number().min(1),
+    price: __1.z.number(),
+    notes: __1.z.string().optional(), // ZodOptional<ZodString> → string?
+    discount: __1.z.number().nullable() // ZodNullable<ZodNumber> → number | null
 });
 // --- create ---
 exports.create = {
-    args: __1.$z.object({
-        customerId: __1.$z.number().min(1),
-        items: __1.$z.array(orderItemSchema), // ZodArray<ZodObject> → {...}[]
+    args: __1.z.object({
+        customerId: __1.z.number().min(1),
+        items: __1.z.array(orderItemSchema), // ZodArray<ZodObject> → {...}[]
         shippingAddress: addressSchema, // nested ZodObject
         billingAddress: addressSchema.nullable(), // ZodNullable<ZodObject> → {...} | null
-        couponCode: __1.$z.string().nullable().optional(), // ZodOptional<ZodNullable<ZodString>> → (string | null)?
-        scheduledDate: __1.$z.date().optional(), // ZodOptional<ZodDate> → Date?
-        isGift: __1.$z.boolean(), // ZodBoolean → boolean
-        giftMessage: __1.$z.string().nullable() // ZodNullable<ZodString> → string | null
+        couponCode: __1.z.string().nullable().optional(), // ZodOptional<ZodNullable<ZodString>> → (string | null)?
+        scheduledDate: __1.z.date().optional(), // ZodOptional<ZodDate> → Date?
+        isGift: __1.z.boolean(), // ZodBoolean → boolean
+        giftMessage: __1.z.string().nullable() // ZodNullable<ZodString> → string | null
     }),
-    res: __1.$z.object({
-        id: __1.$z.number(),
-        status: __1.$z.string(),
-        total: __1.$z.number(),
-        items: __1.$z.array(orderItemSchema),
-        createdAt: __1.$z.date() // ZodDate → Date
+    res: __1.z.object({
+        id: __1.z.number(),
+        status: __1.z.string(),
+        total: __1.z.number(),
+        items: __1.z.array(orderItemSchema),
+        createdAt: __1.z.date() // ZodDate → Date
     })
 };
 // --- fetch ---
 exports.fetch = {
-    args: __1.$z.object({
-        id: __1.$z.number().min(1)
+    args: __1.z.object({
+        id: __1.z.number().min(1)
     }),
-    res: __1.$z.object({
-        id: __1.$z.number(),
-        customerId: __1.$z.number(),
-        status: __1.$z.string(),
-        total: __1.$z.number(),
-        items: __1.$z.array(orderItemSchema),
+    res: __1.z.object({
+        id: __1.z.number(),
+        customerId: __1.z.number(),
+        status: __1.z.string(),
+        total: __1.z.number(),
+        items: __1.z.array(orderItemSchema),
         shippingAddress: addressSchema,
         billingAddress: addressSchema.nullable(),
-        isGift: __1.$z.boolean(),
-        giftMessage: __1.$z.string().nullable(),
-        createdAt: __1.$z.date(),
-        updatedAt: __1.$z.date().nullable() // ZodNullable<ZodDate> → Date | null
+        isGift: __1.z.boolean(),
+        giftMessage: __1.z.string().nullable(),
+        createdAt: __1.z.date(),
+        updatedAt: __1.z.date().nullable() // ZodNullable<ZodDate> → Date | null
     })
 };
 // --- update ---
 exports.update = {
-    args: __1.$z.object({
-        id: __1.$z.number().min(1),
-        status: __1.$z.string().optional(),
+    args: __1.z.object({
+        id: __1.z.number().min(1),
+        status: __1.z.string().optional(),
         shippingAddress: addressSchema.optional(), // ZodOptional<ZodObject> → {...}?
-        giftMessage: __1.$z.string().nullable().optional()
+        giftMessage: __1.z.string().nullable().optional()
     }),
-    res: __1.$z.object({
-        id: __1.$z.number(),
-        status: __1.$z.string(),
-        updatedAt: __1.$z.date()
+    res: __1.z.object({
+        id: __1.z.number(),
+        status: __1.z.string(),
+        updatedAt: __1.z.date()
+    })
+};
+// --- resolve: exercises ZodDiscriminatedUnion + ZodLiteral + ZodEnum ---
+const orderStatusEnum = __1.z.enum(['pending', 'confirmed', 'shipped', 'delivered', 'cancelled']);
+exports.resolve = {
+    args: __1.z.object({
+        id: __1.z.number().min(1)
+    }),
+    res: __1.z.discriminatedUnion('status', [
+        __1.z.object({
+            status: __1.z.literal('found'),
+            order: __1.z.object({
+                id: __1.z.number(),
+                customerName: __1.z.string(),
+                orderStatus: orderStatusEnum,
+                total: __1.z.number()
+            })
+        }),
+        __1.z.object({
+            status: __1.z.literal('not_found')
+        })
+    ])
+};
+// --- statusFilter: exercises ZodEnum in args and response ---
+exports.statusFilter = {
+    args: __1.z.object({
+        status: orderStatusEnum
+    }),
+    res: __1.z.object({
+        orders: __1.z.array(__1.z.object({
+            id: __1.z.number(),
+            status: orderStatusEnum,
+            total: __1.z.number()
+        }))
+    })
+};
+// --- tag: exercises ZodUnion ---
+exports.tag = {
+    args: __1.z.object({
+        orderId: __1.z.number().min(1),
+        tag: __1.z.union([__1.z.string(), __1.z.number()])
+    }),
+    res: __1.z.object({
+        orderId: __1.z.number(),
+        tag: __1.z.union([__1.z.string(), __1.z.number()]),
+        appliedAt: __1.z.date()
     })
 };
 // --- primitives: exercises all remaining keyword types ---
 exports.primitives = {
-    args: __1.$z.object({
-        key: __1.$z.string()
+    args: __1.z.object({
+        key: __1.z.string()
     }),
-    res: __1.$z.object({
-        str: __1.$z.string(), // ZodString → string
-        num: __1.$z.number(), // ZodNumber → number
-        bool: __1.$z.boolean(), // ZodBoolean → boolean
-        date: __1.$z.date(), // ZodDate → Date
-        nul: __1.$z.null(), // ZodNull → null
-        undef: __1.$z.undefined(), // ZodUndefined → undefined
-        unk: __1.$z.unknown(), // ZodUnknown → unknown
-        whatever: __1.$z.any(), // ZodAny → any
-        optStr: __1.$z.string().optional(), // ZodOptional<ZodString> → string?
-        nullStr: __1.$z.string().nullable(), // ZodNullable<ZodString> → string | null
-        defStr: __1.$z.string().default('hello'), // ZodDefault<ZodString> → string
-        optNullStr: __1.$z.string().nullable().optional(), // ZodOptional<ZodNullable> → (string | null)?
-        nullOptStr: __1.$z.string().optional().nullable(), // ZodNullable<ZodOptional> → (string | undefined) | null
-        tags: __1.$z.array(__1.$z.string()), // ZodArray<ZodString> → string[]
-        scores: __1.$z.array(__1.$z.number()).nullable(), // ZodNullable<ZodArray<ZodNumber>> → number[] | null
-        optDates: __1.$z.array(__1.$z.date()).optional(), // ZodOptional<ZodArray<ZodDate>> → Date[]?
-        nested: __1.$z.object({
-            a: __1.$z.number(),
-            b: __1.$z.string().optional(),
-            c: __1.$z.object({
-                d: __1.$z.boolean(),
-                e: __1.$z.array(__1.$z.string()).nullable()
+    res: __1.z.object({
+        str: __1.z.string(), // ZodString → string
+        num: __1.z.number(), // ZodNumber → number
+        bool: __1.z.boolean(), // ZodBoolean → boolean
+        date: __1.z.date(), // ZodDate → Date
+        nul: __1.z.null(), // ZodNull → null
+        undef: __1.z.undefined(), // ZodUndefined → undefined
+        unk: __1.z.unknown(), // ZodUnknown → unknown
+        whatever: __1.z.any(), // ZodAny → any
+        optStr: __1.z.string().optional(), // ZodOptional<ZodString> → string?
+        nullStr: __1.z.string().nullable(), // ZodNullable<ZodString> → string | null
+        defStr: __1.z.string().default('hello'), // ZodDefault<ZodString> → string
+        optNullStr: __1.z.string().nullable().optional(), // ZodOptional<ZodNullable> → (string | null)?
+        nullOptStr: __1.z.string().optional().nullable(), // ZodNullable<ZodOptional> → (string | undefined) | null
+        tags: __1.z.array(__1.z.string()), // ZodArray<ZodString> → string[]
+        scores: __1.z.array(__1.z.number()).nullable(), // ZodNullable<ZodArray<ZodNumber>> → number[] | null
+        optDates: __1.z.array(__1.z.date()).optional(), // ZodOptional<ZodArray<ZodDate>> → Date[]?
+        nested: __1.z.object({
+            a: __1.z.number(),
+            b: __1.z.string().optional(),
+            c: __1.z.object({
+                d: __1.z.boolean(),
+                e: __1.z.array(__1.z.string()).nullable()
             })
         })
     })

package/dist/demo/bridge/product/index.d.ts

@@ -1,4 +1,4 @@
-import { $z } from '../../..';
+import { z } from '../../..';
 import * as types from './types';
 export interface Product {
     id: number;
@@ -10,7 +10,7 @@ type Context = {
     requestedAt: number;
     userId: number;
 };
-export declare const fetch: (args: $z.infer<typeof types.fetch.args>, context: Context) => Promise<$z.infer<typeof types.fetch.res>>;
-export declare const create: (args: $z.infer<typeof types.create.args>, context: Context) => Promise<$z.infer<typeof types.create.res>>;
+export declare const fetch: (args: z.infer<typeof types.fetch.args>, context: Context) => Promise<z.infer<typeof types.fetch.res>>;
+export declare const create: (args: z.infer<typeof types.create.args>, context: Context) => Promise<z.infer<typeof types.create.res>>;
 export declare const list: () => Promise<Product[]>;
 export {};

package/dist/demo/bridge/product/types.d.ts

@@ -1,24 +1,24 @@
-import { $z } from '../../..';
+import { z } from '../../..';
 export declare const fetch: {
-    args: $z.ZodObject<{
-        id: $z.ZodNumber;
-    }, $z.core.$strip>;
-    res: $z.ZodObject<{
-        id: $z.ZodNumber;
-        name: $z.ZodString;
-        price: $z.ZodNumber;
-        createdAt: $z.ZodDate;
-    }, $z.core.$strip>;
+    args: z.ZodObject<{
+        id: z.ZodNumber;
+    }, z.core.$strip>;
+    res: z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        price: z.ZodNumber;
+        createdAt: z.ZodDate;
+    }, z.core.$strip>;
 };
 export declare const create: {
-    args: $z.ZodObject<{
-        name: $z.ZodString;
-        price: $z.ZodNumber;
-    }, $z.core.$strip>;
-    res: $z.ZodObject<{
-        id: $z.ZodNumber;
-        name: $z.ZodString;
-        price: $z.ZodNumber;
-        createdAt: $z.ZodDate;
-    }, $z.core.$strip>;
+    args: z.ZodObject<{
+        name: z.ZodString;
+        price: z.ZodNumber;
+    }, z.core.$strip>;
+    res: z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        price: z.ZodNumber;
+        createdAt: z.ZodDate;
+    }, z.core.$strip>;
 };

package/dist/demo/bridge/product/types.js

@@ -3,25 +3,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.create = exports.fetch = void 0;
 const __1 = require("../../..");
 exports.fetch = {
-    args: __1.$z.object({
-        id: __1.$z.number().min(1)
+    args: __1.z.object({
+        id: __1.z.number().min(1)
     }),
-    res: __1.$z.object({
-        id: __1.$z.number(),
-        name: __1.$z.string(),
-        price: __1.$z.number(),
-        createdAt: __1.$z.date()
+    res: __1.z.object({
+        id: __1.z.number(),
+        name: __1.z.string(),
+        price: __1.z.number(),
+        createdAt: __1.z.date()
     })
 };
 exports.create = {
-    args: __1.$z.object({
-        name: __1.$z.string().min(1),
-        price: __1.$z.number().min(0)
+    args: __1.z.object({
+        name: __1.z.string().min(1),
+        price: __1.z.number().min(0)
     }),
-    res: __1.$z.object({
-        id: __1.$z.number(),
-        name: __1.$z.string(),
-        price: __1.$z.number(),
-        createdAt: __1.$z.date()
+    res: __1.z.object({
+        id: __1.z.number(),
+        name: __1.z.string(),
+        price: __1.z.number(),
+        createdAt: __1.z.date()
     })
 };

package/dist/demo/bridge/user/index.d.ts

@@ -1,4 +1,4 @@
-import { $z } from '../../..';
+import { z } from '../../..';
 import * as types from './types';
 export interface User {
     id: number;
@@ -10,8 +10,8 @@ type Context = {
     requestedAt: number;
     userId: number;
 };
-export declare const fetch: (args: $z.infer<typeof types.fetch.args>, context: Context) => Promise<$z.infer<typeof types.fetch.res>>;
-export declare const create: (args: $z.infer<typeof types.create.args>, context: Context) => Promise<$z.infer<typeof types.create.res>>;
+export declare const fetch: (args: z.infer<typeof types.fetch.args>, context: Context) => Promise<z.infer<typeof types.fetch.res>>;
+export declare const create: (args: z.infer<typeof types.create.args>, context: Context) => Promise<z.infer<typeof types.create.res>>;
 export declare const update: (args: {
     id: number;
     name?: string;

package/dist/demo/bridge/user/types.d.ts

@@ -1,23 +1,23 @@
-import { $z } from '../../..';
+import { z } from '../../..';
 export declare const fetch: {
-    args: $z.ZodObject<{
-        id: $z.ZodNumber;
-    }, $z.core.$strip>;
-    res: $z.ZodObject<{
-        id: $z.ZodNumber;
-        name: $z.ZodString;
-        email: $z.ZodString;
-    }, $z.core.$strip>;
+    args: z.ZodObject<{
+        id: z.ZodNumber;
+    }, z.core.$strip>;
+    res: z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        email: z.ZodString;
+    }, z.core.$strip>;
 };
 export declare const create: {
-    args: $z.ZodObject<{
-        name: $z.ZodString;
-        email: $z.ZodString;
-    }, $z.core.$strip>;
-    res: $z.ZodObject<{
-        id: $z.ZodNumber;
-        name: $z.ZodString;
-        email: $z.ZodString;
-        createdAt: $z.ZodDate;
-    }, $z.core.$strip>;
+    args: z.ZodObject<{
+        name: z.ZodString;
+        email: z.ZodString;
+    }, z.core.$strip>;
+    res: z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        email: z.ZodString;
+        createdAt: z.ZodDate;
+    }, z.core.$strip>;
 };

package/dist/demo/bridge/user/types.js

@@ -3,24 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.create = exports.fetch = void 0;
 const __1 = require("../../..");
 exports.fetch = {
-    args: __1.$z.object({
-        id: __1.$z.number().min(1)
+    args: __1.z.object({
+        id: __1.z.number().min(1)
     }),
-    res: __1.$z.object({
-        id: __1.$z.number(),
-        name: __1.$z.string(),
-        email: __1.$z.string()
+    res: __1.z.object({
+        id: __1.z.number(),
+        name: __1.z.string(),
+        email: __1.z.string()
     })
 };
 exports.create = {
-    args: __1.$z.object({
-        name: __1.$z.string().min(1),
-        email: __1.$z.string().email()
+    args: __1.z.object({
+        name: __1.z.string().min(1),
+        email: __1.z.string().email()
     }),
-    res: __1.$z.object({
-        id: __1.$z.number(),
-        name: __1.$z.string(),
-        email: __1.$z.string(),
-        createdAt: __1.$z.date()
+    res: __1.z.object({
+        id: __1.z.number(),
+        name: __1.z.string(),
+        email: __1.z.string(),
+        createdAt: __1.z.date()
     })
 };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { Application, default as express, Express, NextFunction, Request, Response, Router } from 'express';
 export { createBridge, createMiddleware, onShutdown } from './bridge';
 export { config as tbConfig } from './config';
-export { z as $z } from 'zod';
+export { z } from 'zod';

package/dist/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.$z = exports.tbConfig = exports.onShutdown = exports.createMiddleware = exports.createBridge = exports.Router = exports.express = void 0;
+exports.z = exports.tbConfig = exports.onShutdown = exports.createMiddleware = exports.createBridge = exports.Router = exports.express = void 0;
 var express_1 = require("express");
 Object.defineProperty(exports, "express", { enumerable: true, get: function () { return __importDefault(express_1).default; } });
 Object.defineProperty(exports, "Router", { enumerable: true, get: function () { return express_1.Router; } });
@@ -14,4 +14,4 @@ Object.defineProperty(exports, "onShutdown", { enumerable: true, get: function (
 var config_1 = require("./config");
 Object.defineProperty(exports, "tbConfig", { enumerable: true, get: function () { return config_1.config; } });
 var zod_1 = require("zod");
-Object.defineProperty(exports, "$z", { enumerable: true, get: function () { return zod_1.z; } });
+Object.defineProperty(exports, "z", { enumerable: true, get: function () { return zod_1.z; } });

package/dist/scripts/typedBridgeCleaner.js

@@ -59,9 +59,7 @@ export default typedBridge
 `;
 /**
  * Transformer #1:
- * Resolve zod types to plain TypeScript types, and remove zod imports.
- * Handles both Zod 3 (zod.TypeOf<ZodObject<S,UK,CA,Output,Input>>) and
- * Zod 4 (zod.infer<ZodObject<Shape, UK>>) patterns.
+ * Resolve Zod 4 types to plain TypeScript types, and remove zod imports.
  */
 const resolveZodTypesTransformer = context => {
     return sourceFile => {
@@ -74,23 +72,32 @@ const resolveZodTypesTransformer = context => {
             ZodVoid: typescript_1.default.SyntaxKind.VoidKeyword,
             ZodAny: typescript_1.default.SyntaxKind.AnyKeyword,
             ZodUnknown: typescript_1.default.SyntaxKind.UnknownKeyword,
-            ZodNever: typescript_1.default.SyntaxKind.NeverKeyword,
+            ZodNever: typescript_1.default.SyntaxKind.NeverKeyword
         };
         function getZodRef(node) {
             if (typescript_1.default.isTypeReferenceNode(node) &&
                 typescript_1.default.isQualifiedName(node.typeName) &&
                 typescript_1.default.isIdentifier(node.typeName.left) &&
-                (node.typeName.left.text === 'zod' || node.typeName.left.text.startsWith('zod_'))) {
+                (node.typeName.left.text === 'z' ||
+                    node.typeName.left.text === 'zod' ||
+                    node.typeName.left.text.startsWith('zod_'))) {
                 return { name: node.typeName.right.text, typeArgs: node.typeArguments };
             }
             return null;
         }
+        function unwrapReadonlyTuple(node) {
+            if (typescript_1.default.isTupleTypeNode(node))
+                return node;
+            if (typescript_1.default.isTypeOperatorNode(node) && node.operator === typescript_1.default.SyntaxKind.ReadonlyKeyword && typescript_1.default.isTupleTypeNode(node.type))
+                return node.type;
+            return null;
+        }
         function resolveZodType(node) {
             const ref = getZodRef(node);
             if (!ref)
                 return node;
             const { name, typeArgs } = ref;
-            if ((name === 'infer' || name === 'TypeOf') && typeArgs?.length === 1)
+            if (name === 'infer' && typeArgs?.length === 1)
                 return resolveZodType(typeArgs[0]);
             const keyword = zodKeywordMap[name];
             if (keyword !== undefined)
@@ -99,12 +106,8 @@ const resolveZodTypesTransformer = context => {
                 return typescript_1.default.factory.createLiteralTypeNode(typescript_1.default.factory.createNull());
             if (name === 'ZodDate')
                 return typescript_1.default.factory.createTypeReferenceNode('Date');
-            if (name === 'ZodObject' && typeArgs) {
-                if (typeArgs.length >= 4)
-                    return resolveZodType(typeArgs[3]);
-                if (typeArgs.length >= 1 && typescript_1.default.isTypeLiteralNode(typeArgs[0]))
-                    return resolveShape(typeArgs[0]);
-            }
+            if (name === 'ZodObject' && typeArgs && typeArgs.length >= 1 && typescript_1.default.isTypeLiteralNode(typeArgs[0]))
+                return resolveShape(typeArgs[0]);
             if (name === 'ZodArray' && typeArgs && typeArgs.length >= 1)
                 return typescript_1.default.factory.createArrayTypeNode(resolveZodType(typeArgs[0]));
             if (name === 'ZodOptional' && typeArgs && typeArgs.length >= 1)
@@ -119,6 +122,30 @@ const resolveZodTypesTransformer = context => {
                 ]);
             if (name === 'ZodDefault' && typeArgs && typeArgs.length >= 1)
                 return resolveZodType(typeArgs[0]);
+            if (name === 'ZodLiteral' && typeArgs && typeArgs.length >= 1)
+                return typeArgs[0];
+            // v4: ZodEnum<{pending: "pending", confirmed: "confirmed", ...}>
+            if (name === 'ZodEnum' && typeArgs && typeArgs.length >= 1 && typescript_1.default.isTypeLiteralNode(typeArgs[0])) {
+                const types = [];
+                for (const member of typeArgs[0].members) {
+                    if (typescript_1.default.isPropertySignature(member) && member.type)
+                        types.push(member.type);
+                }
+                if (types.length > 0)
+                    return typescript_1.default.factory.createUnionTypeNode(types);
+            }
+            // v4: ZodDiscriminatedUnion<[ZodObject<...>, ...], "disc">
+            if (name === 'ZodDiscriminatedUnion' && typeArgs && typeArgs.length >= 1) {
+                const tuple = unwrapReadonlyTuple(typeArgs[0]);
+                if (tuple)
+                    return typescript_1.default.factory.createUnionTypeNode(tuple.elements.map(e => resolveZodType(e)));
+            }
+            // v4: ZodUnion<readonly [ZodString, ZodNumber]>
+            if (name === 'ZodUnion' && typeArgs && typeArgs.length >= 1) {
+                const tuple = unwrapReadonlyTuple(typeArgs[0]);
+                if (tuple)
+                    return typescript_1.default.factory.createUnionTypeNode(tuple.elements.map(e => resolveZodType(e)));
+            }
             return node;
         }
         function resolveShape(shape) {
@@ -137,7 +164,7 @@ const resolveZodTypesTransformer = context => {
         function typeVisitor(node) {
             if (typescript_1.default.isTypeNode(node)) {
                 const ref = getZodRef(node);
-                if (ref && (ref.name === 'infer' || ref.name === 'TypeOf'))
+                if (ref)
                     return resolveZodType(node);
             }
             return typescript_1.default.visitEachChild(node, typeVisitor, context);
@@ -205,11 +232,15 @@ const removeDefaultExportTransformer = context => {
  *  3. Writes the final file output.
  */
 function cleanTsFile(src) {
-    let sourceCode = fs_1.default.readFileSync(src, 'utf-8');
+    const sourceCode = fs_1.default.readFileSync(src, 'utf-8');
     // Parse the source
     const sourceFile = typescript_1.default.createSourceFile(path_1.default.basename(src), sourceCode, typescript_1.default.ScriptTarget.Latest, true, typescript_1.default.ScriptKind.TS);
     // Run the transformers
-    const result = typescript_1.default.transform(sourceFile, [resolveZodTypesTransformer, removeSecondParamTransformer, removeDefaultExportTransformer]);
+    const result = typescript_1.default.transform(sourceFile, [
+        resolveZodTypesTransformer,
+        removeSecondParamTransformer,
+        removeDefaultExportTransformer
+    ]);
     // Print final code
     const eslintDisable = `/* eslint-disable */`;
     const printer = typescript_1.default.createPrinter();

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "typed-bridge",
     "description": "Strictly typed server functions for typescript apps",
-    "version": "2.1.1",
+    "version": "2.1.3",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "author": "neilveil",

package/readme.md

@@ -217,22 +217,22 @@ createMiddleware('user.*', async (req, res) => {
 
 ## Zod Validation
 
-Typed Bridge ships with Zod and re-exports it as `$z`. Define schemas and use them in handlers:
+Typed Bridge ships with Zod and re-exports it as `z`. Define schemas and use them in handlers:
 
 ### 1. Declare Schemas
 
 `types.ts`:
 
 ```ts
-import { $z } from 'typed-bridge'
+import { z } from 'typed-bridge'
 
 export const fetch = {
-    args: $z.object({
-        id: $z.number().min(1)
+    args: z.object({
+        id: z.number().min(1)
     }),
-    res: $z.object({
-        id: $z.number(),
-        name: $z.string()
+    res: z.object({
+        id: z.number(),
+        name: z.string()
     })
 }
 ```
@@ -240,13 +240,13 @@ export const fetch = {
 ### 2. Use in Handler
 
 ```ts
-import { $z } from 'typed-bridge'
+import { z } from 'typed-bridge'
 import * as types from './types'
 
 export const fetch = async (
-    args: $z.infer<typeof types.fetch.args>,
+    args: z.infer<typeof types.fetch.args>,
     context: { id: number }
-): Promise<$z.infer<typeof types.fetch.res>> => {
+): Promise<z.infer<typeof types.fetch.res>> => {
     args = types.fetch.args.parse(args)
 
     const user = users.find(user => user.id === args.id)
@@ -310,23 +310,23 @@ onShutdown(() => {
 
 ### vs tRPC
 
-| | **Typed Bridge** | **tRPC** |
-|---|---|---|
-| **Setup** | Define functions, generate typed client, done | Routers, procedures, adapters |
-| **Monorepo required?** | No, generated client is a standalone file | Practically yes, for type inference |
-| **Frontend framework** | Any (React, Vue, Angular, RN, etc.) | React-first, adapters for others |
-| **Learning curve** | Minimal, plain async functions | Moderate, procedures, context, middleware patterns |
-| **Runtime validation** | Zod (built-in) | Zod or others via `.input()` |
+|                        | **Typed Bridge**                              | **tRPC**                                           |
+| ---------------------- | --------------------------------------------- | -------------------------------------------------- |
+| **Setup**              | Define functions, generate typed client, done | Routers, procedures, adapters                      |
+| **Monorepo required?** | No, generated client is a standalone file     | Practically yes, for type inference                |
+| **Frontend framework** | Any (React, Vue, Angular, RN, etc.)           | React-first, adapters for others                   |
+| **Learning curve**     | Minimal, plain async functions                | Moderate, procedures, context, middleware patterns |
+| **Runtime validation** | Zod (built-in)                                | Zod or others via `.input()`                       |
 
 ### vs GraphQL
 
-| | **Typed Bridge** | **GraphQL** |
-|---|---|---|
-| **Setup** | Define functions, generate typed client, done | Schema definition, resolvers, codegen |
-| **Type safety** | Automatic from function signatures | Requires codegen toolchain (e.g. GraphQL Code Generator) |
-| **Overfetching** | Not applicable, you control what each function returns | Solved by design with field selection |
-| **Learning curve** | Minimal, plain TypeScript | Significant: SDL, resolvers, fragments, queries, mutations |
-| **Best for** | App-specific backends, internal APIs | Public APIs, multi-client data graphs |
+|                    | **Typed Bridge**                                       | **GraphQL**                                                |
+| ------------------ | ------------------------------------------------------ | ---------------------------------------------------------- |
+| **Setup**          | Define functions, generate typed client, done          | Schema definition, resolvers, codegen                      |
+| **Type safety**    | Automatic from function signatures                     | Requires codegen toolchain (e.g. GraphQL Code Generator)   |
+| **Overfetching**   | Not applicable, you control what each function returns | Solved by design with field selection                      |
+| **Learning curve** | Minimal, plain TypeScript                              | Significant: SDL, resolvers, fragments, queries, mutations |
+| **Best for**       | App-specific backends, internal APIs                   | Public APIs, multi-client data graphs                      |
 
 Typed Bridge is for teams that want **type-safe RPCs without the architecture overhead**. You write normal TypeScript functions on the server, and the client just works.
 
@@ -351,7 +351,7 @@ src/
 ### Adding a new route
 
 1. Create handler in `bridge/<module>/index.ts`
-2. If using Zod, add schemas in `<module>/types.ts` using `$z` from `typed-bridge`
+2. If using Zod, add schemas in `<module>/types.ts` using `z` from `typed-bridge`
 3. Register route in `bridge/index.ts` as `'module.action': module.action`
 4. If middleware needed, add `createMiddleware(...)` and import the file in server entry
 5. Run `gen:typed-bridge-client` to regenerate the typed client
@@ -361,4 +361,3 @@ src/
 ## Developer
 
 Developed & maintained by [neilveil](https://github.com/neilveil). Give a star to support this project!
-

package/test/bridge.ts

@@ -174,6 +174,36 @@ declare const _default: {
         updatedAt: Date;
     }>;
     'order.list': () => Promise<Order[]>;
+    'order.resolve': (args: {
+        id: number;
+    }) => Promise<{
+        status: "found";
+        order: {
+            id: number;
+            customerName: string;
+            orderStatus: "pending" | "confirmed" | "shipped" | "delivered" | "cancelled";
+            total: number;
+        };
+    } | {
+        status: "not_found";
+    }>;
+    'order.statusFilter': (args: {
+        status: "pending" | "confirmed" | "shipped" | "delivered" | "cancelled";
+    }) => Promise<{
+        orders: {
+            id: number;
+            status: "pending" | "confirmed" | "shipped" | "delivered" | "cancelled";
+            total: number;
+        }[];
+    }>;
+    'order.tag': (args: {
+        orderId: number;
+        tag: string | number;
+    }) => Promise<{
+        orderId: number;
+        tag: string | number;
+        appliedAt: Date;
+    }>;
     'order.primitives': (args: {
         key: string;
     }) => Promise<{