@scalar/validation 0.1.0 → 0.3.0

package/dist/typegen.js

@@ -0,0 +1,221 @@
+const DEFAULT_MAX_DEPTH = 10;
+/**
+ * Returns TypeScript for the schema: named `typeName` nodes become `export type` aliases (once each),
+ * referenced by name elsewhere. With no named nodes, returns a single inline type expression (same as before).
+ *
+ * When at least one named type is emitted, the result is prefixed with a banner stating the output is
+ * autogenerated and must not be edited manually, plus a generation timestamp.
+ *
+ * Pass `namespace` to wrap declarations in `export namespace … { … }`.
+ */
+export const generateTypes = (schema, options) => {
+    const maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
+    const ctx = {
+        definitions: new Map(),
+        declarations: [],
+        inProgress: new Set(),
+    };
+    const root = emitSchema(schema, maxDepth, ctx, '');
+    if (ctx.declarations.length === 0) {
+        return root;
+    }
+    const declStrings = ctx.declarations.map(formatNamedDeclaration);
+    const body = declStrings.join('\n\n');
+    const lastDeclared = ctx.declarations.at(-1)?.name;
+    let content = lastDeclared === root ? body : `${body}\n\n${root}`;
+    const ns = options?.namespace;
+    if (ns && isValidTypeScriptIdentifier(ns)) {
+        content = wrapDeclarationsInNamespace(ns, content);
+    }
+    const generatedAt = options?.generatedAt ?? new Date().toISOString();
+    return `${formatAutogeneratedFileBanner(generatedAt)}${content}`;
+};
+const formatAutogeneratedFileBanner = (generatedAt) => `/**\n * This file is autogenerated. Do not edit it.\n *\n * Generated at: ${generatedAt}\n */\n\n`;
+const wrapDeclarationsInNamespace = (namespace, content) => {
+    const body = content
+        .split('\n')
+        .map((line) => (line === '' ? '' : `  ${line}`))
+        .join('\n');
+    return `export namespace ${namespace} {\n${body}\n}\n`;
+};
+const formatNamedDeclaration = (d) => {
+    const commentBlock = d.comment ? formatTypeCommentAsJsDoc(d.comment) : '';
+    const comment = commentBlock ? `${commentBlock}\n` : '';
+    return `${comment}export type ${d.name} = ${d.body}`;
+};
+/** Inline JSDoc for one line; multi-line comments use a newline after the opening delimiter and ` * ` on each line. */
+const formatTypeCommentAsJsDoc = (comment) => {
+    const lines = comment.split(/\r?\n/);
+    const trimmed = lines.map((line) => line.trim());
+    while (trimmed.length > 0 && trimmed[0] === '') {
+        trimmed.shift();
+    }
+    while (trimmed.length > 0 && trimmed.at(-1) === '') {
+        trimmed.pop();
+    }
+    if (trimmed.length === 0) {
+        return '';
+    }
+    if (trimmed.length === 1) {
+        return `/** ${trimmed[0]} */`;
+    }
+    const body = trimmed.map((line) => ` * ${line}`).join('\n');
+    return `/** \n${body}\n */`;
+};
+/** Prefixes each line of a JSDoc block with `indent` for object property comments. */
+const formatTypeCommentAsIndentedJsDoc = (indent, comment) => {
+    const doc = formatTypeCommentAsJsDoc(comment);
+    if (!doc) {
+        return '';
+    }
+    return doc
+        .split('\n')
+        .map((line) => `${indent}${line}`)
+        .join('\n');
+};
+const getTypeName = (schema) => {
+    if (schema.type === 'lazy' || schema.type === 'evaluate') {
+        return undefined;
+    }
+    const name = schema.typeName;
+    if (!name || !isValidTypeScriptIdentifier(name)) {
+        return undefined;
+    }
+    return name;
+};
+const getTypeComment = (schema) => {
+    if (schema.type === 'lazy' || schema.type === 'evaluate') {
+        return undefined;
+    }
+    if (schema.type === 'optional') {
+        return schema.typeComment ?? getTypeComment(schema.schema);
+    }
+    return schema.typeComment;
+};
+const isValidTypeScriptIdentifier = (name) => /^[$_A-Za-z][$_\w]*$/.test(name);
+const emitSchema = (schema, depth, ctx, braceIndent) => {
+    const name = getTypeName(schema);
+    if (name) {
+        if (ctx.definitions.has(name)) {
+            return name;
+        }
+        if (ctx.inProgress.has(name)) {
+            return name;
+        }
+        ctx.inProgress.add(name);
+        const body = structuralEmit(schema, depth, ctx, '');
+        ctx.inProgress.delete(name);
+        if (!ctx.definitions.has(name)) {
+            ctx.definitions.set(name, body);
+            ctx.declarations.push({
+                name,
+                body,
+                comment: getTypeComment(schema),
+            });
+        }
+        return name;
+    }
+    return structuralEmit(schema, depth, ctx, braceIndent);
+};
+const structuralEmit = (schema, depth, ctx, braceIndent) => {
+    if (depth <= 0) {
+        return 'any';
+    }
+    const next = depth - 1;
+    switch (schema.type) {
+        case 'number':
+            return 'number';
+        case 'string':
+            return 'string';
+        case 'boolean':
+            return 'boolean';
+        case 'nullable':
+            return 'null';
+        case 'notDefined':
+            return 'undefined';
+        case 'any':
+            return 'any';
+        case 'array': {
+            const item = emitSchema(schema.items, next, ctx, braceIndent);
+            return needsArrayItemParen(item) ? `(${item})[]` : `${item}[]`;
+        }
+        case 'record': {
+            const key = emitSchema(schema.key, next, ctx, braceIndent);
+            const value = emitSchema(schema.value, next, ctx, braceIndent);
+            return `Record<${key}, ${value}>`;
+        }
+        case 'object': {
+            const entries = Object.entries(schema.properties);
+            if (entries.length === 0) {
+                return '{}';
+            }
+            const keyIndent = `${braceIndent}  `;
+            const props = entries.map(([key, child]) => {
+                const tsKey = /^[$_a-zA-Z][$_\w]*$/.test(key) ? key : JSON.stringify(key);
+                const optionalProp = child.type === 'optional';
+                const valueSchema = optionalProp ? child.schema : child;
+                const value = emitSchema(valueSchema, next, ctx, keyIndent);
+                const propComment = getTypeComment(child);
+                const docBlock = propComment ? formatTypeCommentAsIndentedJsDoc(keyIndent, propComment) : '';
+                const propLine = optionalProp ? `${keyIndent}${tsKey}?: ${value};` : `${keyIndent}${tsKey}: ${value};`;
+                return docBlock ? `${docBlock}\n${propLine}` : propLine;
+            });
+            return `{\n${props.join('\n')}\n${braceIndent}}`;
+        }
+        case 'optional': {
+            const inner = emitSchema(schema.schema, next, ctx, braceIndent);
+            return `${wrapUnionMember(inner)} | undefined`;
+        }
+        case 'union':
+            if (schema.schemas.length === 0) {
+                return 'never';
+            }
+            return schema.schemas.map((s) => wrapUnionMember(emitSchema(s, next, ctx, braceIndent))).join(' | ');
+        case 'intersection':
+            if (schema.schemas.length === 0) {
+                return 'unknown';
+            }
+            return schema.schemas.map((s) => wrapIntersectionMember(emitSchema(s, next, ctx, braceIndent))).join(' & ');
+        case 'literal':
+            return literalToTs(schema.value);
+        case 'lazy':
+            return emitSchema(schema.schema(), next, ctx, braceIndent);
+        case 'evaluate':
+            return emitSchema(schema.schema, next, ctx, braceIndent);
+        default: {
+            const _exhaustive = schema;
+            return _exhaustive;
+        }
+    }
+};
+const literalToTs = (value) => {
+    if (typeof value === 'bigint') {
+        return `${value}n`;
+    }
+    return JSON.stringify(value);
+};
+const needsArrayItemParen = (t) => {
+    if (t === 'number' || t === 'string' || t === 'boolean' || t === 'null' || t === 'undefined' || t === 'any') {
+        return false;
+    }
+    // Union: `A | B[]` is `A | (B[])`; intersection: `A & B[]` is `A & (B[])`. Wrap the whole item type.
+    return t.includes(' | ') || t.includes(' & ');
+};
+const wrapUnionMember = (t) => {
+    if (t === 'number' || t === 'string' || t === 'boolean' || t === 'null' || t === 'undefined' || t === 'any') {
+        return t;
+    }
+    if (/^(?:-?(?:\d+(?:\.\d+)?|\.\d+)(?:[eE][+-]?\d+)?|-?\d+n|"(?:[^"\\]|\\.)*"|true|false)$/.test(t)) {
+        return t;
+    }
+    if (/^[$_A-Za-z][$_\w]*$/.test(t)) {
+        return t;
+    }
+    return `(${t})`;
+};
+const wrapIntersectionMember = (t) => {
+    if (t.includes(' | ') || t.includes(' & ')) {
+        return `(${t})`;
+    }
+    return t;
+};

package/dist/types.d.ts

@@ -1,8 +1,28 @@
-import type { AnySchema, ArraySchema, BooleanSchema, EvaluateSchema, LazySchema, LiteralSchema, NotDefinedSchema, NullableSchema, NumberSchema, ObjectSchema, RecordSchema, StringSchema, UnionSchema } from './schema.js';
+import type { AnySchema, ArraySchema, BooleanSchema, EvaluateSchema, IntersectionSchema, LazySchema, LiteralSchema, NotDefinedSchema, NullableSchema, NumberSchema, ObjectSchema, OptionalSchema, RecordSchema, Schema, StringSchema, UnionSchema } from './schema.js';
 export type Static<T> = _Static<T, 10>;
-type _Static<T, Depth extends number = 10> = Depth extends 0 ? any : T extends LiteralSchema<infer Value> ? Value : T extends NumberSchema ? number : T extends StringSchema ? string : T extends BooleanSchema ? boolean : T extends NullableSchema ? null : T extends NotDefinedSchema ? undefined : T extends AnySchema ? any : T extends ArraySchema<infer Item> ? Array<_Static<Item, Prev<Depth>>> : T extends RecordSchema<infer Key, infer Value> ? Record<_Static<Key, Prev<Depth>> & PropertyKey, _Static<Value, Prev<Depth>>> : T extends ObjectSchema<infer Properties> ? {
+/**
+ * Folds intersection member schemas into an intersection of their static types.
+ * Uses `Schema` for tuple positions (not a narrower alias) so `infer First extends …` does not
+ * reject valid tuple elements and collapse to `{}`.
+ */
+type IntersectObjectStatics<Schemas extends readonly Schema[], Depth extends number> = Schemas extends readonly [] ? {} : Schemas extends readonly [infer First extends Schema, ...infer Rest extends readonly Schema[]] ? _Static<First, Depth> & IntersectObjectStatics<Rest, Depth> : {};
+type OptionalPropertyKeys<P> = {
+    [K in keyof P]: P[K] extends OptionalSchema<any> ? K : never;
+}[keyof P];
+type RequiredPropertyKeys<P> = {
+    [K in keyof P]: P[K] extends OptionalSchema<any> ? never : K;
+}[keyof P];
+type OptionalSchemaInner<S> = S extends OptionalSchema<infer Inner> ? Inner : never;
+type ObjectStatics<Properties, Depth extends number> = [keyof Properties] extends [never] ? {} : OptionalPropertyKeys<Properties> extends never ? {
     [K in keyof Properties]: _Static<Properties[K], Prev<Depth>>;
-} : T extends UnionSchema<infer Schemas> ? _Static<Schemas[number], Prev<Depth>> : T extends EvaluateSchema<infer S> ? _Static<S, Prev<Depth>> : T extends LazySchema<infer S> ? _Static<ReturnType<S>, Prev<Depth>> : never;
+} : RequiredPropertyKeys<Properties> extends never ? {
+    [K in OptionalPropertyKeys<Properties>]?: _Static<OptionalSchemaInner<Properties[K]>, Prev<Depth>>;
+} : {
+    [K in RequiredPropertyKeys<Properties>]: _Static<Properties[K], Prev<Depth>>;
+} & {
+    [K in OptionalPropertyKeys<Properties>]?: _Static<OptionalSchemaInner<Properties[K]>, Prev<Depth>>;
+};
+type _Static<T, Depth extends number = 10> = Depth extends 0 ? any : T extends LiteralSchema<infer Value> ? Value : T extends NumberSchema ? number : T extends StringSchema ? string : T extends BooleanSchema ? boolean : T extends NullableSchema ? null : T extends NotDefinedSchema ? undefined : T extends AnySchema ? any : T extends ArraySchema<infer Item> ? Array<_Static<Item, Prev<Depth>>> : T extends RecordSchema<infer Key, infer Value> ? Record<_Static<Key, Prev<Depth>> & PropertyKey, _Static<Value, Prev<Depth>>> : T extends ObjectSchema<infer Properties> ? ObjectStatics<Properties, Depth> : T extends OptionalSchema<infer S> ? _Static<S, Prev<Depth>> | undefined : T extends IntersectionSchema<infer Schemas> ? IntersectObjectStatics<Schemas, Prev<Depth>> : T extends UnionSchema<infer Schemas> ? _Static<Schemas[number], Prev<Depth>> : T extends EvaluateSchema<infer S> ? _Static<S, Prev<Depth>> : T extends LazySchema<infer S> ? _Static<ReturnType<S>, Prev<Depth>> : never;
 type Prev<T extends number> = T extends 10 ? 9 : T extends 9 ? 8 : T extends 8 ? 7 : T extends 7 ? 6 : T extends 6 ? 5 : T extends 5 ? 4 : T extends 4 ? 3 : T extends 3 ? 2 : T extends 2 ? 1 : T extends 1 ? 0 : 0;
 export {};
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,WAAW,EACX,aAAa,EACb,cAAc,EACd,UAAU,EACV,aAAa,EACb,gBAAgB,EAChB,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,WAAW,EACZ,MAAM,UAAU,CAAA;AAGjB,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;AAGtC,KAAK,OAAO,CAAC,CAAC,EAAE,KAAK,SAAS,MAAM,GAAG,EAAE,IAAI,KAAK,SAAS,CAAC,GACxD,GAAG,GACH,CAAC,SAAS,aAAa,CAAC,MAAM,KAAK,CAAC,GAClC,KAAK,GACL,CAAC,SAAS,YAAY,GACpB,MAAM,GACN,CAAC,SAAS,YAAY,GACpB,MAAM,GACN,CAAC,SAAS,aAAa,GACrB,OAAO,GACP,CAAC,SAAS,cAAc,GACtB,IAAI,GACJ,CAAC,SAAS,gBAAgB,GACxB,SAAS,GACT,CAAC,SAAS,SAAS,GACjB,GAAG,GACH,CAAC,SAAS,WAAW,CAAC,MAAM,IAAI,CAAC,GAC/B,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GACjC,CAAC,SAAS,YAAY,CAAC,MAAM,GAAG,EAAE,MAAM,KAAK,CAAC,GAC5C,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,WAAW,EAAE,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAC5E,CAAC,SAAS,YAAY,CAAC,MAAM,UAAU,CAAC,GACtC;KAAG,CAAC,IAAI,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;CAAE,GAChE,CAAC,SAAS,WAAW,CAAC,MAAM,OAAO,CAAC,GAClC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,GACrC,CAAC,SAAS,cAAc,CAAC,MAAM,CAAC,CAAC,GAC/B,OAAO,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,GACvB,CAAC,SAAS,UAAU,CAAC,MAAM,CAAC,CAAC,GAC3B,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,GACnC,KAAK,CAAA;AAGnC,KAAK,IAAI,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,EAAE,GACtC,CAAC,GACD,CAAC,SAAS,CAAC,GACT,CAAC,GACD,CAAC,SAAS,CAAC,GACT,CAAC,GACD,CAAC,SAAS,CAAC,GACT,CAAC,GACD,CAAC,SAAS,CAAC,GACT,CAAC,GACD,CAAC,SAAS,CAAC,GACT,CAAC,GACD,CAAC,SAAS,CAAC,GACT,CAAC,GACD,CAAC,SAAS,CAAC,GACT,CAAC,GACD,CAAC,SAAS,CAAC,GACT,CAAC,GACD,CAAC,SAAS,CAAC,GACT,CAAC,GACD,CAAC,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/validate.d.ts

@@ -12,10 +12,12 @@ import type { Schema } from './schema.js';
  * - 'notDefined':  Only `undefined` is valid.
  * - 'array':       Array with all items validated recursively.
  * - 'record':      Object with string/number keys and values, checked recursively.
- * - 'object':      Object with fixed property keys, each validated recursively.
+ * - 'object':      Plain object with fixed property keys, each validated recursively.
  * - 'union':       Accepts if value matches any of the listed schemas.
+ * - 'optional':    Accepts `undefined` or a value matching the inner schema.
+ * - 'intersection': Accepts if value matches every member schema (members are object schemas; value must be a plain object).
  * - 'literal':     Exact match with a literal value.
- * - 'recursive':   Schema referring to itself for nested validation (e.g. trees).
+ * - 'lazy':        Delegates to the schema returned by the factory.
  * - 'evaluate':    Transforms value then validates against an inner schema.
  *
  * @example

package/dist/validate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../src/validate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,QAAQ,GAAI,QAAQ,MAAM,GAAG,SAAS,EAAE,OAAO,OAAO,KAAG,OAwDrE,CAAA"}
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../src/validate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,QAAQ,GAAI,QAAQ,MAAM,GAAG,SAAS,EAAE,OAAO,OAAO,KAAG,OAqErE,CAAA"}

package/dist/validate.js

@@ -12,10 +12,12 @@ import { isObject } from './helpers/is-object.js';
  * - 'notDefined':  Only `undefined` is valid.
  * - 'array':       Array with all items validated recursively.
  * - 'record':      Object with string/number keys and values, checked recursively.
- * - 'object':      Object with fixed property keys, each validated recursively.
+ * - 'object':      Plain object with fixed property keys, each validated recursively.
  * - 'union':       Accepts if value matches any of the listed schemas.
+ * - 'optional':    Accepts `undefined` or a value matching the inner schema.
+ * - 'intersection': Accepts if value matches every member schema (members are object schemas; value must be a plain object).
  * - 'literal':     Exact match with a literal value.
- * - 'recursive':   Schema referring to itself for nested validation (e.g. trees).
+ * - 'lazy':        Delegates to the schema returned by the factory.
  * - 'evaluate':    Transforms value then validates against an inner schema.
  *
  * @example
@@ -69,9 +71,22 @@ export const validate = (schema, value) => {
         const schemaKeys = Object.keys(schema.properties);
         return schemaKeys.every((key) => validate(schema.properties[key], value[key]));
     }
+    if (schema.type === 'optional') {
+        return value === undefined || validate(schema.schema, value);
+    }
     if (schema.type === 'union') {
         return schema.schemas.some((schema) => validate(schema, value));
     }
+    if (schema.type === 'intersection') {
+        if (schema.schemas.length === 0) {
+            // Vacuous: no constraints (matches `Array.prototype.every` on an empty list).
+            return true;
+        }
+        if (!isObject(value)) {
+            return false;
+        }
+        return schema.schemas.every((subSchema) => validate(subSchema, value));
+    }
     if (schema.type === 'literal') {
         return value === schema.value;
     }

package/package.json

@@ -15,7 +15,7 @@
     "coerce",
     "scalar"
   ],
-  "version": "0.1.0",
+  "version": "0.3.0",
   "engines": {
     "node": ">=20"
   },

package/src/coerce.test.ts

@@ -6,6 +6,7 @@ import {
   array,
   boolean,
   evaluate,
+  intersection,
   lazy,
   literal,
   notDefined,
@@ -417,6 +418,15 @@ describe('object', () => {
       y: 2,
     })
   })
+  it('omits optional properties when the value is undefined', () => {
+    const T = object({
+      id: number(),
+      name: optional(string()),
+    })
+    expect(coerce(T, { id: 1 })).toEqual({ id: 1 })
+    expect(coerce(T, { id: 1, name: undefined })).toEqual({ id: 1 })
+    expect(coerce(T, { id: 1, name: 'x' })).toEqual({ id: 1, name: 'x' })
+  })
 })
 
 describe('record', () => {
@@ -918,6 +928,83 @@ describe('union', () => {
       $ref: 'https://example.com/schema',
     })
   })
+
+  it('picks the branch whose type discriminator matches a union of literals', () => {
+    const T = union([
+      object({
+        type: literal('a'),
+        a: string(),
+      }),
+      object({
+        type: union([literal('b'), literal('c')]),
+        b: string(),
+      }),
+    ])
+    expect(coerce(T, { type: 'a' })).toEqual({ type: 'a', a: '' })
+    expect(coerce(T, { type: 'b' })).toEqual({ type: 'b', b: '' })
+    expect(coerce(T, { type: 'c' })).toEqual({ type: 'c', b: '' })
+  })
+})
+
+describe('intersection', () => {
+  const T = intersection([
+    object({
+      a: number(),
+      b: number(),
+    }),
+    object({
+      c: string(),
+      d: string(),
+    }),
+  ])
+  it('merges coerced properties from each object schema', () => {
+    const result = coerce(T, { a: 1, b: 2, c: 'x', d: 'y' })
+    expect(result).toEqual({ a: 1, b: 2, c: 'x', d: 'y' })
+  })
+  it('fills missing keys per branch from the same input value', () => {
+    const result = coerce(T, { a: 'nope', c: 123 })
+    expect(result).toEqual({ a: 0, b: 0, c: '', d: '' })
+  })
+  it('later branch wins on overlapping keys', () => {
+    const overlap = intersection([object({ x: number() }), object({ x: string() })])
+    const result = coerce(overlap, { x: 1 })
+    expect(result).toEqual({ x: '' })
+  })
+  it('wins in a union when every member validates and summed score beats narrower members', () => {
+    const A = object({ type: literal('A'), onlyA: number() })
+    const B = object({ type: literal('B'), onlyB: string() })
+    const both = intersection([
+      object({ type: literal('A'), shared: number() }),
+      object({ shared: number(), extra: string() }),
+    ])
+    const T = union([A, B, both])
+    // Intersection merges only its declared keys; it outscores A here because both sub-objects validate.
+    expect(coerce(T, { type: 'A', onlyA: 1, shared: 2, extra: 'ok' })).toEqual({
+      type: 'A',
+      shared: 2,
+      extra: 'ok',
+    })
+  })
+  it('correctly picks the branch on an intersection with nested unions #1', () => {
+    const T = intersection([
+      union([object({ type: literal('a'), a: string() }), object({ type: literal('b'), b: string() })]),
+      object({ c: string() }),
+    ])
+    expect(coerce(T, { type: 'a', a: 'x', c: 'y' })).toEqual({ type: 'a', a: 'x', c: 'y' })
+    expect(coerce(T, { type: 'b', b: 'x', c: 'y' })).toEqual({ type: 'b', b: 'x', c: 'y' })
+    expect(coerce(T, { c: 'y' })).toEqual({ type: 'a', a: '', c: 'y' })
+  })
+  it('correctly picks the branch on an intersection with nested unions #2', () => {
+    const T = intersection([
+      union([
+        object({ type: literal('a'), a: optional(string()) }),
+        object({ type: literal('b'), b: optional(string()) }),
+      ]),
+      object({ c: optional(string()), d: optional(string()) }),
+    ])
+    expect(coerce(T, { a: 'a' })).toEqual({ type: 'a', a: 'a' })
+    expect(coerce(T, { a: 'a', c: 'c' })).toEqual({ type: 'a', a: 'a', c: 'c' })
+  })
 })
 
 describe('notDefined', () => {

package/src/coerce.ts

@@ -3,6 +3,24 @@ import type { Schema } from './schema'
 import type { Static } from './types'
 import { validate } from './validate'
 
+/**
+ * True when this property schema is only used to discriminate union branches
+ * (single literal, or a union of literals). No presence bonus when the value
+ * does not match — avoids ties like `type: literal('a')` vs `type: union([lit('b'), lit('c')])`.
+ */
+const isDiscriminatorProperty = (schema: Schema): boolean => {
+  if (schema.type === 'optional') {
+    return isDiscriminatorProperty(schema.schema)
+  }
+  if (schema.type === 'literal') {
+    return true
+  }
+  if (schema.type === 'union') {
+    return schema.schemas.length > 0 && schema.schemas.every(isDiscriminatorProperty)
+  }
+  return false
+}
+
 /**
  * Computes a "score" indicating how well a value matches a schema,
  * used for picking the best branch in union coercion.
@@ -17,16 +35,23 @@ const scoreUnion = (schema: Schema, value: unknown): number => {
       return 0
     }
 
-    // For each key in the schema's properties:
-    // - +10 if the value matches an explicit literal for the key.
-    // - +1 if the property exists (not literal match).
+    // Missing keys contribute 0 (including optional keys — matches prior union heuristics).
+    // Discriminator properties (`literal` or `union` of literals): recurse with scoreUnion;
+    // matching values get a high weight (×10) so `type: literal('A')` beats unrelated fields
+    // on another branch; mismatches score 0 (no "key present" tie-break).
+    // Other properties: scoreUnion plus +1 when the value fails validation so `{ a: null }`
+    // can still prefer the branch that declares `a`.
     return Object.keys(schema.properties).reduce<number>((acc, key) => {
-      const exists = key in value
-      const isLiteralMatch = schema.properties[key].type === 'literal' && value[key] === schema.properties[key].value
-      if (isLiteralMatch) {
-        return acc + 10
+      if (!(key in value)) {
+        return acc
       }
-      return acc + (exists ? 1 : 0)
+      const propSchema = schema.properties[key]
+      const raw = value[key as keyof typeof value]
+      const base = scoreUnion(propSchema, raw)
+      if (isDiscriminatorProperty(propSchema)) {
+        return acc + (base > 0 ? base * 10 : 0)
+      }
+      return acc + (base > 0 ? base : 1)
     }, 0)
   }
   if (schema.type === 'array') {
@@ -37,10 +62,19 @@ const scoreUnion = (schema: Schema, value: unknown): number => {
     // TODO: implement smarter scoring for records (just a placeholder for now)
     return isObject(value) ? 1 : 0
   }
+  if (schema.type === 'optional') {
+    return value === undefined ? 1 : scoreUnion(schema.schema, value)
+  }
   if (schema.type === 'union') {
     // For a union, use the highest score among all sub-schemas
     return Math.max(...schema.schemas.map((schema) => scoreUnion(schema, value)))
   }
+  if (schema.type === 'intersection') {
+    if (schema.schemas.length === 0) {
+      return 1
+    }
+    return schema.schemas.reduce((acc, sub) => acc + scoreUnion(sub, value), 0)
+  }
 
   if (schema.type === 'lazy') {
     // For a lazy schema, evaluate the inner schema and recurse
@@ -122,6 +156,12 @@ export const coerce = <S extends Schema>(
   if (schema.type === 'notDefined') {
     return undefined as unknown as Static<S>
   }
+  if (schema.type === 'optional') {
+    if (value === undefined) {
+      return undefined as unknown as Static<S>
+    }
+    return coerce(schema.schema, value, cache)
+  }
   if (schema.type === 'array') {
     if (!Array.isArray(value)) {
       return [] as unknown as Static<S>
@@ -139,9 +179,16 @@ export const coerce = <S extends Schema>(
   if (schema.type === 'object') {
     const keys = Object.keys(schema.properties)
     const target = isObject(value) ? value : null
-    return Object.fromEntries(
-      keys.map((key) => [key, coerce(schema.properties[key], target?.[key], cache)]),
-    ) as unknown as Static<S>
+    const entries: [string, unknown][] = []
+    for (const key of keys) {
+      const propSchema = schema.properties[key]
+      const raw = target?.[key as keyof typeof target]
+      if (propSchema.type === 'optional' && raw === undefined) {
+        continue
+      }
+      entries.push([key, coerce(propSchema, raw, cache)])
+    }
+    return Object.fromEntries(entries) as unknown as Static<S>
   }
   if (schema.type === 'union') {
     const branch = schema.schemas.reduce(
@@ -154,6 +201,12 @@ export const coerce = <S extends Schema>(
     // We need some way to pick one of the union values
     return coerce(branch.schema, value, cache)
   }
+  if (schema.type === 'intersection') {
+    return schema.schemas.reduce<Record<string, unknown>>(
+      (acc, subSchema) => Object.assign(acc, coerce(subSchema, value, cache) as Record<string, unknown>),
+      {},
+    ) as unknown as Static<S>
+  }
   if (schema.type === 'literal') {
     return schema.value
   }

package/src/index.ts

@@ -1,10 +1,26 @@
 export { coerce } from './coerce'
 export {
+  type AnySchema,
+  type ArraySchema,
+  type BooleanSchema,
+  type EvaluateSchema,
+  type IntersectionSchema,
+  type LazySchema,
+  type LiteralSchema,
+  type NotDefinedSchema,
+  type NullableSchema,
+  type NumberSchema,
+  type ObjectSchema,
+  type OptionalSchema,
+  type RecordSchema,
   type Schema,
+  type StringSchema,
+  type UnionSchema,
   any,
   array,
   boolean,
   evaluate,
+  intersection,
   lazy,
   literal,
   notDefined,
@@ -16,5 +32,6 @@ export {
   string,
   union,
 } from './schema'
+export { type GenerateTypesOptions, generateTypes } from './typegen'
 export type { Static } from './types'
 export { validate } from './validate'