ata-validator 1.0.2 → 1.1.0

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to ata-validator are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/), and this project adheres to semantic versioning.
 
+## 1.1.0 - 2026-07-18
+
+### Added
+
+- TypeBox-style modifier combinators on `ata-validator/t`: `t.pick`, `t.omit`, `t.partial`, `t.required`, `t.composite`, and `t.recursive`. All six emit plain JSON Schema, so `Infer`, the runtime validator, and the AOT pipeline consume them with no adapter. This closes the authoring-parity gap for TypeBox migrations. Note: `t.recursive` schemas validate through the interpreted engine and are not AOT-precompilable; the other five combinators AOT-compile like any schema.
+
+### Changed
+
+- The `ata-validator` package is now pure JavaScript: no bundled binaries, no vendored C++ sources, no install script. The native engine moved to per-platform `@ata-validator/native-*` packages, installed automatically as optional dependencies (the same pattern Vite uses for esbuild). The tarball shrinks from ~5.3 MB to under 300 KB. `npm install --omit=optional` or `ATA_NO_NATIVE=1` gives a guaranteed zero-binary setup; validation behavior is identical for every schema shape the JS engine compiles, and the few shapes that still need the native engine now throw a clear error instead (see Fixed below).
+
+### Fixed
+
+- Schemas the JS engine cannot compile (some `$dynamicRef`, cyclic `$ref`, and unusual keyword interactions) crashed with `Maximum call stack size exceeded` in environments without the native addon: the lazy `validate` stub and the rich-error wrapper dispatched to each other forever. These schemas now throw a clear "not supported by the pure-JS engine" error on first use. The same cycle could hit `isValidObject` even with the native addon present when it was the first method called; it now falls through to the full compile and validates correctly.
+
 ## 1.0.2 - 2026-07-17
 
 ### Fixed

package/README.md

@@ -14,6 +14,14 @@ npm install --save-dev ata-validator
 npx ata build 'schemas/*.json' --out-dir src/generated
 ```
 
+The `ata-validator` package itself is pure JavaScript. The native accelerator (simdjson parsing, parallel NDJSON, buffer APIs) ships as per-platform optional packages that npm installs automatically where they fit, the same pattern Vite uses for esbuild. For a guaranteed zero-binary install:
+
+```bash
+npm install ata-validator --omit=optional
+```
+
+or set `ATA_NO_NATIVE=1` at runtime. Validation behavior is identical for the schema shapes the JS engine compiles, which covers typical API payload schemas. The buffer and parallel APIs, plus a small set of complex shapes (some `$dynamicRef`, cyclic `$ref`, and unusual keyword interactions), currently need the native engine and throw a clear error without it rather than validating incorrectly.
+
 In your code:
 
 ```ts
@@ -227,7 +235,14 @@ type User = Infer<typeof User>
 const v = new Validator(User)
 ```
 
-The builder covers primitives (`string`, `number`, `integer`, `boolean`, `null`), composites (`object` with `optional` keys, `array`, `tuple`, `record`, `union`, `intersect`, `literal`, `const`, `enum`), and refs (`ref`). Optionality is carried by a Symbol marker that the emitted JSON Schema and ata's codegen never see, so the output is still a plain JSON Schema literal that you can pass to anything that takes one.
+The builder covers primitives (`string`, `number`, `integer`, `boolean`, `null`), composites (`object` with optional keys, `array`, `tuple`, `record`, `union`, `intersect`, `literal`, `const`, `enum`), plus the TypeBox-style modifiers `pick`, `omit`, `partial`, `required`, `composite`, and `recursive`. Optionality is carried by a Symbol marker that the emitted JSON Schema and ata's codegen never see, so the output is still a plain JSON Schema literal that you can pass to anything that takes one.
+
+```ts
+const User = t.object({ id: t.integer(), name: t.string(), email: t.optional(t.string()) })
+const Patch = t.partial(t.omit(User, ['id']))
+type Patch = Infer<typeof Patch>
+// { name?: string; email?: string }
+```
 
 #### Async refinement
 
@@ -462,6 +477,8 @@ If one of these blocks you, open an issue; scope decisions get revisited with re
 
 ## Building from Source
 
+This section applies to contributors building the repository. Regular `npm install` users need not have a C++ toolchain.
+
 ### Development prerequisites
 
 Native builds require C/C++ toolchain support and the following libraries:
@@ -470,7 +487,7 @@ Native builds require C/C++ toolchain support and the following libraries:
 - `abseil`
 - `mimalloc`
 
-Install them before running `npm install` / `npm run build`:
+Install them before running `npm run build`:
 
 ```bash
 # macOS (Homebrew)

package/index.js

@@ -1,7 +1,7 @@
 // Native addon: optional. Core validate() uses JS codegen and works without it.
 // Buffer APIs (isValid, countValid, isValidParallel) require native.
-// Loading is delegated so this file stays free of `pkg-prebuilds`/`__dirname`/
-// `path` (the browser entry must not pull those in via the bundler).
+// Loading is delegated to lib/native-load.js so this file stays free of
+// platform probing and `path` (the browser entry must not pull those in).
 const native = require("./lib/native-load")();
 const {
   compileToJS,
@@ -569,6 +569,10 @@ class Validator {
         };
       } else {
         this._ensureCodegen();
+        // Codegen can bail on shapes it cannot represent; the full compile
+        // binds the native path or the unsupported thrower instead of
+        // leaving this stub to re-dispatch to itself.
+        if (!this._jsFn) this._ensureCompiled();
       }
       return this.isValidObject(data);
     };
@@ -1004,6 +1008,18 @@ class Validator {
           return valid;
         };
       }
+    } else {
+      // No JS codegen and no native engine. Leaving the lazy stubs in place
+      // makes them re-dispatch to themselves forever, so bind a clear error.
+      const unsupported = () => {
+        throw new Error(
+          'This schema is not supported by the pure-JS engine and the native addon is unavailable in this environment'
+        );
+      };
+      this.validate = unsupported;
+      this.isValidObject = unsupported;
+      this.validateJSON = unsupported;
+      this.isValidJSON = unsupported;
     }
 
     // richErrors enrichment: layered on top of whichever validate path was

package/lib/aot.js

@@ -1,7 +1,7 @@
 'use strict';
 
 // All ahead-of-time (AOT) code generation lives here so the default and browser
-// entries can stay free of `fs`, `path`, `__dirname`, and `pkg-prebuilds`.
+// entries can stay free of `fs`, `path`, and `__dirname`.
 // Browser bundles get `lib/aot.browser.js` instead (see package.json `browser`
 // field), which throws if anyone tries to call an AOT function from the browser.
 //

package/lib/js-compiler.js

@@ -702,6 +702,27 @@ function canResolveDynamicRefs(target, callingSchema, schemaMap) {
   return refs.every(r => anchors.has(r))
 }
 
+// Returns true if the node's subtree contains a local $ref pointing to one of
+// the given def names (i.e., '#/$defs/Name' or '#/definitions/Name' where Name
+// is in defNames). Used to detect whether a $defs body cycles back to a sibling.
+function subtreeRefersToLocalDef(node, defNames) {
+  if (typeof node !== 'object' || node === null) return false
+  if (node.$ref) {
+    const m = /^#\/(?:\$defs|definitions)\/([^/]+)$/.exec(node.$ref)
+    if (m && defNames.has(m[1])) return true
+  }
+  for (const val of Object.values(node)) {
+    if (typeof val === 'object' && val !== null) {
+      if (Array.isArray(val)) {
+        for (const item of val) { if (subtreeRefersToLocalDef(item, defNames)) return true }
+      } else {
+        if (subtreeRefersToLocalDef(val, defNames)) return true
+      }
+    }
+  }
+  return false
+}
+
 // Recursively check if a schema can be safely compiled to JS codegen.
 // Returns false if any sub-schema contains features codegen gets wrong.
 function codegenSafe(schema, schemaMap) {
@@ -809,6 +830,17 @@ function codegenSafe(schema, schemaMap) {
   // Check $defs: targets must be safe, names must be simple, no nested $ref chains
   const defs = schema.$defs || schema.definitions
   if (defs) {
+    const defNames = new Set(Object.keys(defs))
+    // Detect cyclic local refs: if any def's own body references back to a sibling
+    // def, the schema contains a cycle. The JS codegen returns (() => true) on cycle
+    // (permissive), so cyclic schemas must route to the interpreted engine instead.
+    // We check only the def bodies, not the top-level schema, so that a plain
+    // { $ref: '#/$defs/Name', $defs: { Name: { type: 'string' } } } (no cycle)
+    // still compiles.
+    const hasCycle = Object.values(defs).some(
+      (def) => typeof def === 'object' && def !== null && subtreeRefersToLocalDef(def, defNames)
+    )
+    if (hasCycle) return false
     for (const [name, def] of Object.entries(defs)) {
       if (/[~/"']/.test(name)) return false // special chars in def name
       if (typeof def === 'boolean') return false

package/lib/native-load.browser.js

@@ -1,7 +1,7 @@
 'use strict';
 
 // Browser stub: there is no native addon in the browser. Swapped in via the
-// package.json `browser` field so bundlers never resolve `pkg-prebuilds`.
+// package.json `browser` field so bundlers skip native platform probing.
 
 module.exports = function loadNative() {
   return null;

package/lib/native-load.js

@@ -1,21 +1,93 @@
 'use strict';
 
-// Locate and load the optional native addon (pkg-prebuilds). Lives in its own
-// module so the default and browser entries can stay free of `pkg-prebuilds`,
-// `__dirname`, and `path` references. In browser bundles this file is replaced
-// with `native-load.browser.js` via the package.json `browser` field, so the
-// `pkg-prebuilds` import never enters the bundle in the first place.
+// Locate the optional native engine. Resolution order:
+//   1. ATA_NO_NATIVE set        -> null (explicit pure-JS mode)
+//   2. @ata-validator/native-*  -> the per-platform optional package
+//   3. other libc variant       -> linux only, in case detection misfired
+//   4. repo-local dev build     -> contributors working from source
+//   5. null                     -> JS codegen covers all core validation
 //
-// Returns the loaded native binding object, or `null` if no prebuild matches
-// (musl/Alpine, unsupported arch, devs running before `npm run build`, etc.).
-// The JS codegen path covers all core validation when this returns null.
+// Lives in its own module so the default and browser entries stay free of
+// platform probing; browser bundles swap this file for
+// `native-load.browser.js` via the package.json `browser` field.
+
+const VERSION = require('./version');
+
+function nativePackageName(platform, arch, isMusl) {
+  if (platform === 'darwin') return arch === 'arm64' ? '@ata-validator/native-darwin-arm64' : null;
+  if (platform === 'win32') return arch === 'x64' ? '@ata-validator/native-win32-x64' : null;
+  if (platform === 'linux') {
+    if (arch !== 'x64' && arch !== 'arm64') return null;
+    return `@ata-validator/native-linux-${arch}-${isMusl ? 'musl' : 'gnu'}`;
+  }
+  return null;
+}
+
+function detectMusl() {
+  // glibc exposes its version in the process report header; musl does not.
+  try {
+    const report = process.report && process.report.getReport && process.report.getReport();
+    return !!report && !!report.header && !report.header.glibcVersionRuntime;
+  } catch {
+    return false;
+  }
+}
+
+let warned = false;
+function checkVersion(binding, source) {
+  if (!binding) return null;
+  try {
+    const v = typeof binding.version === 'function' ? binding.version() : null;
+    if (v && v !== VERSION) {
+      if (!warned) {
+        warned = true;
+        process.emitWarning(
+          `ata-validator ${VERSION} found a native engine reporting ${v} (${source}); ` +
+          'ignoring it and using the pure-JS engine. Reinstall to realign versions.',
+        );
+      }
+      return null;
+    }
+  } catch {
+    return null;
+  }
+  return binding;
+}
 
 module.exports = function loadNative() {
+  if (process.env.ATA_NO_NATIVE) return null;
+
+  const isMusl = process.platform === 'linux' ? detectMusl() : false;
+  const candidates = [];
+  const primary = nativePackageName(process.platform, process.arch, isMusl);
+  if (primary) candidates.push(primary);
+  if (process.platform === 'linux') {
+    const alt = nativePackageName(process.platform, process.arch, !isMusl);
+    if (alt) candidates.push(alt);
+  }
+
+  for (const name of candidates) {
+    try {
+      const binding = checkVersion(require(name), name);
+      if (binding) return binding;
+    } catch {
+      // not installed on this platform; keep going
+    }
+  }
+
+  // Contributors running from a source checkout.
   try {
     const path = require('path');
-    const pkg = require('pkg-prebuilds');
-    return pkg(path.join(__dirname, '..'), require('../binding-options'));
+    const binding = checkVersion(
+      require(path.join(__dirname, '..', 'build', 'Release', 'ata.node')),
+      'local build',
+    );
+    if (binding) return binding;
   } catch {
-    return null;
+    // no dev build; fall through
   }
+
+  return null;
 };
+
+module.exports.nativePackageName = nativePackageName;

package/lib/t.js

@@ -124,6 +124,90 @@ function refine(schema, check, opts) {
   return attachRefine(schema, check, opts);
 }
 
+function assertObjectSchema(schema, fn) {
+  if (!schema || typeof schema !== 'object' || schema.type !== 'object' ||
+      !schema.properties || typeof schema.properties !== 'object') {
+    throw new Error(`t.${fn}: expected an object schema with properties`);
+  }
+}
+
+// Copy every top-level keyword except the two the combinator recomputes.
+function cloneMeta(schema) {
+  const out = {};
+  for (const key of Object.keys(schema)) {
+    if (key !== 'properties' && key !== 'required') out[key] = schema[key];
+  }
+  return out;
+}
+
+function pick(schema, keys) {
+  assertObjectSchema(schema, 'pick');
+  const keep = new Set(keys);
+  const props = {};
+  for (const key of Object.keys(schema.properties)) {
+    if (keep.has(key)) props[key] = schema.properties[key];
+  }
+  const required = (schema.required || []).filter((key) => keep.has(key));
+  const out = Object.assign(cloneMeta(schema), { properties: props });
+  if (required.length) out.required = required;
+  return out;
+}
+
+function omit(schema, keys) {
+  assertObjectSchema(schema, 'omit');
+  const drop = new Set(keys);
+  const props = {};
+  for (const key of Object.keys(schema.properties)) {
+    if (!drop.has(key)) props[key] = schema.properties[key];
+  }
+  const required = (schema.required || []).filter((key) => !drop.has(key));
+  const out = Object.assign(cloneMeta(schema), { properties: props });
+  if (required.length) out.required = required;
+  return out;
+}
+
+function partial(schema) {
+  assertObjectSchema(schema, 'partial');
+  return Object.assign(cloneMeta(schema), { properties: schema.properties });
+}
+
+function requiredOf(schema, keys) {
+  assertObjectSchema(schema, 'required');
+  const propKeys = Object.keys(schema.properties);
+  let required;
+  if (keys === undefined) {
+    required = propKeys.slice();
+  } else {
+    const known = new Set(propKeys);
+    required = Array.from(new Set([...(schema.required || []), ...keys])).filter((k) => known.has(k));
+  }
+  const out = Object.assign(cloneMeta(schema), { properties: schema.properties });
+  if (required.length) out.required = required;
+  return out;
+}
+
+function recursive(build, opts) {
+  // Single fixed def name; nesting t.recursive inside itself is unsupported
+  // (both layers would claim '#/$defs/self') and documented as such.
+  const self = { $ref: '#/$defs/self' };
+  const body = build(self);
+  return Object.assign({ $ref: '#/$defs/self', $defs: { self: body } }, opts);
+}
+
+function composite(schemas, opts) {
+  const props = {};
+  const requiredSet = new Set();
+  for (const schema of schemas) {
+    assertObjectSchema(schema, 'composite');
+    for (const key of Object.keys(schema.properties)) props[key] = schema.properties[key];
+    for (const key of schema.required || []) requiredSet.add(key);
+  }
+  const required = Array.from(requiredSet).filter((key) => Object.hasOwn(props, key));
+  const out = { type: 'object', properties: props };
+  if (required.length) out.required = required;
+  return Object.assign(out, opts);
+}
+
 module.exports = {
   string,
   number,
@@ -146,4 +230,10 @@ module.exports = {
   never,
   refine,
   OPTIONAL,
+  pick,
+  omit,
+  partial,
+  required: requiredOf,
+  composite,
+  recursive,
 };

package/lib/version.js

@@ -2,9 +2,9 @@
 
 // The package version, exported as a plain string so neither the default nor
 // the browser entry has to `require('./package.json')`. Bundling package.json
-// would drag dependency strings (e.g. `pkg-prebuilds`) into browser builds
-// even though the runtime never touches them.
+// would drag dependency strings into browser builds even though the runtime
+// never touches them.
 //
 // Kept in lockstep with package.json by `tests/test_version_sync.js`.
 
-module.exports = '1.0.2';
+module.exports = '1.1.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "JSON Schema validation with first-class TypeScript and zero runtime cost. AOT compile to per-schema ESM modules with zero validator dependency. Generic Validator<T> for TypeBox/Zod/Valibot composition. Optional runtime API. Standard Schema V1 compatible.",
   "main": "index.js",
   "module": "index.mjs",
@@ -37,18 +37,14 @@
     "ata": "bin/ata.js"
   },
   "browser": {
-    "pkg-prebuilds": false,
     "./lib/native-load.js": "./lib/native-load.browser.js"
   },
   "scripts": {
-    "install": "node scripts/install.js",
-    "prepublishOnly": "node scripts/regen-safe-regex-source.js && node scripts/check-prebuilds.js && ATA_ALLOW_DOC_PLACEHOLDERS=1 node scripts/check-doc-coverage.js && node tests/test_error_codes_lock.js && node tests/test_safe_regex_source_sync.js && node tests/test_version_sync.js",
-    "release:check": "node scripts/regen-safe-regex-source.js && node scripts/check-prebuilds.js && node scripts/check-doc-coverage.js && node tests/test_error_codes_lock.js && node tests/test_safe_regex_source_sync.js && node tests/test_version_sync.js",
+    "prepublishOnly": "node scripts/regen-safe-regex-source.js && node tests/test_pack_purity.js && ATA_ALLOW_DOC_PLACEHOLDERS=1 node scripts/check-doc-coverage.js && node tests/test_error_codes_lock.js && node tests/test_safe_regex_source_sync.js && node tests/test_version_sync.js",
+    "release:check": "node scripts/regen-safe-regex-source.js && node tests/test_pack_purity.js && node scripts/check-doc-coverage.js && node tests/test_error_codes_lock.js && node tests/test_safe_regex_source_sync.js && node tests/test_version_sync.js",
     "build": "cmake-js build --target ata",
     "rebuild": "cmake-js rebuild --target ata",
-    "prebuild": "pkg-prebuilds-copy --baseDir build/Release --source ata.node --name=ata --strip --napi_version=10",
-    "prebuild-all": "npm run prebuild -- --arch x64 && npm run prebuild -- --arch arm64",
-    "test": "node test.js && node tests/test_removed_aot_methods.js && node tests/test_no_native.js && node tests/test_browser_nofs.js && node tests/test_browser_imports_guard.js && node tests/test_version_sync.js && node tests/test_safe_regex_source_sync.js && node tests/test_t_builder.js && node tests/test_async_refine.js && node tests/test_safe_regex.js && node tests/test_safe_regex_integration.js && node tests/test_aot_build.js && node tests/test_aot_differential.js && node tests/test_aot_cli_build.js && node tests/test_aot_cli_smoke.js && node tests/test_bundle_standalone.js && node tests/test_standalone_anyof.js && node tests/test_standalone_formats.js && node tests/test_aot_additional_props_errors.js && node tests/test_id_anchor_refs.js && node tests/test_defs_pointer_alias.js && node tests/test_no_input_mutation.js && node tests/test_typed_validator_runner.js && node tests/test_define_schema.js && node tests/test_error_codes_lock.js && node tests/test_nullable.js && node tests/test_validate_and_parse.js && node tests/test_validate_data.js && node tests/test_enrich_error.js && node tests/test_rich_errors_optout.js && node tests/test_error_messages.js && node tests/test_source_positions.js && node tests/fuzz_positions.js && node tests/test_data_positions.js && node tests/test_render_shared.js && node tests/test_renderers.js && node tests/test_runtime_error_dx.js && node tests/test_aot_error_dx.js && node tests/test_abort_early.js && node tests/test_branch_collapse.js && node tests/test_suggestions.js && node tests/test_cli_validate.js && node tests/test_cli_version.js && node benchmark/bench_aot_size.mjs",
+    "test": "node test.js && node tests/test_removed_aot_methods.js && node tests/test_no_native.js && node tests/test_pure_js_unsupported.js && node tests/test_native_load_order.js && node tests/test_pack_purity.js && node tests/test_make_native_package.js && node tests/test_browser_nofs.js && node tests/test_browser_imports_guard.js && node tests/test_version_sync.js && node tests/test_safe_regex_source_sync.js && node tests/test_t_builder.js && node tests/test_async_refine.js && node tests/test_safe_regex.js && node tests/test_safe_regex_integration.js && node tests/test_aot_build.js && node tests/test_aot_differential.js && node tests/test_aot_cli_build.js && node tests/test_aot_cli_smoke.js && node tests/test_bundle_standalone.js && node tests/test_standalone_anyof.js && node tests/test_standalone_formats.js && node tests/test_aot_additional_props_errors.js && node tests/test_id_anchor_refs.js && node tests/test_defs_pointer_alias.js && node tests/test_no_input_mutation.js && node tests/test_typed_validator_runner.js && node tests/test_define_schema.js && node tests/test_error_codes_lock.js && node tests/test_nullable.js && node tests/test_validate_and_parse.js && node tests/test_validate_data.js && node tests/test_enrich_error.js && node tests/test_rich_errors_optout.js && node tests/test_error_messages.js && node tests/test_source_positions.js && node tests/fuzz_positions.js && node tests/test_data_positions.js && node tests/test_render_shared.js && node tests/test_renderers.js && node tests/test_runtime_error_dx.js && node tests/test_aot_error_dx.js && node tests/test_abort_early.js && node tests/test_branch_collapse.js && node tests/test_suggestions.js && node tests/test_cli_validate.js && node tests/test_cli_version.js && node benchmark/bench_aot_size.mjs",
     "bench:size": "node benchmark/bench_aot_size.mjs",
     "test:suite": "node tests/run_suite.js",
     "test:compat": "node tests/test_compat.js",
@@ -110,22 +106,18 @@
     "t.js",
     "t.mjs",
     "t.d.ts",
-    "binding-options.js",
-    "binding/",
-    "include/",
-    "src/",
-    "deps/",
-    "prebuilds/",
-    "scripts/",
-    "CMakeLists.txt",
+    "bin/",
     "README.md",
     "CHANGELOG.md",
     "LICENSE"
   ],
-  "dependencies": {
-    "node-addon-api": "^8.7.0",
-    "node-api-headers": "^1.8.0",
-    "pkg-prebuilds": "^1.0.0"
+  "optionalDependencies": {
+    "@ata-validator/native-darwin-arm64": "1.1.0",
+    "@ata-validator/native-linux-x64-gnu": "1.1.0",
+    "@ata-validator/native-linux-arm64-gnu": "1.1.0",
+    "@ata-validator/native-linux-x64-musl": "1.1.0",
+    "@ata-validator/native-linux-arm64-musl": "1.1.0",
+    "@ata-validator/native-win32-x64": "1.1.0"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"
@@ -142,6 +134,8 @@
     "esbuild": "^0.28.0",
     "jsonc-parser": "^3.3.1",
     "mitata": "^1.0.34",
+    "node-addon-api": "^8.7.0",
+    "node-api-headers": "^1.8.0",
     "typebox": "^1.1.7",
     "typescript": "^6.0.3",
     "valibot": "^1.3.1",

package/t.d.ts

@@ -167,6 +167,72 @@ export interface TRef extends JSONSchema { $ref: string }
 export interface TAny extends JSONSchema {}
 export interface TNever extends JSONSchema { not: {} }
 
+/** Any object schema the modifier combinators accept. */
+export interface TObjectLike extends JSONSchema {
+  type: 'object';
+  properties: Record<string, JSONSchema>;
+  required?: ReadonlyArray<string>;
+}
+
+type ReqUnion<S> = S extends { required: ReadonlyArray<infer R> } ? R : never;
+
+export interface TPick<S extends TObjectLike, K extends ReadonlyArray<string>> extends JSONSchema {
+  type: 'object';
+  properties: { [P in Extract<keyof S['properties'], K[number]>]: S['properties'][P] };
+  required: ReadonlyArray<Extract<ReqUnion<S>, K[number]>>;
+}
+
+export interface TOmit<S extends TObjectLike, K extends ReadonlyArray<string>> extends JSONSchema {
+  type: 'object';
+  properties: { [P in Exclude<Extract<keyof S['properties'], string>, K[number]>]: S['properties'][P] };
+  required: ReadonlyArray<Exclude<Extract<ReqUnion<S>, string>, K[number]>>;
+}
+
+export interface TPartial<S extends TObjectLike> extends JSONSchema {
+  type: 'object';
+  properties: S['properties'];
+  required: ReadonlyArray<never>;
+}
+
+export interface TRequiredAll<S extends TObjectLike> extends JSONSchema {
+  type: 'object';
+  properties: S['properties'];
+  required: ReadonlyArray<Extract<keyof S['properties'], string>>;
+}
+
+export interface TRequiredWith<S extends TObjectLike, K extends ReadonlyArray<string>> extends JSONSchema {
+  type: 'object';
+  properties: S['properties'];
+  required: ReadonlyArray<Extract<ReqUnion<S> | K[number], Extract<keyof S['properties'], string>>>;
+}
+
+type MergeProps<A, B> = { [K in Extract<keyof A | keyof B, string>]: K extends keyof B ? B[K] : K extends keyof A ? A[K] : never };
+
+type CompositeProps<S extends ReadonlyArray<TObjectLike>> =
+  S extends readonly [] ? {} :
+  S extends readonly [infer H extends TObjectLike, ...infer R extends ReadonlyArray<TObjectLike>]
+    ? MergeProps<H['properties'], CompositeProps<R>>
+    : Record<string, JSONSchema>;
+
+type CompositeReq<S extends ReadonlyArray<TObjectLike>> =
+  S extends readonly [] ? never :
+  S extends readonly [infer H extends TObjectLike, ...infer R extends ReadonlyArray<TObjectLike>]
+    ? ReqUnion<H> | CompositeReq<R>
+    : never;
+
+export interface TComposite<S extends ReadonlyArray<TObjectLike>> extends JSONSchema {
+  type: 'object';
+  properties: CompositeProps<S>;
+  required: ReadonlyArray<Extract<CompositeReq<S>, string>>;
+}
+
+export interface TSelf extends JSONSchema { $ref: '#/$defs/self' }
+
+export interface TRecursive<S extends JSONSchema> extends JSONSchema {
+  $ref: '#/$defs/self';
+  $defs: { self: S };
+}
+
 export interface TBuilder {
   string(opts?: StringOptions): TString;
   number(opts?: NumericOptions): TNumber;
@@ -189,6 +255,24 @@ export interface TBuilder {
   intersect<const S extends ReadonlyArray<JSONSchema>>(schemas: S): TIntersect<S>;
   ref(pointer: string): TRef;
 
+  pick<const S extends TObjectLike, const K extends ReadonlyArray<Extract<keyof S['properties'], string>>>(schema: S, keys: K): TPick<S, K>;
+  omit<const S extends TObjectLike, const K extends ReadonlyArray<Extract<keyof S['properties'], string>>>(schema: S, keys: K): TOmit<S, K>;
+
+  partial<const S extends TObjectLike>(schema: S): TPartial<S>;
+  required<const S extends TObjectLike>(schema: S): TRequiredAll<S>;
+  required<const S extends TObjectLike, const K extends ReadonlyArray<Extract<keyof S['properties'], string>>>(schema: S, keys: K): TRequiredWith<S, K>;
+
+  composite<const S extends ReadonlyArray<TObjectLike>>(schemas: S, opts?: ObjectOptions): TComposite<S>;
+
+  /**
+   * Build a recursive (self-referential) schema. The `self` argument passed to
+   * `build` is a `$ref` pointing to `#/$defs/self`, and the emitted schema
+   * routes through the interpreted engine at runtime. Nesting `t.recursive`
+   * inside itself is unsupported: both layers would claim `#/$defs/self` and
+   * the inner definition would silently overwrite the outer one.
+   */
+  recursive<S extends JSONSchema>(build: (self: TSelf) => S, opts?: { title?: string; description?: string }): TRecursive<S>;
+
   any(): TAny;
   unknown(): TAny;
   never(): TNever;