zodselect 1.2.8 → 1.3.0

package/README.md

@@ -139,6 +139,14 @@ const schema = refineSchema(UserSchema, {
 }
 ```
 
+A field the schema doesn't have is a type error, at any depth and even beside valid fields:
+
+```ts
+refineSchema(UserSchema, { firstName: true, lastNmae: true }); // ✖ 'lastNmae' is not a field of UserSchema
+```
+
+Code that builds a selection generically, whose type the check can't evaluate, calls `refineSchemaUnchecked` instead: the same refinement, with a field the schema doesn't have skipped.
+
 ---
 
 ## 🧪 Refine Field Types Inline

package/dist/refine-schema.d.ts

@@ -2,6 +2,18 @@ import { core, z, ZodAny, ZodArray, ZodBoolean, ZodDate, ZodLiteral, ZodNever, Z
 import { IsAny, IsJsonType } from './types.js';
 type ApplyOptionalNullable<T, U extends ZodType> = IsAny<T, U, unknown extends T ? U : undefined extends T ? null extends T ? ZodOptional<ZodNullable<U>> : ZodOptional<U> : null extends T ? ZodNullable<U> : U>;
 type DepthLimit = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+/** `TShape` with every key `T` doesn't have, at any depth, as `never`, so a misspelt select is a type error even beside valid keys. */
+type Exact<TShape, T> = {
+    [K in keyof TShape]: K extends FieldKeys<T> ? TShape[K] extends ((schema: never) => unknown) | boolean | ZodType ? TShape[K] : TShape[K] extends object ? Exact<TShape[K], FieldObjects<FieldAt<T, K>>> : TShape[K] : never;
+};
+/** What the field `TKey` holds in any object of `T`. */
+type FieldAt<T, TKey> = T extends unknown ? TKey extends keyof T ? T[TKey] : never : never;
+/** The declared keys of every object in `T`, each of a union's own. */
+type FieldKeys<T> = T extends unknown ? Extract<keyof {
+    [K in keyof T as string extends K ? never : number extends K ? never : K]: unknown;
+}, string> : never;
+/** The objects a field of type `T` holds, through arrays: what a nested select picks within. */
+type FieldObjects<T> = T extends readonly (infer E)[] ? FieldObjects<E> : T extends Date ? never : T extends object ? T : never;
 type InternalZodify<T, TDepth extends number = 0> = TDepth extends 9 ? ZodType : IsAny<T, ZodAny, T extends string ? string extends T ? ZodString : ZodLiteral<T> : T extends number ? number extends T ? ZodNumber : ZodLiteral<T> : T extends boolean ? boolean extends T ? ZodBoolean : ZodLiteral<T> : T extends Date ? ZodDate : unknown extends T ? ZodUnknown : T extends Array<infer U> ? ZodArray<Zodify<U, NextDepth<TDepth>>> : T extends object ? IsJsonType<T, true, ZodObject<{
     [K in keyof T]-?: Zodify<T[K], NextDepth<TDepth>>;
 }, core.$strict>, ZodType<T>> : never>;
@@ -12,8 +24,8 @@ type Push<T extends any[], V> = [...T, V];
 type ReapplyOptionalNullable<T, U extends z.ZodType> = T extends ZodOptional<ZodNullable<ZodType>> ? ZodOptional<ZodNullable<U>> : T extends ZodNullable<ZodOptional<ZodType>> ? ZodNullable<ZodOptional<U>> : T extends ZodOptional<ZodType> ? ZodOptional<U> : T extends ZodNullable<ZodType> ? ZodNullable<U> : U;
 export type RefinedSchema<T extends ZodType<object> | ZodUnion, TShape extends RefineSchema<T, TIsSimple>, TIsSimple extends boolean> = T extends ZodUnion ? RefinedUnionSchema<T, TShape> : T extends ZodType<object> ? RefinedTypeSchema<z.infer<T>, TShape> : never;
 export type RefinedTypeSchema<T extends object, TShape, TDepth extends number = 0> = TDepth extends keyof DepthLimit ? ZodObject<{
-    [K in keyof T & keyof TShape]: TShape[K] extends (schema: infer S) => ZodType ? ReturnType<TShape[K]> : TShape[K] extends ZodType ? TShape[K] : TShape[K] extends boolean ? ZodifyField<T, K> : TShape[K] extends object ? Exclude<T[K], null | undefined> extends Array<infer U> ? [Extract<U, object>] extends [never] ? Zodify<T[K]> : ApplyOptionalNullable<T[K], z.ZodArray<RefinedVariants<Extract<U, object>, TShape[K], NextDepth<TDepth>>>> : [Extract<Exclude<T[K], null | undefined>, object>] extends [never] ? ZodNever : ApplyOptionalNullable<T[K], RefinedVariants<Extract<Exclude<T[K], null | undefined>, object>, TShape[K], NextDepth<TDepth>>> : ZodNever;
-}, core.$strict> : any;
+    [K in keyof T & keyof TShape]: TShape[K] extends (schema: infer _S) => ZodType ? ReturnType<TShape[K]> : TShape[K] extends ZodType ? TShape[K] : TShape[K] extends boolean ? ZodifyField<T, K> : TShape[K] extends object ? Exclude<T[K], null | undefined> extends Array<infer U> ? [Extract<U, object>] extends [never] ? Zodify<T[K]> : ApplyOptionalNullable<T[K], z.ZodArray<RefinedVariants<Extract<U, object>, TShape[K], NextDepth<TDepth>>>> : [Extract<Exclude<T[K], null | undefined>, object>] extends [never] ? ZodNever : ApplyOptionalNullable<T[K], RefinedVariants<Extract<Exclude<T[K], null | undefined>, object>, TShape[K], NextDepth<TDepth>>> : ZodNever;
+}, core.$strip> : any;
 export type RefinedUnionSchema<T extends ZodUnion, TShape> = ZodUnion<T['options'] extends Readonly<[infer A, ...infer Rest]> ? Rest extends ZodType[] ? [
     ReapplyOptionalNullable<A, A extends ZodType<object> ? RefinedTypeSchema<z.infer<A>, TShape> : Extract<A, ZodType>>,
     ...{
@@ -43,5 +55,11 @@ type ZodifyField<T, TKey extends keyof T> = unknown extends T[TKey] ? Partial<Pi
 type ZodifyLiteral<T, TElse> = [
     T
 ] extends [boolean | number | string] ? [T] extends [boolean] ? boolean extends T ? ZodBoolean : ZodLiteral<T> : string extends T ? [T] extends [string] ? ZodString : TElse : number extends T ? [T] extends [number] ? ZodNumber : TElse : ZodLiteral<T> : TElse;
-export declare function refineSchema<T extends ZodType<object> | ZodUnion, TShape extends RefineSchema<T, false>>(schema: T, shape: TShape): RefinedSchema<T, TShape, false>;
+/** `shape`'s fields of `schema`. A key the schema doesn't have, at any depth, is a type error. */
+export declare function refineSchema<T extends ZodType<object> | ZodUnion, TShape extends RefineSchema<T, false>>(schema: T, shape: TShape & Exact<TShape, z.infer<T>>): RefinedSchema<T, TShape, false>;
+/**
+ * {@link refineSchema} for a shape whose type is still generic, which the exact key check can't evaluate.
+ * Prefer {@link refineSchema}: a key the schema doesn't have is skipped here, not refused.
+ */
+export declare function refineSchemaUnchecked<T extends ZodType<object> | ZodUnion, TShape extends RefineSchema<T, false>>(schema: T, shape: TShape): RefinedSchema<T, TShape, false>;
 export {};

package/dist/refine-schema.js

@@ -1,22 +1,8 @@
 import { z } from 'zod';
 import { isZodArray, isZodCatch, isZodDefault, isZodLazy, isZodNullable, isZodObject, isZodOptional, isZodType, isZodUnion } from './utilities.js';
-// Main function to refine the schema
+/** `shape`'s fields of `schema`. A key the schema doesn't have, at any depth, is a type error. */
 export function refineSchema(schema, shape) {
-    if (isZodObject(schema)) {
-        const refinedShape = {};
-        const schemaShape = schema.shape;
-        for (const key in shape) {
-            if (key in schemaShape && shape[key] !== false) {
-                refinedShape[key] = refineSchemaField(schemaShape[key], shape[key]);
-            }
-        }
-        return z.object(refinedShape);
-    }
-    else if (isZodUnion(schema)) {
-        const refinedOptions = schema.options.map(option => refineSchemaField(option, shape));
-        return z.union(refinedOptions);
-    }
-    throw new Error('Unsupported schema type for refinement');
+    return refineSchemaUnchecked(schema, shape);
 }
 // Helper function to refine a single schema field
 function refineSchemaField(fieldSchema, fieldShape) {
@@ -30,10 +16,10 @@ function refineSchemaField(fieldSchema, fieldShape) {
         return fieldShape; // Use redefined type
     }
     else if (isZodObject(fieldSchema)) {
-        return refineSchema(fieldSchema, fieldShape); // Recursively refine nested objects
+        return refineSchemaUnchecked(fieldSchema, fieldShape); // Recursively refine nested objects
     }
     else if (isZodUnion(fieldSchema)) {
-        return refineSchema(fieldSchema, fieldShape);
+        return refineSchemaUnchecked(fieldSchema, fieldShape);
     }
     else if (isZodArray(fieldSchema)) {
         // Recursively refine array items
@@ -54,3 +40,24 @@ function refineSchemaField(fieldSchema, fieldShape) {
     }
     return fieldSchema;
 }
+/**
+ * {@link refineSchema} for a shape whose type is still generic, which the exact key check can't evaluate.
+ * Prefer {@link refineSchema}: a key the schema doesn't have is skipped here, not refused.
+ */
+export function refineSchemaUnchecked(schema, shape) {
+    if (isZodObject(schema)) {
+        const refinedShape = {};
+        const schemaShape = schema.shape;
+        for (const key in shape) {
+            if (key in schemaShape && shape[key] !== false) {
+                refinedShape[key] = refineSchemaField(schemaShape[key], shape[key]);
+            }
+        }
+        return z.object(refinedShape);
+    }
+    else if (isZodUnion(schema)) {
+        const refinedOptions = schema.options.map(option => refineSchemaField(option, shape));
+        return z.union(refinedOptions);
+    }
+    throw new Error('Unsupported schema type for refinement');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zodselect",
-  "version": "1.2.8",
+  "version": "1.3.0",
   "description": "Type-safe selection utility built on top of Zod. Allows for strongly typed field selection, schema merging, and runtime refinement for frontend or backend use.",
   "author": "SecureDataSystems",
   "license": "MIT",
@@ -25,12 +25,13 @@
     }
   },
   "devDependencies": {
-    "@temelyos/eslint-config": "^1.0.38",
+    "@temelyos/oxlint-config": "^1.1.0",
     "@temelyos/tsconfig": "^1.0.6",
     "@types/node": "^26.1.1",
+    "oxlint": "^1.88.0",
+    "oxlint-tsgolint": "^7.0.2004",
     "tsx": "^4.23.1",
-    "typescript": "npm:@typescript/typescript6@^6.0.2",
-    "typescript-native": "npm:typescript@^7.0.2"
+    "typescript": "^7.0.2"
   },
   "dependencies": {
     "zod": "^4.4.3"
@@ -39,8 +40,8 @@
     "build": "node scripts/build.mjs && tsc --project tsconfig.build.json",
     "clean": "node scripts/clean.mjs",
     "deploy": "npm run build && node ./scripts/publish.mjs",
-    "lint": "eslint . --c eslint.config.mjs",
-    "lint:fix": "eslint . --c eslint.config.mjs --fix",
+    "lint": "oxlint",
+    "lint:fix": "temelyos-oxlint-fix",
     "prune": "node scripts/prune.mjs",
     "test": "tsx --tsconfig ./tsconfig.build.json --test ./src/**/*.{spec,test}.ts ./test/**/*.{spec,test}.ts"
   }

package/dist/build-select-object.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/build-select-object.spec.js

@@ -1,211 +0,0 @@
-import { strict as assert } from 'assert';
-import { describe, it } from 'node:test';
-import { z } from 'zod';
-import { buildSelectObject } from './build-select-object.js';
-describe('.buildSelectObject()', () => {
-    it('should return all keys set to true for a flat object', () => {
-        const schema = z.object({
-            age: z.number(),
-            name: z.string()
-        });
-        assert.deepStrictEqual(buildSelectObject(schema), { age: true, name: true });
-    });
-    it('should merge keys from all union members', () => {
-        const schema = z.union([
-            z.object({ type: z.literal('a'), valueA: z.string() }),
-            z.object({ type: z.literal('b'), valueB: z.number() })
-        ]);
-        assert.deepStrictEqual(buildSelectObject(schema), {
-            type: true,
-            valueA: true,
-            valueB: true
-        });
-    });
-    it('should merge keys from an intersection', () => {
-        const schema = z.intersection(z.object({ a: z.string() }), z.object({ b: z.number() }));
-        assert.deepStrictEqual(buildSelectObject(schema), { a: true, b: true });
-    });
-    it('should unwrap optional/nullable wrappers', () => {
-        const inner = z.object({ id: z.string(), value: z.number() });
-        const schema = inner.optional();
-        assert.deepStrictEqual(buildSelectObject(schema), { id: true, value: true });
-    });
-    it('should unwrap lazy schemas', () => {
-        const schema = z.lazy(() => z.object({ bar: z.number(), foo: z.string() }));
-        assert.deepStrictEqual(buildSelectObject(schema), { bar: true, foo: true });
-    });
-    it('should handle nested unions inside intersection', () => {
-        const schema = z.intersection(z.union([
-            z.object({ a: z.string() }),
-            z.object({ b: z.number() })
-        ]), z.object({ c: z.boolean() }));
-        assert.deepStrictEqual(buildSelectObject(schema), {
-            a: true,
-            b: true,
-            c: true
-        });
-    });
-    it('should recursively expand nested objects', () => {
-        const schema = z.object({
-            active: z.boolean(),
-            user: z.object({
-                age: z.number(),
-                name: z.string()
-            })
-        });
-        assert.deepStrictEqual(buildSelectObject(schema), {
-            active: true,
-            user: { age: true, name: true }
-        });
-    });
-    it('should recursively expand deeply nested objects', () => {
-        const schema = z.object({
-            name: z.string(),
-            organization: z.object({
-                _id: z.string(),
-                address: z.object({
-                    city: z.string(),
-                    country: z.string()
-                })
-            })
-        });
-        assert.deepStrictEqual(buildSelectObject(schema), {
-            name: true,
-            organization: { _id: true, address: { city: true, country: true } }
-        });
-    });
-    it('should expand optional nested objects', () => {
-        const schema = z.object({
-            name: z.string(),
-            organization: z.object({
-                _id: z.string(),
-                name: z.string()
-            }).optional()
-        });
-        assert.deepStrictEqual(buildSelectObject(schema), {
-            name: true,
-            organization: { _id: true, name: true }
-        });
-    });
-    it('should not expand arrays', () => {
-        const schema = z.object({
-            name: z.string(),
-            tags: z.array(z.string())
-        });
-        assert.deepStrictEqual(buildSelectObject(schema), { name: true, tags: true });
-    });
-    it('should expand the items of an array of objects', () => {
-        const schema = z.object({
-            items: z.array(z.object({ id: z.string(), value: z.number() })),
-            name: z.string()
-        });
-        const select = buildSelectObject(schema);
-        const isTyped = true;
-        assert.ok(isTyped);
-        assert.deepStrictEqual(select, { items: { id: true, value: true }, name: true });
-    });
-    it('should expand an optional array of optional objects', () => {
-        const schema = z.object({
-            items: z.array(z.object({ id: z.string() }).optional()).optional()
-        });
-        const select = buildSelectObject(schema);
-        const isTyped = true;
-        assert.ok(isTyped);
-        assert.deepStrictEqual(select, { items: { id: true } });
-    });
-    it('should expand arrays of objects inside arrays of objects', () => {
-        const schema = z.object({
-            attachments: z.array(z.object({
-                history: z.array(z.object({ note: z.string(), uploadedBy: z.object({ _id: z.string(), username: z.string() }) })),
-                title: z.string()
-            }))
-        });
-        const select = buildSelectObject(schema);
-        const isTyped = true;
-        assert.ok(isTyped);
-        assert.deepStrictEqual(select, {
-            attachments: { history: { note: true, uploadedBy: { _id: true, username: true } }, title: true }
-        });
-    });
-    it('should type nested objects as nested selects', () => {
-        const schema = z.object({
-            client: z.object({ _id: z.string(), name: z.string() }).optional(),
-            title: z.string()
-        });
-        const select = buildSelectObject(schema);
-        const isTyped = true;
-        assert.ok(isTyped);
-        assert.deepStrictEqual(select, { client: { _id: true, name: true }, title: true });
-    });
-    it('should not expand records, or arrays of anything but objects', () => {
-        const schema = z.object({
-            byKey: z.record(z.string(), z.object({ id: z.string() })),
-            matrix: z.array(z.array(z.number())),
-            tags: z.array(z.string())
-        });
-        const select = buildSelectObject(schema);
-        const isTyped = true;
-        assert.ok(isTyped);
-        assert.deepStrictEqual(select, { byKey: true, matrix: true, tags: true });
-    });
-    it('should select a union field whole when a variant is not an object', () => {
-        const schema = z.object({
-            file: z.union([z.object({ _id: z.string(), filename: z.string() }), z.string()]),
-            name: z.union([z.string(), z.object({ first: z.string(), last: z.string() })])
-        });
-        const select = buildSelectObject(schema);
-        const isTyped = true;
-        assert.ok(isTyped);
-        assert.deepStrictEqual(select, { file: true, name: true });
-    });
-    it('should merge the keys of every object variant of a union field', () => {
-        const schema = z.object({
-            party: z.union([z.object({ name: z.string(), type: z.literal('company') }), z.object({ first: z.string(), type: z.literal('person') })]).optional()
-        });
-        const select = buildSelectObject(schema);
-        const isTyped = true;
-        assert.ok(isTyped);
-        assert.deepStrictEqual(select, { party: { first: true, name: true, type: true } });
-    });
-    it('should not expand a union field with no object variant', () => {
-        const schema = z.object({ value: z.union([z.string(), z.number()]).nullable() });
-        const select = buildSelectObject(schema);
-        const isTyped = true;
-        assert.ok(isTyped);
-        assert.deepStrictEqual(select, { value: true });
-    });
-    it('should expand an array of a union of objects', () => {
-        const schema = z.object({
-            options: z.array(z.union([z.object({ a: z.string() }), z.object({ b: z.string() })]))
-        });
-        const select = buildSelectObject(schema);
-        const isTyped = true;
-        assert.ok(isTyped);
-        assert.deepStrictEqual(select, { options: { a: true, b: true } });
-    });
-    it('should be a select the schema accepts', () => {
-        const schema = z.object({
-            client: z.object({ _id: z.string(), name: z.string() }),
-            items: z.array(z.object({ id: z.string() }))
-        });
-        const select = buildSelectObject(schema);
-        assert.deepStrictEqual(select, { client: { _id: true, name: true }, items: { id: true } });
-    });
-    it('should handle recursive schemas without infinite loop', () => {
-        ;
-        const node = z.lazy(() => z.object({
-            children: z.array(node).optional(),
-            name: z.string(),
-            parent: node.optional()
-        }));
-        const schema = z.object({
-            name: z.string(),
-            root: node
-        });
-        // Should not throw or hang — recursive objects hit depth limit
-        const result = buildSelectObject(schema);
-        assert.strictEqual(result.name, true);
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        assert.ok(typeof result.root === 'object' && result.root !== null);
-    });
-});

package/dist/build-select-schema.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/build-select-schema.spec.js

@@ -1,242 +0,0 @@
-import { strict as assert } from 'assert';
-import { describe, it } from 'node:test';
-import { z, ZodObject } from 'zod';
-import { buildSelectSchema } from './build-select-schema.js';
-import { getInnerType, isZodObjectLoose } from './utilities.js';
-describe('.buildSelectSchema()', () => {
-    it('should build select schema for a flat object', () => {
-        const schema = z.object({
-            age: z.number(),
-            name: z.string()
-        });
-        const selectSchema = buildSelectSchema(schema);
-        assert(selectSchema instanceof ZodObject);
-        assert.deepEqual(selectSchema.parse({ name: true }), { name: true });
-        assert.deepEqual(selectSchema.parse({}), {});
-        assert.throws(() => selectSchema.parse({ name: 'yes' }), /expected boolean/);
-        assert.throws(() => selectSchema.parse({ unknown: true }), /Unrecognized key/);
-    });
-    it('should handle nested objects', () => {
-        const schema = z.object({
-            user: z.object({
-                id: z.string(),
-                profile: z.object({
-                    displayName: z.string()
-                })
-            })
-        });
-        const selectSchema = buildSelectSchema(schema);
-        const result = selectSchema.parse({
-            user: {
-                id: true,
-                profile: {
-                    displayName: true
-                }
-            }
-        });
-        assert.deepEqual(result, {
-            user: {
-                id: true,
-                profile: {
-                    displayName: true
-                }
-            }
-        });
-    });
-    it('should build select schema for a union of objects', () => {
-        const schema = z.union([
-            z.object({ type: z.literal('a'), valueA: z.string() }).strict(),
-            z.object({ type: z.literal('b'), valueB: z.number() }).strict()
-        ]);
-        const selectSchema = buildSelectSchema(schema);
-        assert(selectSchema instanceof ZodObject);
-        const result = selectSchema.parse({
-            type: true,
-            valueA: true
-        });
-        assert.deepEqual(result, {
-            type: true,
-            valueA: true
-        });
-        assert.throws(() => selectSchema.parse({ valueC: true }), /Unrecognized key/);
-    });
-    it('z.infer of a union select schema should be a plain select type', () => {
-        const schema = z.union([
-            z.object({ shared: z.string(), type: z.literal('a'), valueA: z.string() }).strict(),
-            z.object({ shared: z.string(), type: z.literal('b'), valueB: z.number() }).strict()
-        ]);
-        const selectSchema = buildSelectSchema(schema);
-        // Runtime: the schema correctly parses a plain select object
-        assert.deepEqual(selectSchema.parse({ shared: true, type: true, valueA: true }), { shared: true, type: true, valueA: true });
-        const plain = {};
-        void plain;
-        assert.ok(true);
-    });
-    it('should support intersections of objects', () => {
-        const schema = z.intersection(z.object({ a: z.string() }), z.object({ b: z.number() }));
-        const select = buildSelectSchema(schema);
-        assert.strictEqual(getInnerType(select.shape.a).def.type, 'boolean');
-        assert.strictEqual(getInnerType(select.shape.b).def.type, 'boolean');
-    });
-    it('should support tuples of objects', () => {
-        const schema = z.tuple([
-            z.object({ foo: z.string() }),
-            z.object({ bar: z.number() })
-        ]);
-        const select = buildSelectSchema(schema);
-        assert.strictEqual(getInnerType(select.shape.foo).def.type, 'boolean');
-        assert.strictEqual(getInnerType(select.shape.bar).def.type, 'boolean');
-    });
-    it('should return a strict schema if any member is strict', () => {
-        const schema = z.union([
-            z.object({ strictA: z.string() }).strict(),
-            z.object({ strictB: z.number() }).strict()
-        ]);
-        const select = buildSelectSchema(schema);
-        assert.strictEqual(isZodObjectLoose(select), false);
-    });
-    it('should return a strict schema when only one union member is strict', () => {
-        const schema = z.union([
-            z.object({ strictA: z.string() }).strict(),
-            z.looseObject({ looseB: z.number() })
-        ]);
-        const select = buildSelectSchema(schema);
-        // Any strict member makes the merged select strict so callers cannot
-        // accidentally reference fields outside any member's defined shape.
-        assert.strictEqual(isZodObjectLoose(select), false);
-    });
-    it('should allow optional keys in the select schema', () => {
-        const schema = z.object({
-            optionalField: z.string().optional()
-        });
-        const select = buildSelectSchema(schema);
-        assert.strictEqual(getInnerType(select.shape.optionalField).def.type, 'boolean');
-    });
-    it('should handle direct recursion', () => {
-        const roleSchema = z.lazy(() => {
-            return (z.object({
-                name: z.string(),
-                roles: z.array(roleSchema)
-            }));
-        });
-        const select = buildSelectSchema(roleSchema);
-        assert.deepStrictEqual(Object.keys(select.shape), ['name', 'roles']);
-        const nameSelect = select.shape.name;
-        assert.strictEqual(nameSelect.def.type, 'optional');
-        assert.strictEqual(nameSelect.def.innerType.def.type, 'boolean');
-        const rolesSelect = select.shape.roles;
-        assert.strictEqual(rolesSelect.def.type, 'lazy');
-        const innerUnion = rolesSelect.def.getter().def.innerType;
-        assert.strictEqual(innerUnion.def.type, 'union');
-        const booleanItem = innerUnion.def.options[0];
-        assert.strictEqual(booleanItem.def.type, 'boolean');
-        const roleItem = innerUnion.def.options[1];
-        assert.strictEqual(roleItem.def.type, 'object');
-    });
-    it('should support mutual recursion (cross-recursive)', () => {
-        const schemaA = z.lazy(() => z.object({
-            b: schemaB
-        }));
-        const schemaB = z.lazy(() => z.object({
-            a: schemaA
-        }));
-        const select = buildSelectSchema(schemaA);
-        assert.strictEqual(select.shape.b.def.type, 'lazy');
-        const bUnion = select.shape.b.def.getter();
-        assert.strictEqual(bUnion.def.innerType.def.type, 'union');
-        const bObj = bUnion.def.innerType.def.options[1];
-        assert.strictEqual(bObj.shape.a.def.type, 'lazy');
-    });
-    it('should share the same instance in recursion (no infinite loop)', () => {
-        const role = z.lazy(() => z.object({
-            name: z.string(),
-            roles: z.array(role)
-        }));
-        const select = buildSelectSchema(role);
-        const rolesSelect = select.shape.roles;
-        const unionSelect = rolesSelect.def.getter().def.innerType;
-        const nestedRoleSelect = unionSelect.def.options[1].shape.roles;
-        // Should be the same object (by reference)
-        assert.strictEqual(rolesSelect, nestedRoleSelect);
-    });
-    it('should support record types', () => {
-        const schema = z.object({
-            tags: z.record(z.string(), z.string())
-        });
-        const select = buildSelectSchema(schema);
-        const tagsSelect = select.shape.tags;
-        assert.strictEqual(tagsSelect.type, 'optional');
-        const union = tagsSelect.def.innerType;
-        assert.strictEqual(union.type, 'union');
-        assert.strictEqual(union.def.options[0].type, 'boolean');
-        assert.strictEqual(union.def.options[1].type, 'record');
-        assert.strictEqual(union.def.options[1].def.keyType.type, 'string');
-        assert.strictEqual(union.def.options[1].def.valueType.type, 'optional');
-        assert.strictEqual(union.def.options[1].def.valueType.def.innerType.type, 'boolean');
-    });
-    it('should share the same lazy instance for a recursive schema referenced by multiple union members', () => {
-        const nested = z.lazy(() => z.object({ children: z.array(nested) }));
-        const schema = z.union([
-            z.object({ a: nested }),
-            z.object({ b: nested })
-        ]);
-        const select = buildSelectSchema(schema);
-        // Both 'a' and 'b' reference the same `nested` schema.
-        // Their select schemas must be the same lazy instance (shared cache).
-        const aSelect = select.shape.a;
-        const bSelect = select.shape.b;
-        assert.strictEqual(aSelect, bSelect);
-    });
-    it('should support unknown types', () => {
-        const schema = z.object({
-            tags: z.unknown()
-        });
-        const select = buildSelectSchema(schema);
-        const result = select.safeParse({
-            tags: {
-                any: {
-                    damn: true
-                },
-                thing: true
-            }
-        });
-        assert.strictEqual(result.success, true);
-        assert.deepStrictEqual(result.data, {
-            tags: {
-                any: {
-                    damn: true
-                },
-                thing: true
-            }
-        });
-    });
-    it('should allow nested object sub-selection in union members', () => {
-        const account = z.object({
-            _id: z.string(),
-            name: z.string()
-        });
-        const individual = z.object({
-            account: account.optional(),
-            name: z.object({ first: z.string(), last: z.string() }),
-            type: z.literal('individual')
-        });
-        const organization = z.object({
-            account: account.optional(),
-            name: z.string(),
-            type: z.literal('organization')
-        });
-        const contact = z.union([individual, organization]);
-        const selectSchema = buildSelectSchema(contact);
-        // Runtime: nested sub-selection on a shared nested object field should parse
-        const result = selectSchema.parse({
-            account: { _id: true, name: true },
-            type: true
-        });
-        assert.deepStrictEqual(result, {
-            account: { _id: true, name: true },
-            type: true
-        });
-        const nested = { account: { _id: true, name: true }, type: true };
-        void nested;
-    });
-});

package/dist/refine-schema.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/refine-schema.spec.js

@@ -1,414 +0,0 @@
-import { strict as assert, deepStrictEqual, throws } from 'assert';
-import { describe, it } from 'node:test';
-import { z, ZodError } from 'zod';
-import { refineSchema } from './refine-schema.js';
-describe('.refineSchema()', () => {
-    it('should retain required fields', () => {
-        const userSchema = z.object({
-            age: z.number().optional(),
-            firstName: z.string(),
-            lastName: z.string()
-        });
-        const refinedSchema = refineSchema(userSchema, {
-            firstName: true,
-            lastName: true
-        });
-        const parsedData = refinedSchema.parse({
-            firstName: 'John',
-            lastName: 'Doe'
-        });
-        assert.equal(parsedData.firstName, 'John');
-        assert.equal(parsedData.lastName, 'Doe');
-    });
-    it('should handle optional fields', () => {
-        const userSchema = z.object({
-            age: z.number().optional(),
-            firstName: z.string(),
-            lastName: z.string()
-        });
-        const refinedSchema = refineSchema(userSchema, {
-            age: true
-        });
-        const parsedData = refinedSchema.parse({ age: 25 });
-        assert.equal(parsedData.age, 25);
-        const parsedWithoutAge = refinedSchema.parse({});
-        assert.equal(parsedWithoutAge.age, undefined);
-    });
-    it('should handle nullable fields', () => {
-        const roleSchema = z.object({
-            name: z.string()
-        });
-        const userSchema = z.object({
-            firstName: z.string(),
-            role: roleSchema.nullable()
-        });
-        const refinedSchema = refineSchema(userSchema, {
-            role: true
-        });
-        const parsedWithNullRole = refinedSchema.parse({
-            firstName: 'Alice',
-            role: null
-        });
-        assert.equal(parsedWithNullRole.role, null);
-    });
-    it('should handle both optional and nullable fields', () => {
-        const roleSchema = z.object({
-            name: z.string()
-        });
-        const userSchema = z.object({
-            firstName: z.string(),
-            role: roleSchema.nullable().optional()
-        });
-        const refinedSchema = refineSchema(userSchema, {
-            role: {
-                name: true
-            }
-        });
-        const parsedWithRole = refinedSchema.parse({
-            firstName: 'Alice',
-            role: { name: 'Admin' }
-        });
-        assert.deepStrictEqual(parsedWithRole.role, { name: 'Admin' });
-        const parsedWithNullRole = refinedSchema.parse({
-            firstName: 'Alice',
-            role: null
-        });
-        assert.strictEqual(parsedWithNullRole.role, null);
-        const parsedWithoutRole = refinedSchema.parse({ firstName: 'Alice' });
-        assert.strictEqual(parsedWithoutRole.role, undefined);
-    });
-    it('should apply custom schema transformations', () => {
-        const roleSchema = z.object({
-            name: z.string()
-        });
-        const userSchema = z.object({
-            firstName: z.string(),
-            role: roleSchema
-        });
-        const refinedSchema = refineSchema(userSchema, {
-            role: schema => schema.extend({ permissions: z.array(z.string()) })
-        });
-        const parsedData = refinedSchema.parse({
-            firstName: 'Bob',
-            role: { name: 'User', permissions: ['read', 'write'] }
-        });
-        assert.deepEqual(parsedData.role, {
-            name: 'User',
-            permissions: ['read', 'write']
-        });
-    });
-    it('should handle nested arrays', () => {
-        const roleSchema = z.object({
-            level: z.number(),
-            title: z.string()
-        });
-        const userSchema = z.object({
-            age: z.number().optional(),
-            firstName: z.string(),
-            lastName: z.string(),
-            nestedArray: z.array(z.object({ name: z.string(), value: z.number() })).optional().nullable(),
-            role: roleSchema.nullable().optional(),
-            tags: z.array(z.string()).optional()
-        });
-        const refinedSchema = refineSchema(userSchema, {
-            nestedArray: {
-                name: true
-            }
-        });
-        const parsedData = refinedSchema.parse({
-            firstName: 'Alice',
-            lastName: 'Smith',
-            nestedArray: [{ name: 'Feature1', value: 10 }, { name: 'Feature2', value: 20 }]
-        });
-        assert.deepStrictEqual(parsedData.nestedArray, [{ name: 'Feature1' }, { name: 'Feature2' }]);
-        // Test optional array
-        const parsedWithoutNestedArray = refinedSchema.parse({
-            firstName: 'Alice',
-            lastName: 'Smith'
-        });
-        assert.equal(parsedWithoutNestedArray.nestedArray, undefined);
-    });
-    it('keeps an array under a default, a catch or a lazy an array of the picked fields', () => {
-        const line = z.object({ id: z.string(), secret: z.string() });
-        const order = z.object({
-            caught: z.array(line).catch([]),
-            defaulted: z.array(line).default([]),
-            lazy: z.lazy(() => z.array(line))
-        });
-        const refined = refineSchema(order, { caught: { id: true }, defaulted: { id: true }, lazy: { id: true } });
-        const lines = [{ id: 'a', secret: 's' }];
-        deepStrictEqual(refined.parse({ caught: lines, defaulted: lines, lazy: lines }), { caught: [{ id: 'a' }], defaulted: [{ id: 'a' }], lazy: [{ id: 'a' }] });
-        assert.ok(refined.shape.defaulted instanceof z.ZodArray);
-        assert.ok(refined.shape.caught instanceof z.ZodArray);
-    });
-    it('should handle custom fields', () => {
-        const userSchema = z.object({
-            address: z.custom().optional(),
-            firstName: z.string(),
-            lastName: z.string()
-        });
-        const refinedSchema = refineSchema(userSchema, {
-            address: true
-        });
-        const parsedData = refinedSchema.parse({
-            address: {
-                city: 'Austin',
-                state: 'TX',
-                street: '123 Main Street'
-            },
-            firstName: 'Alice',
-            lastName: 'Smith'
-        });
-        assert.deepStrictEqual(parsedData, {
-            address: {
-                city: 'Austin',
-                state: 'TX',
-                street: '123 Main Street'
-            }
-        });
-    });
-    it('should support unions of objects', () => {
-        const person = z.object({
-            firstName: z.string(),
-            lastName: z.string()
-        });
-        const address = z.object({
-            address: z.string(),
-            city: z.string()
-        });
-        const schema = refineSchema(z.union([person, address]), {
-            address: true,
-            firstName: true
-        });
-        let parseResult = schema.parse({
-            address: '123 Main Street',
-            firstName: 'Jerry',
-            lastName: 'Springer'
-        });
-        deepStrictEqual(parseResult, { firstName: 'Jerry' });
-        parseResult = schema.parse({
-            address: '123 Main Street',
-            city: 'Austin'
-        });
-        deepStrictEqual(parseResult, { address: '123 Main Street' });
-    });
-    it('should error if none of the types are matched', () => {
-        const person = z.object({
-            firstName: z.string(),
-            lastName: z.string()
-        });
-        const address = z.object({
-            address: z.string(),
-            city: z.string()
-        });
-        const schema = refineSchema(z.union([person, address]), {
-            address: true,
-            firstName: true
-        });
-        throws(() => {
-            schema.parse({
-                lastName: 'Springer'
-            });
-        }, (err) => {
-            if (!(err instanceof ZodError) || err.issues[0].code !== 'invalid_union') {
-                return false;
-            }
-            return true;
-        });
-    });
-    it('should exclude fields specified as false in the shape', () => {
-        const schema = z.object({
-            firstName: z.string(),
-            lastName: z.string()
-        });
-        const refined = refineSchema(schema, {
-            firstName: true,
-            lastName: false
-        });
-        // lastName was specified as false — it should be excluded from the refined schema
-        const result = refined.parse({ firstName: 'Alice', lastName: 'Smith' });
-        assert.deepStrictEqual(result, { firstName: 'Alice' });
-    });
-    it('should support unions of objects and simple types', () => {
-        const person = z.object({
-            firstName: z.string(),
-            lastName: z.string()
-        });
-        const schema = refineSchema(z.union([person, z.string()]), {
-            address: true,
-            firstName: true
-        });
-        let parseResult = schema.parse({
-            firstName: 'Jerry',
-            lastName: 'Springer'
-        });
-        deepStrictEqual(parseResult, { firstName: 'Jerry' });
-        parseResult = schema.parse('123 Main Street');
-        deepStrictEqual(parseResult, '123 Main Street');
-    });
-    it('should accept selecting a subfield of a union member with an optional array-of-objects field', () => {
-        // Regression test for a bug in `UnionFieldType` (refine-schema.ts).
-        //
-        // `UnionFieldType` chose a union member field's refine shape with
-        // `z.infer<T> extends Array<infer U>` but, unlike `RefineType`, it did not
-        // strip `| undefined` first. For an OPTIONAL array-of-objects member
-        // (`field: Obj.array().optional()`), `z.infer<T>` is `Obj[] | undefined`,
-        // which is NOT assignable to `Array<infer U>`, so the field's refine shape
-        // collapsed to `RefineObject<Obj[]>` (the array's own keys) instead of
-        // `RefineObject<Obj>`. The runtime was unaffected, so this only broke the
-        // type-check (`tsc`), not `tsx --test`.
-        const accessLevel = z.object({
-            _id: z.string(),
-            name: z.string()
-        });
-        const organizationInvitation = z.object({
-            accessLevels: accessLevel.array().optional(),
-            organizationId: z.string(),
-            type: z.literal('organization')
-        });
-        const platformInvitation = z.object({
-            accessLevels: accessLevel.array().optional(),
-            type: z.literal('platform')
-        });
-        const invitation = z.discriminatedUnion('type', [organizationInvitation, platformInvitation]);
-        // Type-level assertion: drilling into a subfield of the optional array
-        // member is a valid select and MUST be assignable to the refine shape.
-        // With the bug present, this `satisfies` fails to compile.
-        const select = {
-            accessLevels: { name: true },
-            type: true
-        };
-        const refined = refineSchema(invitation, select);
-        const parsed = refined.parse({
-            accessLevels: [{ name: 'Admin' }],
-            type: 'organization'
-        });
-        assert.equal(parsed.type, 'organization');
-        assert.deepEqual(parsed.accessLevels, [{ name: 'Admin' }]);
-    });
-    it('allows selecting a nested subfield of a declared looseObject field', () => {
-        // Regression test for `RefineObject` collapsing a `z.looseObject`'s declared fields.
-        //
-        // A `z.looseObject` carries a catchall index signature (`[k: string]: unknown`).
-        // `RefineObject` maps over `keyof T`, and when `T` has an index signature `keyof T`
-        // collapses to `string | number`, so every declared field's value type came from the
-        // catchall (`unknown` -> scalar `boolean`). Declared fields could be marked `true` but
-        // could NOT be drilled into. The runtime was unaffected, so this only broke the
-        // type-check (`tsc`), not `tsx --test`.
-        const personName = z.object({
-            first: z.string().optional(),
-            last: z.string().optional()
-        });
-        const user = z.looseObject({
-            _id: z.string(),
-            name: personName.optional(),
-            username: z.string()
-        });
-        const root = z.object({
-            invitedBy: user
-        });
-        // Type-level assertion: drilling into `invitedBy.name.first` is valid and MUST be
-        // assignable to the refine shape. With the bug present this `satisfies` fails to
-        // compile because `invitedBy`'s declared fields collapse to an index signature with
-        // `boolean` values.
-        const select = {
-            invitedBy: { name: { first: true } }
-        };
-        const refined = refineSchema(root, select);
-        const parsed = refined.parse({
-            invitedBy: { name: { first: 'Alice' } }
-        });
-        assert.equal(parsed.invitedBy.name?.first, 'Alice');
-    });
-    it('keeps every option of a small enum in the refined type (control)', () => {
-        const stage = z.enum(['one', 'two', 'three']);
-        const project = z.object({ name: z.string(), stage });
-        const refined = refineSchema(project, { stage: true });
-        // Type-level assertion: every option must remain assignable to the refined type.
-        const selected = [
-            { stage: 'one' },
-            { stage: 'two' },
-            { stage: 'three' }
-        ];
-        deepStrictEqual(selected.map(s => refined.parse(s).stage), stage.options);
-    });
-    it('keeps every option of an enum wider than nine options in the refined type', () => {
-        // Regression test for `TuplifyUnion` (refine-schema.ts) truncating wide enums.
-        //
-        // `TuplifyUnion` spends one recursion level per union member and stops at its
-        // depth cap, so an enum field refined with `true` silently dropped every option
-        // past nine from the refined TYPE — and which options vanished varied with
-        // TypeScript's internal union ordering. Fixed by the ZodLiteral shortcut in
-        // `Zodify`. The runtime was unaffected, so this only broke the type-check
-        // (`tsc`), not `tsx --test`.
-        const stage = z.enum([
-            'draft', 'interviewing', 'interview-complete',
-            'previewing', 'preview-review',
-            'plan-review', 'plan-approved', 'local',
-            'spec-review', 'spec-approved',
-            'implementing', 'module-ready'
-        ]);
-        const project = z.object({ name: z.string(), stage });
-        const refined = refineSchema(project, { stage: true });
-        // Type-level assertion: each of the twelve options must remain assignable to
-        // the refined type. With the bug present, three of these assignments fail TS2322.
-        const selected = [
-            { stage: 'draft' },
-            { stage: 'interviewing' },
-            { stage: 'interview-complete' },
-            { stage: 'previewing' },
-            { stage: 'preview-review' },
-            { stage: 'plan-review' },
-            { stage: 'plan-approved' },
-            { stage: 'local' },
-            { stage: 'spec-review' },
-            { stage: 'spec-approved' },
-            { stage: 'implementing' },
-            { stage: 'module-ready' }
-        ];
-        deepStrictEqual(selected.map(s => refined.parse(s).stage), stage.options);
-    });
-});
-describe('.refineSchema() literal and unknown field types', () => {
-    // Regression tests for `Zodify` (refine-schema.ts) when a schema's fields are listed
-    // (e.g. via `buildSelectObject`) instead of selected whole. Before the fix a numeric
-    // literal union widened to `number` and a required `z.unknown()` field became
-    // optional, so the selected type no longer fit the source type. Runtime was
-    // unaffected; these assignments fail the type-check (`tsc`).
-    const question = z.object({
-        answer: z.object({ value: z.unknown() }),
-        flag: z.literal(true),
-        note: z.unknown().optional(),
-        scale: z.union([z.literal(5), z.literal(10)]),
-        steps: z.literal([3, 7]),
-        value: z.unknown()
-    });
-    const survey = z.object({
-        name: z.string(),
-        pages: z.array(z.object({ questions: z.array(question) }))
-    });
-    it('keeps a numeric literal union instead of widening it to number', () => {
-        const refined = refineSchema(survey, { pages: { questions: { scale: true, steps: true } } });
-        // With the bug these resolve to `number`, so the source type can't take them.
-        const scale = {}.scale;
-        const steps = {}.steps;
-        void scale;
-        void steps;
-        const parsed = refined.parse({ pages: [{ questions: [{ scale: 10, steps: 3 }] }] });
-        assert.equal(parsed.pages[0]?.questions[0]?.scale, 10);
-        throws(() => refined.parse({ pages: [{ questions: [{ scale: 7, steps: 3 }] }] }), ZodError);
-    });
-    it('keeps a boolean literal instead of widening it to boolean', () => {
-        const refined = refineSchema(survey, { pages: { questions: { flag: true } } });
-        const isFlag = {}.flag;
-        void isFlag;
-        throws(() => refined.parse({ pages: [{ questions: [{ flag: false }] }] }), ZodError);
-    });
-    it('keeps a required unknown field required', () => {
-        const refined = refineSchema(survey, { pages: { questions: { answer: true, note: true, value: true } } });
-        // With the bug `value` became an optional key; `note` must stay optional.
-        const selected = { answer: { value: 1 }, value: 'x' };
-        const questions = [selected];
-        deepStrictEqual(refined.parse({ pages: [{ questions }] }).pages[0]?.questions, questions);
-    });
-});

package/dist/select.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/select.spec.js

@@ -1,108 +0,0 @@
-import { strict as assert } from 'assert';
-import { describe, it } from 'node:test';
-import { z } from 'zod';
-import { buildSelectObject } from './build-select-object.js';
-import { refineSchema } from './refine-schema.js';
-const internalService = z.object({
-    name: z.string(),
-    type: z.literal('internal')
-}).strict();
-const externalService = z.object({
-    iconUrl: z.string().optional(),
-    name: z.string(),
-    type: z.literal('external')
-}).strict();
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-const serviceType = z.union([internalService, externalService]);
-describe('InferMergedType', () => {
-    it('should resolve to z.infer<T> when used in a generic function with TSelect = undefined', () => {
-        function getServices(options) {
-            void options;
-            return {};
-        }
-        // When called without select, TSelect defaults to undefined
-        // InferMergedType<typeof Service, undefined> should resolve to z.infer<typeof Service>
-        const services = getServices({});
-        const service = Object.values(services)[0];
-        // This is a compile-time test: the assertion below must type-check (all
-        // union members have `name: string`). The impl returns `{}`, so guard the
-        // dereference — the block never runs but TS still checks it.
-        if (service) {
-            const name = service.name;
-            void name;
-        }
-    });
-    it('should resolve to projected type when used in a generic function with a select', () => {
-        function getServices(options) {
-            void options;
-            return {};
-        }
-        // When called with a select, the return type should be the projected type
-        const services = getServices({ select: { name: true } });
-        const service = Object.values(services)[0];
-        // This is a compile-time test: the assertion below must type-check (name
-        // was selected). The impl returns `{}`, so guard the dereference — the
-        // block never runs but TS still checks it.
-        if (service) {
-            const name = service.name;
-            void name;
-        }
-    });
-});
-describe('a field whose value is a union of objects', () => {
-    const channel = z.object({ _id: z.string(), key: z.string(), name: z.string() });
-    const effect = z.discriminatedUnion('kind', [
-        z.object({ channel, kind: z.literal('route') }),
-        z.object({ field: z.string(), kind: z.literal('require') })
-    ]);
-    const policy = z.object({
-        _id: z.string(),
-        effect,
-        effects: z.array(effect).optional(),
-        name: z.union([z.string(), z.object({ en: z.string() })])
-    });
-    it('accepts a nested select into the variants, and refines each variant by it', () => {
-        const select = { effect: { channel: { _id: true, name: true }, field: true, kind: true } };
-        const parsed = refineSchema(policy, select).parse({ effect: { channel: { _id: 'c1', key: 'rpo', name: 'RPO' }, kind: 'route' } });
-        assert.deepEqual(parsed, { effect: { channel: { _id: 'c1', name: 'RPO' }, kind: 'route' } });
-    });
-    it('types the result variant by variant, so checking the kind narrows to what that variant selected', () => {
-        const select = { effect: { channel: { _id: true, name: true }, field: true, kind: true } };
-        const isTyped = true;
-        assert.ok(isTyped);
-        assert.deepEqual(refineSchema(policy, select).parse({ effect: { field: 'rationale', kind: 'require' } }), { effect: { field: 'rationale', kind: 'require' } });
-    });
-    it('does the same for an array of such a union', () => {
-        const select = { effects: { channel: { name: true }, kind: true } };
-        const isTyped = true;
-        const effects = [{ channel: { _id: 'c1', key: 'rpo', name: 'RPO' }, kind: 'route' }, { field: 'rationale', kind: 'require' }];
-        assert.ok(isTyped);
-        assert.deepEqual(refineSchema(policy, select).parse({ effects }), { effects: [{ channel: { name: 'RPO' }, kind: 'route' }, { kind: 'require' }] });
-    });
-    it('accepts the select buildSelectObject builds for it', () => {
-        const select = buildSelectObject(policy);
-        assert.deepEqual(select, {
-            _id: true,
-            effect: { channel: { _id: true, key: true, name: true }, field: true, kind: true },
-            effects: { channel: { _id: true, key: true, name: true }, field: true, kind: true },
-            name: true
-        });
-    });
-    it('accepts a nested select into the object variants of a union with a plain one, as a join read as its record is', () => {
-        const select = { name: { en: true } };
-        const isTyped = true;
-        assert.ok(isTyped);
-        assert.deepEqual(refineSchema(policy, select).parse({ name: { en: 'Software' } }), { name: { en: 'Software' } });
-    });
-    it('accepts the select a screen builds by declaring a joined id as its record', () => {
-        const file = z.object({ _id: z.string(), filename: z.string() });
-        const attachment = z.object({ file: z.union([file, z.string()]), title: z.string().optional() });
-        const stored = z.object({ attachments: z.array(attachment).optional() });
-        const read = z.object({ attachments: z.array(attachment.extend({ file })).optional() });
-        const select = buildSelectObject(read);
-        const isTyped = true;
-        assert.ok(isTyped);
-        assert.deepEqual(select, { attachments: { file: { _id: true, filename: true }, title: true } });
-        assert.deepEqual(refineSchema(stored, select).parse({ attachments: [{ file: { _id: 'f1', filename: 'a.pdf' } }] }), { attachments: [{ file: { _id: 'f1', filename: 'a.pdf' } }] });
-    });
-});

package/dist/utilities.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/utilities.spec.js

@@ -1,94 +0,0 @@
-import assert from 'node:assert';
-import { describe, it } from 'node:test';
-import { z } from 'zod';
-import { getInnerType, isZodObject, isZodOptional, isZodRecord, isZodUnion, isZodUnknown } from './utilities.js';
-describe('.utilities()', () => {
-    describe('.getInnerType()', () => {
-        it('getInnerType identifies inner types', () => {
-            const optionalString = z.string().optional();
-            const nullableString = z.string().nullable();
-            const defaultString = z.string().default('default');
-            const catchString = z.string().catch('fallback');
-            const lazyString = z.lazy(() => z.string());
-            const arrayString = z.array(z.string());
-            assert.strictEqual(getInnerType(optionalString).def.type, optionalString.def.innerType.def.type);
-            assert.strictEqual(getInnerType(nullableString).def.type, nullableString.def.innerType.def.type);
-            assert.strictEqual(getInnerType(defaultString).def.type, defaultString.def.innerType.def.type);
-            assert.strictEqual(getInnerType(catchString).def.type, catchString.def.innerType.def.type);
-            assert.strictEqual(getInnerType(lazyString).def.type, lazyString.def.getter().def.type);
-            assert.strictEqual(getInnerType(arrayString).def.type, arrayString.element.def.type);
-            assert.strictEqual(getInnerType(z.string()).def.type, 'string'); // Not a wrapper type
-        });
-        it('should return base type from array', () => {
-            const schema = z.array(z.number());
-            const inner = getInnerType(schema);
-            assert.strictEqual(inner.def.type, 'number');
-        });
-        it('should unwrap nested optional -> nullable -> default -> string', () => {
-            const schema = z.string().default('x').nullable().optional();
-            const inner = getInnerType(schema);
-            assert.strictEqual(inner.def.type, 'string');
-        });
-        it('should unwrap lazy inside nested wrappers', () => {
-            const lazySchema = z.lazy(() => z.string());
-            const wrapped = lazySchema.optional().nullable().default('abc');
-            const inner = getInnerType(wrapped);
-            assert.strictEqual(inner.def.type, 'string');
-        });
-    });
-    it('isZodObject detects ZodObject', () => {
-        const objectSchema = z.object({ name: z.string() });
-        const stringSchema = z.string();
-        assert.ok(isZodObject(objectSchema));
-        assert.ok(!isZodObject(stringSchema));
-    });
-    it('isZodObject should detect loose objects when isLoose is passed', () => {
-        assert.ok(isZodObject(z.looseObject({}), true));
-        assert.ok(!isZodObject(z.looseObject({}), false));
-        assert.ok(!isZodObject(z.strictObject({}), true));
-        assert.ok(isZodObject(z.strictObject({}), false));
-    });
-    it('isZodOptional detects ZodOptional', () => {
-        const optionalSchema = z.string().optional();
-        const stringSchema = z.string();
-        assert.ok(isZodOptional(optionalSchema));
-        assert.ok(!isZodOptional(stringSchema));
-    });
-    it('isZodRecord detects complex record schemas with optional fields', () => {
-        // Create a sample RecordAttachmentSchema
-        const recordAttachmentSchema = z.object({
-            name: z.string(),
-            size: z.number(),
-            type: z.string()
-        });
-        // Create a record schema with optional field
-        const attachmentsSchema = z.record(z.string(), recordAttachmentSchema).optional();
-        const nonRecordSchema = z.object({ field: z.string() });
-        // Test record detection
-        assert.ok(isZodRecord(z.record(z.string(), recordAttachmentSchema)), 'Should detect record schema');
-        assert.ok(isZodRecord(attachmentsSchema.unwrap()), 'Should detect optional record schema when unwrapped');
-        assert.ok(!isZodRecord(nonRecordSchema), 'Should not detect object schema as record');
-        // Test with actual record data
-        const validRecord = z.record(z.string(), recordAttachmentSchema).parse({
-            'file1': { name: 'test.pdf', size: 1024, type: 'application/pdf' },
-            'file2': { name: 'image.jpg', size: 2048, type: 'image/jpeg' }
-        });
-        assert.ok(validRecord, 'Should successfully parse valid record data');
-    });
-    it('isZodRecord detects ZodRecord', () => {
-        const recordSchema = z.record(z.string(), z.string());
-        const stringSchema = z.string();
-        assert.ok(isZodRecord(recordSchema));
-        assert.ok(!isZodRecord(stringSchema));
-    });
-    it('isZodUnion detects ZodUnion', () => {
-        const unionSchema = z.union([z.string(), z.number()]);
-        const stringSchema = z.string();
-        assert.ok(isZodUnion(unionSchema));
-        assert.ok(!isZodUnion(stringSchema));
-    });
-    it('isZodUnknown detects ZodUnknown', () => {
-        assert.ok(isZodUnknown(z.unknown()));
-        assert.ok(!isZodUnknown(z.string()));
-    });
-});