@cleverbrush/schema-json 0.0.0-beta-20260410073748

package/README.md

@@ -0,0 +1,223 @@
+# @cleverbrush/schema-json
+<!-- coverage-badge-start -->
+![Coverage](https://img.shields.io/badge/coverage-95.5%25-brightgreen)
+<!-- coverage-badge-end -->
+
+Bidirectional JSON Schema (Draft 7 / 2020-12) interop for
+[`@cleverbrush/schema`](../schema).
+
+Import a JSON Schema and get a fully-typed `@cleverbrush/schema` builder that
+preserves every constraint. Or convert a builder back to a JSON Schema object
+for use in OpenAPI specs, form generators, or any other JSON Schema consumer.
+
+## When to use this library
+
+- **Consuming external APIs** — you have a JSON Schema from an OpenAPI spec or
+  a third-party service and want to validate incoming data with full TypeScript
+  type inference.
+- **OpenAPI / JSON Schema round-trip** — generate JSON Schemas from your
+  `@cleverbrush/schema` validators to embed in API specs.
+- **Migrating from raw JSON Schema** — convert an existing schema catalogue to
+  `@cleverbrush/schema` builders incrementally.
+- **Code generation** — introspect a JSON Schema at the type level via
+  `JsonSchemaNodeToBuilder<S>` without running any code.
+
+## Installation
+
+```bash
+npm install @cleverbrush/schema-json
+```
+
+> **Peer dependency:** `@cleverbrush/schema@^2.0.0` must already be installed.
+
+## Quick Start
+
+```ts
+import { fromJsonSchema, toJsonSchema } from '@cleverbrush/schema-json';
+import { object, string, number } from '@cleverbrush/schema';
+
+// ── JSON Schema → builder ──────────────────────────────────────────────────
+const PersonSchema = fromJsonSchema({
+    type: 'object',
+    properties: {
+        name:  { type: 'string', minLength: 1 },
+        email: { type: 'string', format: 'email' },
+        age:   { type: 'integer', minimum: 0 },
+    },
+    required: ['name', 'email'],
+} as const); // ← `as const` is required for precise type inference
+
+const result = PersonSchema.parse({ name: 'Alice', email: 'alice@example.com', age: 30 });
+// result.object is typed as { name: string; email: string; age?: number }
+
+// ── Builder → JSON Schema ──────────────────────────────────────────────────
+const ApiSchema = object({
+    id:    string().uuid(),
+    title: string().minLength(1).maxLength(255),
+    score: number().min(0).max(100).optional(),
+});
+
+const spec = toJsonSchema(ApiSchema);
+// {
+//   "$schema": "https://json-schema.org/draft/2020-12/schema",
+//   "type": "object",
+//   "properties": {
+//     "id":    { "type": "string", "format": "uuid" },
+//     "title": { "type": "string", "minLength": 1, "maxLength": 255 },
+//     "score": { "type": "number" }
+//   },
+//   "required": ["id", "title"]
+// }
+```
+
+## API Reference
+
+### `fromJsonSchema(schema)`
+
+Converts a JSON Schema literal to a `@cleverbrush/schema` builder.
+
+```ts
+function fromJsonSchema<const S>(schema: S): JsonSchemaNodeToBuilder<S>
+```
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| `schema` | JSON Schema literal | Pass with `as const` for precise TypeScript inference |
+
+**Returns** a `@cleverbrush/schema` builder (e.g. `StringSchemaBuilder`,
+`ObjectSchemaBuilder`, `UnionSchemaBuilder`, etc.) whose static type mirrors the
+JSON Schema structure.
+
+#### `as const` is required
+
+Without `as const`, TypeScript widens string literals to `string` and object
+shapes to `Record<string, unknown>`, so inference collapses to
+`SchemaBuilder<unknown>`. Always annotate:
+
+```ts
+const S = { type: 'object', properties: { x: { type: 'number' } } } as const;
+const schema = fromJsonSchema(S); // ObjectSchemaBuilder<{ x: NumberSchemaBuilder<...> }>
+```
+
+#### Supported JSON Schema keywords
+
+| Keyword | Builder equivalent |
+| ------------------------------------------ | ----------------------------------- |
+| `type: 'string'` | `string()` |
+| `type: 'number'` | `number()` |
+| `type: 'integer'` | `number()` with integer flag |
+| `type: 'boolean'` | `boolean()` |
+| `type: 'null'` | `SchemaBuilder<null>` |
+| `type: 'array'` + `items` | `array(itemBuilder)` |
+| `type: 'object'` + `properties` | `object({ … })` |
+| `required: […]` | required / optional per property |
+| `additionalProperties: true` | `.acceptUnknownProps()` |
+| `const` | literal builder (`.equals(...)`) |
+| `enum` | `union(…)` of const builders |
+| `anyOf` | `union(…)` of sub-builders |
+| `allOf` | not supported — falls back to `any()` |
+| `minLength` / `maxLength` | `.minLength()` / `.maxLength()` |
+| `pattern` | `.matches(regex)` (invalid patterns silently ignored) |
+| `minimum` / `maximum` | `.min()` / `.max()` |
+| `exclusiveMinimum` / `exclusiveMaximum` | custom validator (not round-trippable via `toJsonSchema`) |
+| `multipleOf` | `.multipleOf()` |
+| `minItems` / `maxItems` | `.minLength()` / `.maxLength()` on array |
+| `format: 'email'` | `.email()` extension |
+| `format: 'uuid'` | `.uuid()` extension |
+| `format: 'uri'` or `'url'` | `.url()` extension |
+| `format: 'ipv4'` | `.ip({ version: 'v4' })` |
+| `format: 'ipv6'` | `.ip({ version: 'v6' })` |
+| `format: 'date-time'` | `.matches(iso8601 regex)` |
+| `readOnly: true` | `.readonly()` |
+| `description` | `.describe(text)` |
+
+---
+
+### `toJsonSchema(schema, opts?)`
+
+Converts a `@cleverbrush/schema` builder to a JSON Schema object.
+
+```ts
+function toJsonSchema(
+    schema: SchemaBuilder<any, any, any>,
+    opts?: ToJsonSchemaOptions,
+): Record<string, unknown>
+```
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| `schema` | `SchemaBuilder` | any builder from `@cleverbrush/schema` |
+| `opts` | `ToJsonSchemaOptions` | optional output configuration |
+
+**Returns** a plain JavaScript object that is safe to `JSON.stringify`.
+
+Descriptions set via `.describe(text)` are emitted as the `description` field on the corresponding JSON Schema node (including nested object properties).
+
+#### `ToJsonSchemaOptions`
+
+| Option | Type | Default | Description |
+| --- | --- | --- | --- |
+| `draft` | `'2020-12' \| '07'` | `'2020-12'` | JSON Schema draft version for the `$schema` URI |
+| `$schema` | `boolean` | `true` | Whether to include the `$schema` header in the output |
+
+```ts
+// Embed in OpenAPI (suppress the $schema header)
+toJsonSchema(schema, { $schema: false });
+
+// Use Draft 07
+toJsonSchema(schema, { draft: '07' });
+```
+
+---
+
+## Type Utilities
+
+### `InferFromJsonSchema<S>`
+
+Recursively derives the TypeScript value type from a statically-known JSON
+Schema. Useful when you want the type without calling `fromJsonSchema` at
+runtime.
+
+```ts
+import type { InferFromJsonSchema } from '@cleverbrush/schema-json';
+
+const S = {
+    type: 'object',
+    properties: {
+        id:    { type: 'integer' },
+        label: { type: 'string' },
+    },
+    required: ['id'],
+} as const;
+
+type Item = InferFromJsonSchema<typeof S>;
+// { id: number; label?: string }
+```
+
+### `JsonSchemaNodeToBuilder<S, TRequired?>`
+
+Maps a statically-known JSON Schema literal to the `@cleverbrush/schema`
+builder type — purely at the type level, no runtime code executed.
+
+```ts
+import type { JsonSchemaNodeToBuilder } from '@cleverbrush/schema-json';
+
+const S = { type: 'string', format: 'email' } as const;
+type B = JsonSchemaNodeToBuilder<typeof S>;
+// StringSchemaBuilder<string, true>
+```
+
+---
+
+## Limitations
+
+| Limitation | Notes |
+| ----------------------------------------- | ------------------------------------------------------ |
+| Custom validators (`addValidator`) | Not representable in JSON Schema — omitted in `toJsonSchema` output, not recoverable by `fromJsonSchema` |
+| Preprocessors (`addPreprocessor`) | Same as above |
+| `$ref` / `$defs` | Not supported in `fromJsonSchema` |
+| `if` / `then` / `else` | Not supported |
+| `not` | Not supported |
+| `allOf` in `fromJsonSchema` | Falls back to `SchemaBuilder<unknown>` (no deep merge) |
+| Dual IP format (`ip()` with both v4 + v6) | `format` is omitted in `toJsonSchema` output (no standard keyword covers both) |
+| JSDoc comments on properties | Not preserved in `toJsonSchema` output |

package/dist/fromJsonSchema.d.ts

@@ -0,0 +1,86 @@
+import type { JsonSchemaNodeToBuilder } from './types.js';
+/**
+ * Converts a JSON Schema object into a `@cleverbrush/schema` builder.
+ *
+ * @remarks
+ * **`as const` is required for precise TypeScript inference.**  Without it
+ * TypeScript widens string literals to `string` and the inferred builder
+ * type collapses to `SchemaBuilder<unknown>`. Always pass the schema literal
+ * (or the variable holding it) with `as const`.
+ *
+ * **Supported JSON Schema keywords**
+ *
+ * | Keyword                        | Builder equivalent              |
+ * | ------------------------------ | ------------------------------- |
+ * | `type: 'string'`               | `string()`                      |
+ * | `type: 'number'`               | `number()`                      |
+ * | `type: 'integer'`              | `number()` (integer flag)       |
+ * | `type: 'boolean'`              | `boolean()`                     |
+ * | `type: 'null'`                 | `SchemaBuilder<null>`           |
+ * | `type: 'array'` + `items`      | `array(itemBuilder)`            |
+ * | `type: 'object'` + `properties`| `object({ … })`                 |
+ * | `required: […]`                | required / optional per-prop    |
+ * | `additionalProperties: true`   | `.acceptUnknownProps()`         |
+ * | `const`                        | `string/number/boolean eq`      |
+ * | `enum`                         | `union(…)`                      |
+ * | `anyOf`                        | `union(…)`                      |
+ * | `minLength` / `maxLength`      | `.minLength()` / `.maxLength()` |
+ * | `pattern`                      | `.matches(regex)` (invalid patterns silently ignored) |
+ * | `minimum` / `maximum`          | `.min()` / `.max()`             |
+ * | `exclusiveMinimum` / `exclusiveMaximum` | custom validator (not round-trippable via `toJsonSchema`) |
+ * | `multipleOf`                   | `.multipleOf()`                 |
+ * | `minItems` / `maxItems`        | `.minLength()` / `.maxLength()` |
+ * | `format: 'email'`              | `.email()` extension            |
+ * | `format: 'uuid'`               | `.uuid()` extension             |
+ * | `format: 'uri'` / `'url'`      | `.url()` extension              |
+ * | `format: 'ipv4'`               | `.ip({ version: 'v4' })`        |
+ * | `format: 'ipv6'`               | `.ip({ version: 'v6' })`        |
+ * | `format: 'date-time'`          | `.matches(iso8601 regex)`       |
+ *
+ * Keywords **not** supported: `allOf` (falls back to `any()`), `$ref`,
+ * `$defs`, `if/then/else`, `not`, `contains`, `unevaluatedProperties`,
+ * `contentEncoding`.
+ *
+ * @param schema - A JSON Schema literal.  Pass with `as const` for precise
+ *   TypeScript type inference on the returned builder.
+ * @returns A `@cleverbrush/schema` builder whose static type mirrors the
+ *   structure described by the JSON Schema node.
+ *
+ * @example
+ * ```ts
+ * import { fromJsonSchema } from '@cleverbrush/schema-json';
+ *
+ * const schema = fromJsonSchema({
+ *   type: 'object',
+ *   properties: {
+ *     name:  { type: 'string', minLength: 1 },
+ *     score: { type: 'number', minimum: 0, maximum: 100 },
+ *   },
+ *   required: ['name'],
+ * } as const);
+ *
+ * schema.parse({ name: 'Alice', score: 95 });
+ * // TypeScript infers: { name: string; score?: number }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Union types via `enum`
+ * const statusSchema = fromJsonSchema({
+ *   enum: ['active', 'inactive', 'pending']
+ * } as const);
+ *
+ * statusSchema.parse('active'); // valid — 'active' | 'inactive' | 'pending'
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Use InferFromJsonSchema to derive the TypeScript type statically
+ * import type { InferFromJsonSchema } from '@cleverbrush/schema-json';
+ *
+ * const S = { type: 'object', properties: { id: { type: 'integer' } }, required: ['id'] } as const;
+ * type Payload = InferFromJsonSchema<typeof S>; // { id: number }
+ * const payloadSchema = fromJsonSchema(S);
+ * ```
+ */
+export declare function fromJsonSchema<const S>(schema: S): JsonSchemaNodeToBuilder<S>;

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `@cleverbrush/schema-json` — Bidirectional JSON Schema interop for `@cleverbrush/schema`.
+ *
+ * @example
+ * ```ts
+ * import { toJsonSchema, fromJsonSchema } from '@cleverbrush/schema-json';
+ * import { object, string, number } from '@cleverbrush/schema';
+ *
+ * // Schema → JSON Schema
+ * const spec = toJsonSchema(object({ name: string(), age: number().optional() }));
+ *
+ * // JSON Schema → Schema (use `as const` for type inference)
+ * const schema = fromJsonSchema({ type: 'object', properties: { name: { type: 'string' } }, required: ['name'] } as const);
+ * schema.parse({ name: 'Alice' }); // inferred as { name: string }
+ * ```
+ *
+ * @module
+ */
+export type { StandardJSONSchemaV1, StandardTypedV1 } from '@standard-schema/spec';
+export { fromJsonSchema } from './fromJsonSchema.js';
+export { withStandardJsonSchema } from './standardJsonSchema.js';
+export { toJsonSchema } from './toJsonSchema.js';
+export type { InferFromJsonSchema, JsonSchemaNode, JsonSchemaNodeToBuilder, ToJsonSchemaOptions } from './types.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+import{any as u,array as J,boolean as b,nul as v,number as l,object as B,string as x,tuple as N,union as O}from"@cleverbrush/schema";function p(n){return{valid:!1,errors:[{message:n}]}}function y(){return{valid:!0,errors:[]}}function m(n){if(typeof n!="object"||n===null)return u();let e=n,t;if("enum"in e&&Array.isArray(e.enum))t=j(e.enum);else if("const"in e)t=h(e.const);else if("anyOf"in e&&Array.isArray(e.anyOf))t=I(e.anyOf);else if("allOf"in e&&Array.isArray(e.allOf))t=u();else if(!("type"in e))t=u();else switch(e.type){case"string":t=T(e);break;case"number":t=S(e,!1);break;case"integer":t=S(e,!0);break;case"boolean":t=b();break;case"null":t=v();break;case"array":t=L(e);break;case"object":t=R(e);break;default:t=u()}return e.readOnly===!0&&(t=t.readonly()),typeof e.description=="string"&&e.description&&(t=t.describe(e.description)),t}function h(n){return typeof n=="string"?x(n):typeof n=="number"?l(n):typeof n=="boolean"?b().equals(n):u()}function T(n){let e=x(),t=n.format;if(t==="email"?e=e.email():t==="uuid"?e=e.uuid():t==="uri"||t==="url"?e=e.url():t==="ipv4"?e=e.ip({version:"v4"}):t==="ipv6"?e=e.ip({version:"v6"}):t==="date-time"&&(e=e.addValidator(a=>typeof a=="string"&&!Number.isNaN(Date.parse(a))?y():p("must be a valid date-time string"))),typeof n.minLength=="number"&&(e=e.minLength(n.minLength)),typeof n.maxLength=="number"&&(e=e.maxLength(n.maxLength)),typeof n.pattern=="string")try{e=e.matches(new RegExp(n.pattern))}catch{}return e}function S(n,e){let t=e?l().isInteger():l().isFloat();if(typeof n.minimum=="number"&&(t=t.min(n.minimum)),typeof n.maximum=="number"&&(t=t.max(n.maximum)),typeof n.multipleOf=="number"&&(t=t.multipleOf(n.multipleOf)),typeof n.exclusiveMinimum=="number"){let a=n.exclusiveMinimum;t=t.addValidator(r=>typeof r=="number"&&r>a?y():p(`must be greater than ${a}`))}if(typeof n.exclusiveMaximum=="number"){let a=n.exclusiveMaximum;t=t.addValidator(r=>typeof r=="number"&&r<a?y():p(`must be less than ${a}`))}return t}function L(n){if(Array.isArray(n.prefixItems)){let t=n.prefixItems.map(m),a=N(t);return n.items!==void 0&&n.items!==!1&&typeof n.items=="object"&&(a=a.rest(m(n.items))),a}let e=J();return n.items!==void 0&&(e=e.of(m(n.items))),typeof n.minItems=="number"&&(e=e.minLength(n.minItems)),typeof n.maxItems=="number"&&(e=e.maxLength(n.maxItems)),e}function R(n){let e=n.properties,t=new Set(Array.isArray(n.required)?n.required:[]),a=B();if(e)for(let[r,i]of Object.entries(e)){let s=m(i);a=a.addProp(r,t.has(r)?s.required():s.optional())}return n.additionalProperties!==!1&&(a=a.acceptUnknownProps()),a}function j(n){if(n.length===0)return u();let[e,...t]=n,a=O(h(e));for(let r of t)a=a.or(h(r));return a}function I(n){if(n.length===0)return u();let[e,...t]=n,a=O(m(e));for(let r of t)a=a.or(m(r));return a}function q(n){return m(n)}function w(n){return n.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}function $(n){let e=n.introspect(),t=e.extensions??{},a=e.isReadonly===!0?{readOnly:!0}:{};switch(e.type){case"string":{if(e.equalsTo!==void 0)return{...a,const:e.equalsTo};let r={...a,type:"string"};if(t.email===!0)r.format="email";else if(t.uuid===!0)r.format="uuid";else if(t.url)r.format="uri";else if(t.ip){let i=typeof t.ip=="object"?t.ip.version:void 0;i==="v4"?r.format="ipv4":i==="v6"&&(r.format="ipv6")}if(e.minLength!==void 0&&(r.minLength=e.minLength),e.maxLength!==void 0&&(r.maxLength=e.maxLength),t.nonempty===!0&&r.minLength===void 0&&(r.minLength=1),e.matches instanceof RegExp){if(e.matches.flags!=="")throw new Error(`Cannot convert RegExp /${e.matches.source}/${e.matches.flags} to JSON Schema pattern: RegExp flags are not representable in standard JSON Schema.`);r.pattern=e.matches.source}else e.startsWith!==void 0?r.pattern=`^${w(e.startsWith)}`:e.endsWith!==void 0&&(r.pattern=`${w(e.endsWith)}$`);return r}case"number":{if(e.equalsTo!==void 0)return{...a,const:e.equalsTo};let r={...a,type:e.isInteger?"integer":"number"};return e.min!==void 0&&(r.minimum=e.min),e.max!==void 0&&(r.maximum=e.max),t.multipleOf!==void 0&&(r.multipleOf=t.multipleOf),t.positive===!0&&(r.exclusiveMinimum=0),t.negative===!0&&(r.exclusiveMaximum=0),r}case"boolean":return e.equalsTo!==void 0?{...a,const:e.equalsTo}:{...a,type:"boolean"};case"date":return{...a,type:"string",format:"date-time"};case"array":{let r={...a,type:"array"};return e.elementSchema&&(r.items=c(e.elementSchema)),e.minLength!==void 0&&(r.minItems=e.minLength),e.maxLength!==void 0&&(r.maxItems=e.maxLength),t.nonempty===!0&&r.minItems===void 0&&(r.minItems=1),r}case"tuple":{let r=e.elements??[],i={type:"array",prefixItems:r.map(c),minItems:r.length};return e.restSchema?i.items=c(e.restSchema):(i.items=!1,i.maxItems=r.length),i}case"object":{let r={...a,type:"object"},i=e.properties;if(i){let s={},f=[];for(let[o,g]of Object.entries(i))s[o]=c(g),g.introspect().isRequired!==!1&&f.push(o);r.properties=s,f.length>0&&(r.required=f)}return e.acceptUnknownProps===!1&&(r.additionalProperties=!1),r}case"null":return{...a,type:"null"};case"union":{let r=e.options??[],i=[],s=r.length>0;for(let f of r){let o=f.introspect();if((o.type==="string"||o.type==="number"||o.type==="boolean")&&o.equalsTo!==void 0)i.push(o.equalsTo);else{s=!1;break}}return s?{...a,enum:i}:{...a,anyOf:r.map(c)}}default:return{}}}function c(n){let e=$(n),t=n.introspect();return typeof t.description=="string"&&t.description!==""&&(e.description=t.description),e}function d(n,e){let t=c(n);return e?.$schema===!1?t:{$schema:(e?.draft??"2020-12")==="07"?"http://json-schema.org/draft-07/schema#":"https://json-schema.org/draft/2020-12/schema",...t}}function k(n){switch(n){case"draft-2020-12":return{draft:"2020-12",$schema:!1};case"draft-07":return{draft:"07",$schema:!1};case"openapi-3.0":return{draft:"07",$schema:!1};default:throw new Error(`@cleverbrush/schema-json: unsupported JSON Schema target "${n}".`)}}function V(n){let e={input(r){return d(n,k(r.target))},output(r){return d(n,k(r.target))}},a={...n["~standard"],jsonSchema:e};return Object.defineProperty(n,"~standard",{value:a,configurable:!0,writable:!1,enumerable:!1}),n}export{q as fromJsonSchema,d as toJsonSchema,V as withStandardJsonSchema};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/fromJsonSchema.ts","../src/toJsonSchema.ts","../src/standardJsonSchema.ts"],"sourcesContent":["import type { SchemaBuilder } from '@cleverbrush/schema';\nimport {\n    any,\n    array,\n    boolean,\n    nul,\n    number,\n    object,\n    string,\n    tuple,\n    union\n} from '@cleverbrush/schema';\nimport type { JsonSchemaNodeToBuilder } from './types.js';\n\n// ---------------------------------------------------------------------------\n// Internal helpers\n// ---------------------------------------------------------------------------\n\nfunction fail(msg: string) {\n    return { valid: false as const, errors: [{ message: msg }] };\n}\n\nfunction ok() {\n    return { valid: true as const, errors: [] };\n}\n\nfunction buildNode(s: unknown): SchemaBuilder<any, any, any> {\n    if (typeof s !== 'object' || s === null) return any();\n    const node = s as Record<string, unknown>;\n\n    let b: SchemaBuilder<any, any, any>;\n\n    if ('enum' in node && Array.isArray(node['enum']))\n        b = buildEnum(node['enum']);\n    else if ('const' in node) b = buildConst(node['const']);\n    else if ('anyOf' in node && Array.isArray(node['anyOf']))\n        b = buildAnyOf(node['anyOf']);\n    // allOf is not supported (no intersection builder); fall back to any()\n    else if ('allOf' in node && Array.isArray(node['allOf'])) b = any();\n    else if (!('type' in node)) b = any();\n    else {\n        switch (node['type']) {\n            case 'string':\n                b = buildString(node);\n                break;\n            case 'number':\n                b = buildNumber(node, false);\n                break;\n            case 'integer':\n                b = buildNumber(node, true);\n                break;\n            case 'boolean':\n                b = boolean();\n                break;\n            case 'null':\n                b = nul();\n                break;\n            case 'array':\n                b = buildArray(node);\n                break;\n            case 'object':\n                b = buildObject(node);\n                break;\n            default:\n                b = any();\n        }\n    }\n\n    if (node['readOnly'] === true) b = (b as any).readonly();\n    if (typeof node['description'] === 'string' && node['description'])\n        b = (b as any).describe(node['description']);\n    return b;\n}\n\nfunction buildConst(val: unknown): SchemaBuilder<any, any, any> {\n    if (typeof val === 'string') return string(val as any);\n    if (typeof val === 'number') return number(val as any);\n    if (typeof val === 'boolean') return boolean().equals(val);\n    return any();\n}\n\nfunction buildString(\n    node: Record<string, unknown>\n): SchemaBuilder<any, any, any> {\n    let b: any = string();\n    const format = node['format'] as string | undefined;\n\n    if (format === 'email') {\n        b = b.email();\n    } else if (format === 'uuid') {\n        b = b.uuid();\n    } else if (format === 'uri' || format === 'url') {\n        b = b.url();\n    } else if (format === 'ipv4') {\n        b = b.ip({ version: 'v4' });\n    } else if (format === 'ipv6') {\n        b = b.ip({ version: 'v6' });\n    } else if (format === 'date-time') {\n        b = b.addValidator((v: unknown) =>\n            typeof v === 'string' && !Number.isNaN(Date.parse(v))\n                ? ok()\n                : fail('must be a valid date-time string')\n        );\n    }\n\n    if (typeof node['minLength'] === 'number')\n        b = b.minLength(node['minLength']);\n    if (typeof node['maxLength'] === 'number')\n        b = b.maxLength(node['maxLength']);\n    if (typeof node['pattern'] === 'string') {\n        try {\n            b = b.matches(new RegExp(node['pattern']));\n        } catch {\n            // invalid regex pattern — silently ignore\n        }\n    }\n    return b;\n}\n\nfunction buildNumber(\n    node: Record<string, unknown>,\n    integer: boolean\n): SchemaBuilder<any, any, any> {\n    let b: any = integer ? number().isInteger() : number().isFloat();\n    if (typeof node['minimum'] === 'number') b = b.min(node['minimum']);\n    if (typeof node['maximum'] === 'number') b = b.max(node['maximum']);\n    if (typeof node['multipleOf'] === 'number') {\n        b = b.multipleOf(node['multipleOf']);\n    }\n    if (typeof node['exclusiveMinimum'] === 'number') {\n        const min = node['exclusiveMinimum'];\n        b = b.addValidator((v: unknown) =>\n            typeof v === 'number' && v > min\n                ? ok()\n                : fail(`must be greater than ${min}`)\n        );\n    }\n    if (typeof node['exclusiveMaximum'] === 'number') {\n        const max = node['exclusiveMaximum'];\n        b = b.addValidator((v: unknown) =>\n            typeof v === 'number' && v < max\n                ? ok()\n                : fail(`must be less than ${max}`)\n        );\n    }\n    return b;\n}\n\nfunction buildArray(\n    node: Record<string, unknown>\n): SchemaBuilder<any, any, any> {\n    // JSON Schema 2020-12 tuples use `prefixItems`\n    if (Array.isArray(node['prefixItems'])) {\n        const elements = (node['prefixItems'] as unknown[]).map(buildNode);\n        let b: any = tuple(elements as any);\n        // `items: false` means no extra elements (default for tuple)\n        // `items: <schema>` means rest elements validated against that schema\n        if (\n            node['items'] !== undefined &&\n            node['items'] !== false &&\n            typeof node['items'] === 'object'\n        ) {\n            b = b.rest(buildNode(node['items']));\n        }\n        return b;\n    }\n    let b: any = array();\n    if (node['items'] !== undefined) b = b.of(buildNode(node['items']));\n    if (typeof node['minItems'] === 'number') b = b.minLength(node['minItems']);\n    if (typeof node['maxItems'] === 'number') b = b.maxLength(node['maxItems']);\n    return b;\n}\n\nfunction buildObject(\n    node: Record<string, unknown>\n): SchemaBuilder<any, any, any> {\n    const props = node['properties'] as Record<string, unknown> | undefined;\n    const requiredSet = new Set<string>(\n        Array.isArray(node['required']) ? (node['required'] as string[]) : []\n    );\n    let b: any = object();\n    if (props) {\n        for (const [key, propNode] of Object.entries(props)) {\n            const propBuilder = buildNode(propNode);\n            b = b.addProp(\n                key,\n                requiredSet.has(key)\n                    ? propBuilder.required()\n                    : propBuilder.optional()\n            );\n        }\n    }\n    if (node['additionalProperties'] !== false) b = b.acceptUnknownProps();\n    return b;\n}\n\nfunction buildEnum(values: unknown[]): SchemaBuilder<any, any, any> {\n    if (values.length === 0) return any();\n    const [first, ...rest] = values;\n    let b: any = union(buildConst(first));\n    for (const v of rest) b = b.or(buildConst(v));\n    return b;\n}\n\nfunction buildAnyOf(options: unknown[]): SchemaBuilder<any, any, any> {\n    if (options.length === 0) return any();\n    const [first, ...rest] = options;\n    let b: any = union(buildNode(first));\n    for (const opt of rest) b = b.or(buildNode(opt));\n    return b;\n}\n\n/**\n * Converts a JSON Schema object into a `@cleverbrush/schema` builder.\n *\n * @remarks\n * **`as const` is required for precise TypeScript inference.**  Without it\n * TypeScript widens string literals to `string` and the inferred builder\n * type collapses to `SchemaBuilder<unknown>`. Always pass the schema literal\n * (or the variable holding it) with `as const`.\n *\n * **Supported JSON Schema keywords**\n *\n * | Keyword                        | Builder equivalent              |\n * | ------------------------------ | ------------------------------- |\n * | `type: 'string'`               | `string()`                      |\n * | `type: 'number'`               | `number()`                      |\n * | `type: 'integer'`              | `number()` (integer flag)       |\n * | `type: 'boolean'`              | `boolean()`                     |\n * | `type: 'null'`                 | `SchemaBuilder<null>`           |\n * | `type: 'array'` + `items`      | `array(itemBuilder)`            |\n * | `type: 'object'` + `properties`| `object({ … })`                 |\n * | `required: […]`                | required / optional per-prop    |\n * | `additionalProperties: true`   | `.acceptUnknownProps()`         |\n * | `const`                        | `string/number/boolean eq`      |\n * | `enum`                         | `union(…)`                      |\n * | `anyOf`                        | `union(…)`                      |\n * | `minLength` / `maxLength`      | `.minLength()` / `.maxLength()` |\n * | `pattern`                      | `.matches(regex)` (invalid patterns silently ignored) |\n * | `minimum` / `maximum`          | `.min()` / `.max()`             |\n * | `exclusiveMinimum` / `exclusiveMaximum` | custom validator (not round-trippable via `toJsonSchema`) |\n * | `multipleOf`                   | `.multipleOf()`                 |\n * | `minItems` / `maxItems`        | `.minLength()` / `.maxLength()` |\n * | `format: 'email'`              | `.email()` extension            |\n * | `format: 'uuid'`               | `.uuid()` extension             |\n * | `format: 'uri'` / `'url'`      | `.url()` extension              |\n * | `format: 'ipv4'`               | `.ip({ version: 'v4' })`        |\n * | `format: 'ipv6'`               | `.ip({ version: 'v6' })`        |\n * | `format: 'date-time'`          | `.matches(iso8601 regex)`       |\n *\n * Keywords **not** supported: `allOf` (falls back to `any()`), `$ref`,\n * `$defs`, `if/then/else`, `not`, `contains`, `unevaluatedProperties`,\n * `contentEncoding`.\n *\n * @param schema - A JSON Schema literal.  Pass with `as const` for precise\n *   TypeScript type inference on the returned builder.\n * @returns A `@cleverbrush/schema` builder whose static type mirrors the\n *   structure described by the JSON Schema node.\n *\n * @example\n * ```ts\n * import { fromJsonSchema } from '@cleverbrush/schema-json';\n *\n * const schema = fromJsonSchema({\n *   type: 'object',\n *   properties: {\n *     name:  { type: 'string', minLength: 1 },\n *     score: { type: 'number', minimum: 0, maximum: 100 },\n *   },\n *   required: ['name'],\n * } as const);\n *\n * schema.parse({ name: 'Alice', score: 95 });\n * // TypeScript infers: { name: string; score?: number }\n * ```\n *\n * @example\n * ```ts\n * // Union types via `enum`\n * const statusSchema = fromJsonSchema({\n *   enum: ['active', 'inactive', 'pending']\n * } as const);\n *\n * statusSchema.parse('active'); // valid — 'active' | 'inactive' | 'pending'\n * ```\n *\n * @example\n * ```ts\n * // Use InferFromJsonSchema to derive the TypeScript type statically\n * import type { InferFromJsonSchema } from '@cleverbrush/schema-json';\n *\n * const S = { type: 'object', properties: { id: { type: 'integer' } }, required: ['id'] } as const;\n * type Payload = InferFromJsonSchema<typeof S>; // { id: number }\n * const payloadSchema = fromJsonSchema(S);\n * ```\n */\nexport function fromJsonSchema<const S>(schema: S): JsonSchemaNodeToBuilder<S> {\n    return buildNode(schema) as JsonSchemaNodeToBuilder<S>;\n}\n","import type { SchemaBuilder } from '@cleverbrush/schema';\nimport type { ToJsonSchemaOptions } from './types.js';\n\ntype Out = Record<string, unknown>;\n\nfunction escapeRegex(s: string): string {\n    return s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n}\n\nfunction convertNodeInner(schema: SchemaBuilder<any, any, any>): Out {\n    const info = schema.introspect() as any;\n    const ext: Record<string, unknown> = info.extensions ?? {};\n    const readOnly: Out = info.isReadonly === true ? { readOnly: true } : {};\n\n    switch (info.type) {\n        case 'string': {\n            if (info.equalsTo !== undefined)\n                return { ...readOnly, const: info.equalsTo };\n            const out: Out = { ...readOnly, type: 'string' };\n            if (ext['email'] === true) {\n                out['format'] = 'email';\n            } else if (ext['uuid'] === true) {\n                out['format'] = 'uuid';\n            } else if (ext['url']) {\n                out['format'] = 'uri';\n            } else if (ext['ip']) {\n                const ver =\n                    typeof ext['ip'] === 'object'\n                        ? (ext['ip'] as any).version\n                        : undefined;\n                if (ver === 'v4') out['format'] = 'ipv4';\n                else if (ver === 'v6') out['format'] = 'ipv6';\n                // both versions: no single standard JSON Schema format — omit\n            }\n            if (info.minLength !== undefined) out['minLength'] = info.minLength;\n            if (info.maxLength !== undefined) out['maxLength'] = info.maxLength;\n            // .nonempty() sets minLength via extension; if not already set\n            if (ext['nonempty'] === true && out['minLength'] === undefined)\n                out['minLength'] = 1;\n            if (info.matches instanceof RegExp) {\n                if (info.matches.flags !== '') {\n                    throw new Error(\n                        `Cannot convert RegExp /${info.matches.source}/${info.matches.flags} to JSON Schema pattern: RegExp flags are not representable in standard JSON Schema.`\n                    );\n                }\n                out['pattern'] = info.matches.source;\n            } else if (info.startsWith !== undefined) {\n                out['pattern'] = `^${escapeRegex(info.startsWith)}`;\n            } else if (info.endsWith !== undefined) {\n                out['pattern'] = `${escapeRegex(info.endsWith)}$`;\n            }\n            return out;\n        }\n\n        case 'number': {\n            if (info.equalsTo !== undefined)\n                return { ...readOnly, const: info.equalsTo };\n            const out: Out = {\n                ...readOnly,\n                type: info.isInteger ? 'integer' : 'number'\n            };\n            if (info.min !== undefined) out['minimum'] = info.min;\n            if (info.max !== undefined) out['maximum'] = info.max;\n            if (ext['multipleOf'] !== undefined)\n                out['multipleOf'] = ext['multipleOf'];\n            if (ext['positive'] === true) out['exclusiveMinimum'] = 0;\n            if (ext['negative'] === true) out['exclusiveMaximum'] = 0;\n            return out;\n        }\n\n        case 'boolean': {\n            if (info.equalsTo !== undefined)\n                return { ...readOnly, const: info.equalsTo };\n            return { ...readOnly, type: 'boolean' };\n        }\n\n        case 'date':\n            return { ...readOnly, type: 'string', format: 'date-time' };\n\n        case 'array': {\n            const out: Out = { ...readOnly, type: 'array' };\n            if (info.elementSchema)\n                out['items'] = convertNode(info.elementSchema);\n            if (info.minLength !== undefined) out['minItems'] = info.minLength;\n            if (info.maxLength !== undefined) out['maxItems'] = info.maxLength;\n            if (ext['nonempty'] === true && out['minItems'] === undefined)\n                out['minItems'] = 1;\n            return out;\n        }\n\n        case 'tuple': {\n            const elements: SchemaBuilder<any, any, any>[] =\n                info.elements ?? [];\n            const out: Out = {\n                type: 'array',\n                prefixItems: elements.map(convertNode),\n                minItems: elements.length\n            };\n            if (info.restSchema) {\n                out['items'] = convertNode(info.restSchema);\n            } else {\n                out['items'] = false;\n                out['maxItems'] = elements.length;\n            }\n            return out;\n        }\n\n        case 'object': {\n            const out: Out = { ...readOnly, type: 'object' };\n            const props = info.properties as\n                | Record<string, SchemaBuilder<any, any, any>>\n                | undefined;\n            if (props) {\n                const outProps: Record<string, unknown> = {};\n                const required: string[] = [];\n                for (const [key, propSchema] of Object.entries(props)) {\n                    outProps[key] = convertNode(propSchema);\n                    if ((propSchema.introspect() as any).isRequired !== false)\n                        required.push(key);\n                }\n                out['properties'] = outProps;\n                if (required.length > 0) out['required'] = required;\n            }\n            if (info.acceptUnknownProps === false)\n                out['additionalProperties'] = false;\n            return out;\n        }\n\n        case 'null':\n            return { ...readOnly, type: 'null' };\n\n        case 'union': {\n            const options: SchemaBuilder<any, any, any>[] = info.options ?? [];\n            const enumValues: unknown[] = [];\n            let allConst = options.length > 0;\n            for (const opt of options) {\n                const oi = opt.introspect() as any;\n                if (\n                    (oi.type === 'string' ||\n                        oi.type === 'number' ||\n                        oi.type === 'boolean') &&\n                    oi.equalsTo !== undefined\n                ) {\n                    enumValues.push(oi.equalsTo);\n                } else {\n                    allConst = false;\n                    break;\n                }\n            }\n            if (allConst) return { ...readOnly, enum: enumValues };\n            return { ...readOnly, anyOf: options.map(convertNode) };\n        }\n\n        default:\n            return {};\n    }\n}\n\nfunction convertNode(schema: SchemaBuilder<any, any, any>): Out {\n    const out = convertNodeInner(schema);\n    const info = schema.introspect() as any;\n    if (typeof info.description === 'string' && info.description !== '')\n        out['description'] = info.description;\n    return out;\n}\n\n/**\n * Converts a `@cleverbrush/schema` builder to a JSON Schema object.\n *\n * @remarks\n * **What round-trips cleanly**: all declarative constraints — type, format,\n * minLength/maxLength, minimum/maximum, multipleOf, pattern, required/optional\n * per property, additionalProperties, items, enum/const literals, anyOf/union.\n *\n * **What is silently omitted**:\n * - Custom validators added via `addValidator` (no JSON Schema equivalent)\n * - Preprocessors added via `addPreprocessor`\n * - JSDoc comments on schema properties\n * - `exclusiveMinimum`/`exclusiveMaximum` constraints from `fromJsonSchema`\n *   (stored as custom validators — not introspectable; only `positive()`/\n *   `negative()` extension-based exclusives are emitted)\n * - IP format with both v4 _and_ v6 allowed simultaneously (no single\n *   standard JSON Schema format covers both; the `format` keyword is omitted\n *   in that case)\n *\n * By default the output includes a `$schema` header for JSON Schema Draft\n * 2020-12. Pass `{ $schema: false }` when embedding the result in an OpenAPI\n * specification, or `{ draft: '07' }` for Draft 07 compatibility.\n *\n * @param schema - Any `@cleverbrush/schema` builder instance.\n * @param opts   - Optional output configuration (see {@link ToJsonSchemaOptions}).\n * @returns A plain JSON-serialisable object representing the schema.\n *\n * @example\n * ```ts\n * import { toJsonSchema } from '@cleverbrush/schema-json';\n * import { object, string, number } from '@cleverbrush/schema';\n *\n * const UserSchema = object({\n *   name:  string().minLength(1),\n *   email: string().email(),\n *   age:   number().optional(),\n * });\n *\n * const spec = toJsonSchema(UserSchema);\n * // {\n * //   \"$schema\": \"https://json-schema.org/draft/2020-12/schema\",\n * //   \"type\": \"object\",\n * //   \"properties\": {\n * //     \"name\":  { \"type\": \"string\", \"minLength\": 1 },\n * //     \"email\": { \"type\": \"string\", \"format\": \"email\" },\n * //     \"age\":   { \"type\": \"number\" }\n * //   },\n * //   \"required\": [\"name\", \"email\"]\n * // }\n * ```\n *\n * @example\n * ```ts\n * // Embed in an OpenAPI spec (strip the $schema header)\n * toJsonSchema(schema, { $schema: false });\n *\n * // Use JSON Schema Draft 07\n * toJsonSchema(schema, { draft: '07' });\n * ```\n */\nexport function toJsonSchema(\n    schema: SchemaBuilder<any, any, any>,\n    opts?: ToJsonSchemaOptions\n): Record<string, unknown> {\n    const body = convertNode(schema);\n    if (opts?.$schema === false) return body;\n    const draft = opts?.draft ?? '2020-12';\n    const uri =\n        draft === '07'\n            ? 'http://json-schema.org/draft-07/schema#'\n            : 'https://json-schema.org/draft/2020-12/schema';\n    return { $schema: uri, ...body };\n}\n","import type { SchemaBuilder } from '@cleverbrush/schema';\nimport type { StandardJSONSchemaV1 } from '@standard-schema/spec';\nimport { toJsonSchema } from './toJsonSchema.js';\n\n/**\n * Maps Standard JSON Schema target identifiers to the options accepted by\n * {@link toJsonSchema}.\n */\nfunction targetToOptions(target: StandardJSONSchemaV1.Target): {\n    draft: '2020-12' | '07';\n    $schema: false;\n} {\n    switch (target) {\n        case 'draft-2020-12':\n            return { draft: '2020-12', $schema: false };\n        case 'draft-07':\n            return { draft: '07', $schema: false };\n        case 'openapi-3.0':\n            // OpenAPI 3.0 is a superset of JSON Schema Draft 04; Draft 07 is\n            // the closest we support.\n            return { draft: '07', $schema: false };\n        default:\n            throw new Error(\n                `@cleverbrush/schema-json: unsupported JSON Schema target \"${target}\".`\n            );\n    }\n}\n\n/**\n * Wraps a `@cleverbrush/schema` builder with the\n * [Standard JSON Schema v1](https://standardschema.dev/) interface.\n *\n * The returned schema object's `~standard` property is enriched with a\n * `jsonSchema` converter. Because `@cleverbrush/schema` does not\n * distinguish between input and output types, both `input()` and `output()`\n * produce the same JSON Schema document.\n *\n * **Note:** this mutates the schema instance by overriding the `~standard`\n * property. The returned reference is the same schema object.\n *\n * @example\n * ```ts\n * import { object, string, number } from '@cleverbrush/schema';\n * import { withStandardJsonSchema } from '@cleverbrush/schema-json';\n *\n * const schema = object({ name: string(), age: number().optional() });\n * const wrapped = withStandardJsonSchema(schema);\n *\n * // Access standard JSON Schema properties\n * wrapped['~standard'].jsonSchema.input({ target: 'draft-2020-12' });\n * wrapped['~standard'].jsonSchema.output({ target: 'draft-07' });\n * ```\n *\n * @param schema - Any `@cleverbrush/schema` builder instance.\n * @returns The same schema instance, now also conforming to `StandardJSONSchemaV1`.\n */\nexport function withStandardJsonSchema<\n    T extends SchemaBuilder<any, any, any, any, any>\n>(schema: T): T & StandardJSONSchemaV1 {\n    const converter: StandardJSONSchemaV1.Converter = {\n        input(options: StandardJSONSchemaV1.Options): Record<string, unknown> {\n            return toJsonSchema(schema, targetToOptions(options.target));\n        },\n        output(options: StandardJSONSchemaV1.Options): Record<string, unknown> {\n            return toJsonSchema(schema, targetToOptions(options.target));\n        }\n    };\n\n    // Extend the existing `~standard` props (which already include the\n    // StandardSchemaV1 validate function from the schema library) with the\n    // jsonSchema converter.\n    const existingStandard = schema['~standard'];\n    const enrichedStandard = { ...existingStandard, jsonSchema: converter };\n\n    // Override the prototype getter with an instance-level property.\n    // A Proxy wrapper was considered but JavaScript private fields (#field)\n    // are bound to the original class instance; when a method is invoked\n    // through a Proxy the receiver is the Proxy, not the real instance, so\n    // private-field access throws a TypeError. defineProperty avoids this\n    // because `this` inside methods still refers to the original schema.\n    Object.defineProperty(schema, '~standard', {\n        value: enrichedStandard,\n        configurable: true,\n        writable: false,\n        enumerable: false\n    });\n\n    return schema as T & StandardJSONSchemaV1;\n}\n"],"mappings":"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","names":["any","array","boolean","nul","number","object","string","tuple","union","fail","msg","ok","buildNode","s","node","b","buildEnum","buildConst","buildAnyOf","buildString","buildNumber","buildArray","buildObject","val","format","v","integer","min","max","elements","props","requiredSet","key","propNode","propBuilder","values","first","rest","options","opt","fromJsonSchema","schema","escapeRegex","s","convertNodeInner","schema","info","ext","readOnly","out","ver","convertNode","elements","props","outProps","required","key","propSchema","options","enumValues","allConst","opt","oi","toJsonSchema","opts","body","targetToOptions","target","withStandardJsonSchema","schema","converter","options","toJsonSchema","enrichedStandard"]}

package/dist/standardJsonSchema.d.ts

@@ -0,0 +1,31 @@
+import type { SchemaBuilder } from '@cleverbrush/schema';
+import type { StandardJSONSchemaV1 } from '@standard-schema/spec';
+/**
+ * Wraps a `@cleverbrush/schema` builder with the
+ * [Standard JSON Schema v1](https://standardschema.dev/) interface.
+ *
+ * The returned schema object's `~standard` property is enriched with a
+ * `jsonSchema` converter. Because `@cleverbrush/schema` does not
+ * distinguish between input and output types, both `input()` and `output()`
+ * produce the same JSON Schema document.
+ *
+ * **Note:** this mutates the schema instance by overriding the `~standard`
+ * property. The returned reference is the same schema object.
+ *
+ * @example
+ * ```ts
+ * import { object, string, number } from '@cleverbrush/schema';
+ * import { withStandardJsonSchema } from '@cleverbrush/schema-json';
+ *
+ * const schema = object({ name: string(), age: number().optional() });
+ * const wrapped = withStandardJsonSchema(schema);
+ *
+ * // Access standard JSON Schema properties
+ * wrapped['~standard'].jsonSchema.input({ target: 'draft-2020-12' });
+ * wrapped['~standard'].jsonSchema.output({ target: 'draft-07' });
+ * ```
+ *
+ * @param schema - Any `@cleverbrush/schema` builder instance.
+ * @returns The same schema instance, now also conforming to `StandardJSONSchemaV1`.
+ */
+export declare function withStandardJsonSchema<T extends SchemaBuilder<any, any, any, any, any>>(schema: T): T & StandardJSONSchemaV1;

package/dist/toJsonSchema.d.ts

@@ -0,0 +1,63 @@
+import type { SchemaBuilder } from '@cleverbrush/schema';
+import type { ToJsonSchemaOptions } from './types.js';
+/**
+ * Converts a `@cleverbrush/schema` builder to a JSON Schema object.
+ *
+ * @remarks
+ * **What round-trips cleanly**: all declarative constraints — type, format,
+ * minLength/maxLength, minimum/maximum, multipleOf, pattern, required/optional
+ * per property, additionalProperties, items, enum/const literals, anyOf/union.
+ *
+ * **What is silently omitted**:
+ * - Custom validators added via `addValidator` (no JSON Schema equivalent)
+ * - Preprocessors added via `addPreprocessor`
+ * - JSDoc comments on schema properties
+ * - `exclusiveMinimum`/`exclusiveMaximum` constraints from `fromJsonSchema`
+ *   (stored as custom validators — not introspectable; only `positive()`/
+ *   `negative()` extension-based exclusives are emitted)
+ * - IP format with both v4 _and_ v6 allowed simultaneously (no single
+ *   standard JSON Schema format covers both; the `format` keyword is omitted
+ *   in that case)
+ *
+ * By default the output includes a `$schema` header for JSON Schema Draft
+ * 2020-12. Pass `{ $schema: false }` when embedding the result in an OpenAPI
+ * specification, or `{ draft: '07' }` for Draft 07 compatibility.
+ *
+ * @param schema - Any `@cleverbrush/schema` builder instance.
+ * @param opts   - Optional output configuration (see {@link ToJsonSchemaOptions}).
+ * @returns A plain JSON-serialisable object representing the schema.
+ *
+ * @example
+ * ```ts
+ * import { toJsonSchema } from '@cleverbrush/schema-json';
+ * import { object, string, number } from '@cleverbrush/schema';
+ *
+ * const UserSchema = object({
+ *   name:  string().minLength(1),
+ *   email: string().email(),
+ *   age:   number().optional(),
+ * });
+ *
+ * const spec = toJsonSchema(UserSchema);
+ * // {
+ * //   "$schema": "https://json-schema.org/draft/2020-12/schema",
+ * //   "type": "object",
+ * //   "properties": {
+ * //     "name":  { "type": "string", "minLength": 1 },
+ * //     "email": { "type": "string", "format": "email" },
+ * //     "age":   { "type": "number" }
+ * //   },
+ * //   "required": ["name", "email"]
+ * // }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Embed in an OpenAPI spec (strip the $schema header)
+ * toJsonSchema(schema, { $schema: false });
+ *
+ * // Use JSON Schema Draft 07
+ * toJsonSchema(schema, { draft: '07' });
+ * ```
+ */
+export declare function toJsonSchema(schema: SchemaBuilder<any, any, any>, opts?: ToJsonSchemaOptions): Record<string, unknown>;

package/dist/types.d.ts

@@ -0,0 +1,257 @@
+/**
+ * Types for `@cleverbrush/schema-json`.
+ *
+ * @module
+ */
+import type { BooleanSchemaBuilder, ExtendedArray, ExtendedNumber, ExtendedString, ObjectSchemaBuilder, SchemaBuilder, UnionSchemaBuilder } from '@cleverbrush/schema';
+/**
+ * Subset of JSON Schema (Draft 7 / 2020-12) accepted as input.
+ *
+ * For accurate TypeScript type inference via {@link InferFromJsonSchema},
+ * pass schema literals with `as const`.
+ */
+export type JsonSchemaNode = {
+    readonly type: 'string';
+    readonly format?: string;
+    readonly minLength?: number;
+    readonly maxLength?: number;
+    readonly pattern?: string;
+    [k: string]: unknown;
+} | {
+    readonly type: 'number' | 'integer';
+    readonly minimum?: number;
+    readonly maximum?: number;
+    readonly exclusiveMinimum?: number;
+    readonly exclusiveMaximum?: number;
+    readonly multipleOf?: number;
+    [k: string]: unknown;
+} | {
+    readonly type: 'boolean';
+    [k: string]: unknown;
+} | {
+    readonly type: 'null';
+    [k: string]: unknown;
+} | {
+    readonly type: 'array';
+    readonly items?: JsonSchemaNode;
+    readonly minItems?: number;
+    readonly maxItems?: number;
+    [k: string]: unknown;
+} | {
+    readonly type: 'object';
+    readonly properties?: Readonly<Record<string, JsonSchemaNode>>;
+    readonly required?: readonly string[];
+    readonly additionalProperties?: boolean;
+    [k: string]: unknown;
+} | {
+    readonly const: unknown;
+    [k: string]: unknown;
+} | {
+    readonly enum: readonly unknown[];
+    [k: string]: unknown;
+} | {
+    readonly anyOf: readonly JsonSchemaNode[];
+    [k: string]: unknown;
+} | {
+    readonly allOf: readonly JsonSchemaNode[];
+    [k: string]: unknown;
+} | Record<string, never>;
+/**
+ * Recursively infers a TypeScript type from a statically-known JSON Schema node.
+ *
+ * Requires `as const` on the input object for precise inference —
+ * without it TypeScript widens string literals to `string` and inference
+ * collapses to `unknown`.
+ *
+ * @example
+ * ```ts
+ * type User = InferFromJsonSchema<typeof UserJsonSchema>;
+ * // { name: string; age?: number }
+ * ```
+ */
+export type InferFromJsonSchema<S> = S extends {
+    readonly const: infer V;
+} ? V : S extends {
+    readonly enum: readonly (infer V)[];
+} ? V : S extends {
+    readonly type: 'string';
+} ? string : S extends {
+    readonly type: 'number' | 'integer';
+} ? number : S extends {
+    readonly type: 'boolean';
+} ? boolean : S extends {
+    readonly type: 'null';
+} ? null : S extends {
+    readonly type: 'array';
+    readonly items: infer I;
+} ? InferFromJsonSchema<I>[] : S extends {
+    readonly type: 'array';
+} ? unknown[] : S extends {
+    readonly type: 'object';
+    readonly properties: infer P;
+    readonly required: readonly (infer R extends string)[];
+} ? {
+    [K in keyof P & string as K extends R ? K : never]: InferFromJsonSchema<P[K]>;
+} & {
+    [K in keyof P & string as K extends R ? never : K]?: InferFromJsonSchema<P[K]>;
+} : S extends {
+    readonly type: 'object';
+    readonly properties: infer P;
+} ? {
+    [K in keyof P]?: InferFromJsonSchema<P[K]>;
+} : S extends {
+    readonly type: 'object';
+} ? Record<string, unknown> : S extends {
+    readonly anyOf: readonly (infer U)[];
+} ? InferFromJsonSchema<U> : S extends {
+    readonly allOf: readonly JsonSchemaNode[];
+} ? unknown : unknown;
+/** Options accepted by {@link toJsonSchema}. */
+export type ToJsonSchemaOptions = {
+    /**
+     * JSON Schema draft version to reference in the `$schema` header.
+     * @default '2020-12'
+     */
+    draft?: '2020-12' | '07';
+    /**
+     * Whether to include the `$schema` header in the output.
+     * Set to `false` when embedding in an OpenAPI spec.
+     * @default true
+     */
+    $schema?: boolean;
+};
+/**
+ * Required variant: `ExtendedString<T>` (the return type of `string()`).
+ * Optional variant: `ReturnType<ExtendedString<T>['optional']>` (the return
+ * type of `string().optional()`).
+ * @internal
+ */
+type ExtendedStringBuilder<T extends string = string, TRequired extends boolean = true> = TRequired extends true ? ExtendedString<T> : ReturnType<ExtendedString<T>['optional']>;
+/**
+ * Required variant: `ExtendedNumber<T>` (the return type of `number()`).
+ * Optional variant: `ReturnType<ExtendedNumber<T>['optional']>` (the return
+ * type of `number().optional()`).
+ * @internal
+ */
+type ExtendedNumberBuilder<T extends number = number, TRequired extends boolean = true> = TRequired extends true ? ExtendedNumber<T> : ReturnType<ExtendedNumber<T>['optional']>;
+/**
+ * Required variant: `ExtendedArray<TElement>` (the return type of `array()`).
+ * Optional variant: `ReturnType<ExtendedArray<TElement>['optional']>` (the
+ * return type of `array().optional()`).
+ * @internal
+ */
+type ExtendedArrayBuilder<TElement extends SchemaBuilder<any, any, any> = SchemaBuilder<any, any, any>, TRequired extends boolean = true> = TRequired extends true ? ExtendedArray<TElement> : ReturnType<ExtendedArray<TElement>['optional']>;
+/**
+ * Maps a JSON Schema `const` value to the narrowest possible builder type.
+ * @internal
+ */
+type ConstToBuilder<V, TRequired extends boolean> = V extends string ? ExtendedStringBuilder<V, TRequired> : V extends number ? ExtendedNumberBuilder<V, TRequired> : V extends boolean ? BooleanSchemaBuilder<V, TRequired> : SchemaBuilder<V, TRequired>;
+/**
+ * Recursively maps a readonly tuple of `const`/`enum` values to a tuple of
+ * builders, preserving the exact literal types of each element.
+ * @internal
+ */
+type EnumTupleToBuilders<T extends readonly unknown[]> = T extends readonly [] ? [] : T extends readonly [infer First, ...infer Rest extends readonly unknown[]] ? [ConstToBuilder<First, true>, ...EnumTupleToBuilders<Rest>] : [SchemaBuilder<any, any, any>];
+/**
+ * Recursively maps a readonly tuple of JSON Schema nodes (e.g. an `anyOf`
+ * array) to a tuple of builders for use with `UnionSchemaBuilder`.
+ * @internal
+ */
+type SchemaNodesTupleToBuilders<T extends readonly unknown[]> = T extends readonly [] ? [] : T extends readonly [
+    infer First,
+    ...infer Rest extends readonly unknown[]
+] ? [
+    JsonSchemaNodeToBuilder<First, true>,
+    ...SchemaNodesTupleToBuilders<Rest>
+] : [SchemaBuilder<any, any, any>];
+/**
+ * Maps an object schema's `properties` record to the property-descriptor
+ * record that `ObjectSchemaBuilder` expects as its first type parameter.
+ *
+ * Properties present in the `required` array get `TRequired = true`;
+ * all others get `TRequired = false`.
+ * @internal
+ */
+type ObjectPropertiesToBuilders<P extends Record<string, unknown>, R extends string> = {
+    [K in keyof P as K extends R ? K : never]: JsonSchemaNodeToBuilder<P[K], true>;
+} & {
+    [K in keyof P as K extends R ? never : K]: JsonSchemaNodeToBuilder<P[K], false>;
+};
+/**
+ * Recursively maps a statically-known JSON Schema node (passed with
+ * `as const`) to the exact `@cleverbrush/schema` builder type, including:
+ *
+ * - `StringSchemaBuilder`, `NumberSchemaBuilder`, `BooleanSchemaBuilder`
+ *   for primitive types and `const` literals
+ * - `ArraySchemaBuilder<ElementBuilder>` with the element builder inferred
+ *   from `items`
+ * - `ObjectSchemaBuilder<PropertyDescriptors>` where each property is a
+ *   typed builder with `TRequired = true/false` driven by the `required`
+ *   array
+ * - `UnionSchemaBuilder<[...Builders]>` for `enum` and `anyOf`
+ *
+ * @typeParam S        - The JSON Schema node type (inferred from `as const`).
+ * @typeParam TRequired - Whether this node represents a required (`true`) or
+ *   optional (`false`) value in its parent context.  Defaults to `true`.
+ *
+ * @example
+ * ```ts
+ * import { fromJsonSchema } from '@cleverbrush/schema-json';
+ * import type { JsonSchemaNodeToBuilder } from '@cleverbrush/schema-json';
+ *
+ * const S = {
+ *   type: 'object',
+ *   properties: {
+ *     name:  { type: 'string' },
+ *     score: { type: 'number' },
+ *   },
+ *   required: ['name'],
+ * } as const;
+ *
+ * type Builder = JsonSchemaNodeToBuilder<typeof S>;
+ * // ObjectSchemaBuilder<
+ * //   { name: ExtendedStringBuilder<string, true> } &
+ * //   { score: ExtendedNumberBuilder<number, false> }
+ * // >
+ *
+ * const schema = fromJsonSchema(S);
+ * // TypeScript knows schema is ObjectSchemaBuilder<...>
+ * // with full intellisense on .parse(), .addProp(), etc.
+ * ```
+ */
+export type JsonSchemaNodeToBuilder<S, TRequired extends boolean = true> = S extends {
+    readonly const: infer V;
+} ? ConstToBuilder<V, TRequired> : S extends {
+    readonly enum: infer Vals extends readonly unknown[];
+} ? UnionSchemaBuilder<EnumTupleToBuilders<Vals>, TRequired> : S extends {
+    readonly anyOf: infer Opts extends readonly unknown[];
+} ? UnionSchemaBuilder<SchemaNodesTupleToBuilders<Opts>, TRequired> : S extends {
+    readonly allOf: infer _Opts extends readonly unknown[];
+} ? SchemaBuilder<unknown, TRequired> : S extends {
+    readonly type: 'string';
+} ? ExtendedStringBuilder<string, TRequired> : S extends {
+    readonly type: 'number';
+} ? ExtendedNumberBuilder<number, TRequired> : S extends {
+    readonly type: 'integer';
+} ? ExtendedNumberBuilder<number, TRequired> : S extends {
+    readonly type: 'boolean';
+} ? BooleanSchemaBuilder<boolean, TRequired> : S extends {
+    readonly type: 'null';
+} ? SchemaBuilder<null, TRequired> : S extends {
+    readonly type: 'array';
+    readonly items: infer I;
+} ? ExtendedArrayBuilder<JsonSchemaNodeToBuilder<I, true>, TRequired> : S extends {
+    readonly type: 'array';
+} ? ExtendedArrayBuilder<SchemaBuilder<unknown, true>, TRequired> : S extends {
+    readonly type: 'object';
+    readonly properties: infer P extends Record<string, unknown>;
+    readonly required: readonly (infer R extends string)[];
+} ? ObjectSchemaBuilder<ObjectPropertiesToBuilders<P, R>, TRequired> : S extends {
+    readonly type: 'object';
+    readonly properties: infer P extends Record<string, unknown>;
+} ? ObjectSchemaBuilder<{
+    [K in keyof P]: JsonSchemaNodeToBuilder<P[K], false>;
+}, TRequired> : S extends {
+    readonly type: 'object';
+} ? ObjectSchemaBuilder<{}, TRequired> : SchemaBuilder<unknown, TRequired>;
+export {};

package/package.json

@@ -0,0 +1,45 @@
+{
+    "author": "Andrew Zolotukhin <andrew_zol@cleverbrush.com>",
+    "bugs": {
+        "url": "https://github.com/cleverbrush/framework/issues",
+        "email": "andrew_zol@cleverbrush.com"
+    },
+    "description": "Bidirectional JSON Schema (Draft 7 / 2020-12) interop for @cleverbrush/schema",
+    "files": [
+        "dist"
+    ],
+    "homepage": "https://docs.cleverbrush.com/modules/_cleverbrush_schema-json.html",
+    "keywords": [
+        "json schema",
+        "schema",
+        "validation",
+        "cleverbrush"
+    ],
+    "license": "BSD 3-Clause",
+    "main": "./dist/index.js",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        }
+    },
+    "sideEffects": false,
+    "name": "@cleverbrush/schema-json",
+    "peerDependencies": {
+        "@cleverbrush/schema": "0.0.0-beta-20260410073748",
+        "@standard-schema/spec": "^1.1.0"
+    },
+    "readme": "https://github.com/cleverbrush/framework/tree/master/libs/schema-json#readme",
+    "repository": {
+        "type": "git",
+        "url": "github:cleverbrush/framework"
+    },
+    "scripts": {
+        "watch": "tsc --build --watch",
+        "build": "tsup && tsc --project tsconfig.build.json --emitDeclarationOnly",
+        "clean": "rm -rf dist tsconfig.tsbuildinfo"
+    },
+    "type": "module",
+    "types": "./dist/index.d.ts",
+    "version": "0.0.0-beta-20260410073748"
+}