@yuhere/js-jsonrpc2 2.1.12 → 2.1.14

package/dist/cli/cli.d.ts

@@ -1,3 +1,2 @@
 #!/usr/bin/env node
 export {};
-//# sourceMappingURL=cli.d.ts.map

package/dist/cli/cli.js

@@ -137,4 +137,3 @@ main().catch((err) => {
     console.error('启动失败：', err);
     process.exit(1);
 });
-//# sourceMappingURL=cli.js.map

package/dist/cli/demo-methods.d.ts

@@ -7,4 +7,3 @@ import type { Repository } from '../core/Repository.js';
  * 被 dev/express.ts 与 src/cli.ts 共用。
  */
 export declare function installDemoMethods(repository: Repository): void;
-//# sourceMappingURL=demo-methods.d.ts.map

package/dist/cli/demo-methods.js

@@ -473,4 +473,3 @@ export function installDemoMethods(repository) {
         }
     });
 }
-//# sourceMappingURL=demo-methods.js.map

package/dist/cli/express.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=express.d.ts.map

package/dist/cli/express.js

@@ -39,4 +39,3 @@ const port = Number(process.env['PORT'] ?? 5000);
 server.listen(port, () => {
     console.log(`js-jsonrpc2 debug server listening on http://localhost:${port}`);
 });
-//# sourceMappingURL=express.js.map

package/dist/cli/stdio.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=stdio.d.ts.map

package/dist/cli/stdio.js

@@ -2,4 +2,3 @@ import { createRepository, serveStdio, s } from '../index.js';
 const repository = createRepository();
 repository.register({ namespace: 'echo', signature: [s.string(), s.string()] }, (v) => v);
 await serveStdio({ repository, framing: 'lines' });
-//# sourceMappingURL=stdio.js.map

package/dist/core/Repository.d.ts

@@ -19,4 +19,3 @@ export declare class Repository {
 }
 export declare function createRepository(options?: RepositoryOptions): Repository;
 export type { MethodDescriptor };
-//# sourceMappingURL=Repository.d.ts.map

package/dist/core/Repository.js

@@ -297,4 +297,3 @@ export class Repository {
 export function createRepository(options = {}) {
     return new Repository(options);
 }
-//# sourceMappingURL=Repository.js.map

package/dist/core/convert.d.ts

@@ -1,4 +1,3 @@
 import type { MethodDescriptor } from './descriptor.js';
 import type { Injections } from '../types.js';
 export declare function convertParams(descriptor: MethodDescriptor, params: unknown, injections: Injections): Promise<unknown[]>;
-//# sourceMappingURL=convert.d.ts.map

package/dist/core/convert.js

@@ -26,4 +26,3 @@ export async function convertParams(descriptor, params, injections) {
     }
     return converted;
 }
-//# sourceMappingURL=convert.js.map

package/dist/core/descriptor.d.ts

@@ -24,4 +24,3 @@ export declare function buildDescriptor(descriptor: RPCDescriptor, fn: RPCHandle
 export declare function signatureOf(descriptor: MethodDescriptor): unknown[];
 export declare function lookup(methods: Map<string, MethodDescriptor>, method: string): MethodDescriptor;
 export declare function invalidParams(message: string, data?: unknown): RPCError;
-//# sourceMappingURL=descriptor.d.ts.map

package/dist/core/descriptor.js

@@ -80,4 +80,3 @@ export function lookup(methods, method) {
 export function invalidParams(message, data) {
     return new RPCError(INVALID_PARAMS, message, data);
 }
-//# sourceMappingURL=descriptor.js.map

package/dist/core/index.d.ts

@@ -1,4 +1,3 @@
 export { Repository, createRepository } from './Repository.js';
 export type { MethodDescriptor } from './descriptor.js';
 export { validateRequest } from './spec-check.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/core/index.js

@@ -1,3 +1,2 @@
 export { Repository, createRepository } from './Repository.js';
 export { validateRequest } from './spec-check.js';
-//# sourceMappingURL=index.js.map

package/dist/core/llm-tools.d.ts

@@ -22,4 +22,3 @@ export interface JSONSchema {
 }
 export declare function listLlmTools(repository: Repository, injections: Injections, rawOptions?: unknown): Promise<LlmTools>;
 export declare function invokeLlmTool(repository: Repository, call: LlmToolCall, injections: Injections): Promise<unknown>;
-//# sourceMappingURL=llm-tools.d.ts.map

package/dist/core/llm-tools.js

@@ -50,12 +50,12 @@ function convert(desc) {
                 out.minItems = c.min;
             if (c.max !== undefined)
                 out.maxItems = c.max;
-            out.items = convert(desc.children.items);
+            out.items = convert(desc.element);
             break;
         }
         case 'tuple': {
             out.type = 'array';
-            const items = desc.children.items;
+            const items = desc.elements;
             out.items = items.map(convert);
             out.minItems = items.length;
             out.maxItems = items.length;
@@ -63,19 +63,19 @@ function convert(desc) {
         }
         case 'object': {
             out.type = 'object';
-            const strict = Boolean(desc.constraints.strict);
-            const props = desc.children
-                .properties;
+            const optional = new Set((desc.constraints
+                ?.optionalProps) ?? []);
+            const allowUnknown = (desc.constraints
+                ?.allowUnknownProps) ?? true;
+            const props = desc.properties;
             out.properties = {};
             for (const [k, v] of Object.entries(props))
                 out.properties[k] = convert(v);
-            if (strict) {
-                out.required = Object.keys(props);
+            const required = Object.keys(props).filter((k) => !optional.has(k));
+            if (required.length > 0)
+                out.required = required;
+            if (!allowUnknown)
                 out.additionalProperties = false;
-            }
-            else {
-                out.additionalProperties = true;
-            }
             break;
         }
         case 'record': {
@@ -85,12 +85,11 @@ function convert(desc) {
                 out.minProperties = c.min;
             if (c.max !== undefined)
                 out.maxProperties = c.max;
-            out.additionalProperties = convert(desc.children.values);
+            out.additionalProperties = convert(desc.value);
             break;
         }
         case 'union': {
-            const options = desc.children.options;
-            out.anyOf = options.map(convert);
+            out.anyOf = desc.options.map(convert);
             break;
         }
         case 'unknown': {
@@ -101,8 +100,10 @@ function convert(desc) {
             out.type = 'null';
             break;
         }
-        default:
-            throw new Error(`Unsupported schema kind for JSON Schema: ${desc.kind}`);
+        default: {
+            const _exhaustive = desc;
+            throw new Error(`Unsupported schema kind for JSON Schema: ${JSON.stringify(_exhaustive)}`);
+        }
     }
     if (desc.nullable) {
         if (desc.kind === 'unknown' || desc.kind === 'null') {
@@ -150,7 +151,6 @@ function renderSchema(schema, indent = 0) {
     if (c)
         head += ` \`${c}\``;
     lines.push(head);
-    const ch = schema.children ?? {};
     const pushChild = (label, child) => {
         const sub = renderSchema(child, indent + 1);
         if (sub.length) {
@@ -158,36 +158,35 @@ function renderSchema(schema, indent = 0) {
             lines.push(...sub);
         }
     };
-    if (isSchema(ch.inner))
-        pushChild('inner', ch.inner);
-    if (Array.isArray(ch.items)) {
-        ch.items.forEach((it, i) => {
-            if (isSchema(it))
-                pushChild(`[${i}]`, it);
-        });
-    }
-    else if (isSchema(ch.items)) {
-        pushChild('items', ch.items);
-    }
-    if (Array.isArray(ch.options)) {
-        ch.options.forEach((opt, i) => {
-            if (isSchema(opt))
-                pushChild(`option[${i}]`, opt);
-        });
-    }
-    if (ch.properties && typeof ch.properties === 'object') {
-        for (const [k, v] of Object.entries(ch.properties)) {
-            if (isSchema(v))
+    switch (schema.kind) {
+        case 'array': {
+            pushChild('element', schema.element);
+            break;
+        }
+        case 'record': {
+            pushChild('value', schema.value);
+            break;
+        }
+        case 'object': {
+            for (const [k, v] of Object.entries(schema.properties)) {
                 pushChild(k, v);
+            }
+            break;
+        }
+        case 'union': {
+            schema.options.forEach((opt, i) => pushChild(`option[${i}]`, opt));
+            break;
         }
+        case 'tuple': {
+            schema.elements.forEach((it, i) => pushChild(`[${i}]`, it));
+            break;
+        }
+        default:
+            // 叶子类型：无子节点。
+            break;
     }
-    if (isSchema(ch.values))
-        pushChild('values', ch.values);
     return lines;
 }
-function isSchema(v) {
-    return !!v && typeof v === 'object' && typeof v.kind === 'string';
-}
 /** 渲染返回值槽位（Schema / VoidMarker / StreamMarker）。 */
 function renderReturnSlot(slot) {
     if (slot instanceof VoidMarker)
@@ -309,4 +308,3 @@ export async function invokeLlmTool(repository, call, injections) {
         })();
     }
 }
-//# sourceMappingURL=llm-tools.js.map

package/dist/core/permission.d.ts

@@ -2,4 +2,3 @@ import type { MethodDescriptor } from './descriptor.js';
 import type { Injections } from '../types.js';
 export declare function checkPermission(descriptor: MethodDescriptor, injections: Injections): Promise<void>;
 export declare function assertAccessible(descriptor: MethodDescriptor, injections: Injections): Promise<void>;
-//# sourceMappingURL=permission.d.ts.map

package/dist/core/permission.js

@@ -26,4 +26,3 @@ export async function assertAccessible(descriptor, injections) {
         throw error;
     }
 }
-//# sourceMappingURL=permission.js.map

package/dist/core/spec-check.d.ts

@@ -1,3 +1,2 @@
 import type { RPCRequestInput } from '../types.js';
 export declare function validateRequest(input: unknown): RPCRequestInput;
-//# sourceMappingURL=spec-check.d.ts.map

package/dist/core/spec-check.js

@@ -8,4 +8,3 @@ export function validateRequest(input) {
     }
     return result.data;
 }
-//# sourceMappingURL=spec-check.js.map

package/dist/core/system-methods.d.ts

@@ -1,3 +1,2 @@
 import type { Repository } from './Repository.js';
 export declare function registerSystemMethods(repository: Repository): void;
-//# sourceMappingURL=system-methods.d.ts.map

package/dist/core/system-methods.js

@@ -111,4 +111,3 @@ export function registerSystemMethods(repository) {
         return repository.listLlmTools(injections, rawOptions);
     });
 }
-//# sourceMappingURL=system-methods.js.map

package/dist/errors/RPCError.d.ts

@@ -6,4 +6,3 @@ export declare class RPCError extends Error {
     toPayload(): RPCErrorPayload;
     toJSON(): RPCErrorPayload;
 }
-//# sourceMappingURL=RPCError.d.ts.map

package/dist/errors/RPCError.js

@@ -20,4 +20,3 @@ export class RPCError extends Error {
         return this.toPayload();
     }
 }
-//# sourceMappingURL=RPCError.js.map

package/dist/errors/codes.d.ts

@@ -4,4 +4,3 @@ export declare const METHOD_NOT_FOUND = -32601;
 export declare const INVALID_PARAMS = -32602;
 export declare const INTERNAL_ERROR = -32603;
 export declare const PERMISSION_DENIED = -32604;
-//# sourceMappingURL=codes.d.ts.map

package/dist/errors/codes.js

@@ -4,4 +4,3 @@ export const METHOD_NOT_FOUND = -32601;
 export const INVALID_PARAMS = -32602;
 export const INTERNAL_ERROR = -32603;
 export const PERMISSION_DENIED = -32604;
-//# sourceMappingURL=codes.js.map

package/dist/errors/index.d.ts

@@ -1,3 +1,2 @@
 export { RPCError } from './RPCError.js';
 export * from './codes.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/errors/index.js

@@ -1,3 +1,2 @@
 export { RPCError } from './RPCError.js';
 export * from './codes.js';
-//# sourceMappingURL=index.js.map

package/dist/index.d.ts

@@ -15,4 +15,3 @@ export { attachWebSocket, createWebSocketServer, serveStdio };
 export type { WSOptions, StandaloneWsOptions, StandaloneWsHandle } from './transport/ws/index.js';
 export type { StdioOptions } from './transport/stdio/index.js';
 export type { ExpressOptions } from './transport/express/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -14,4 +14,3 @@ export { createExpressRouter };
 import { attachWebSocket, createWebSocketServer } from './transport/ws/index.js';
 import { serveStdio } from './transport/stdio/index.js';
 export { attachWebSocket, createWebSocketServer, serveStdio };
-//# sourceMappingURL=index.js.map

package/dist/metrics/memory.d.ts

@@ -56,4 +56,3 @@ export interface MemoryMetrics extends RPCMetrics {
     reset(): void;
 }
 export declare function createMemoryMetrics(options?: MemoryMetricsOptions): MemoryMetrics;
-//# sourceMappingURL=memory.d.ts.map

package/dist/metrics/memory.js

@@ -185,4 +185,3 @@ export function createMemoryMetrics(options = {}) {
         },
     };
 }
-//# sourceMappingURL=memory.js.map

package/dist/metrics/prom.d.ts

@@ -1 +0,0 @@
-//# sourceMappingURL=prom.d.ts.map

package/dist/metrics/prom.js

@@ -102,4 +102,3 @@
 //         },
 //     };
 // }
-//# sourceMappingURL=prom.js.map

package/dist/schema/json/index.d.ts

@@ -6,7 +6,7 @@ export declare const s: {
     boolean: () => import("./primitives.js").BooleanSchema;
     literal: <const T extends import("./primitives.js").LiteralValue>(value: T) => import("./primitives.js").LiteralSchema<T>;
     array: <T>(item: import("./primitives.js").Schema<T>) => import("./primitives.js").ArraySchema<T>;
-    object: <S extends import("./primitives.js").ObjectShape>(shape: S) => import("./primitives.js").ObjectSchema<S, false>;
+    object: <S extends import("./primitives.js").ObjectShape>(shape: S) => import("./primitives.js").ObjectSchema<S>;
     record: <T>(value: import("./primitives.js").Schema<T>) => import("./primitives.js").RecordSchema<T>;
     union: <const S extends readonly [import("./primitives.js").Schema<unknown>, ...import("./primitives.js").Schema<unknown>[]]>(schemas: S) => import("./primitives.js").UnionSchema<S>;
     tuple: <const S extends readonly [import("./primitives.js").Schema<unknown>, ...import("./primitives.js").Schema<unknown>[]]>(schemas: S) => import("./primitives.js").TupleSchema<S>;
@@ -17,4 +17,3 @@ export declare const s: {
     injectable: <const K extends string>(key: K) => import("./marker.js").InjectableMarker<K>;
     stream: <T>(inner: import("./primitives.js").Schema<T>) => import("./marker.js").StreamMarker<T>;
 };
-//# sourceMappingURL=index.d.ts.map

package/dist/schema/json/index.js

@@ -3,4 +3,3 @@ import { markers } from "./marker.js";
 export * from "./primitives.js";
 export * from "./marker.js";
 export const s = { ...primitives, ...markers };
-//# sourceMappingURL=index.js.map

package/dist/schema/json/marker.d.ts

@@ -20,4 +20,3 @@ export declare const markers: {
     injectable: <const K extends string>(key: K) => InjectableMarker<K>;
     stream: <T>(inner: Schema<T>) => StreamMarker<T>;
 };
-//# sourceMappingURL=marker.d.ts.map

package/dist/schema/json/marker.js

@@ -24,4 +24,3 @@ export const markers = {
     injectable: (key) => new InjectableMarker(key),
     stream: (inner) => new StreamMarker(inner),
 };
-//# sourceMappingURL=marker.js.map

package/dist/schema/json/primitives.d.ts

@@ -9,20 +9,36 @@ export type JSONValue = JSONPrimitive | JSONValue[] | {
     [key: string]: JSONValue;
 };
 export type SchemaKind = string;
-export interface SchemaDescription {
+export interface BaseSchemaDescription {
     kind: SchemaKind;
     description?: string;
-    /**
-     * 该值是否允许为 null。
-     *
-     * 唯一真相来源：由 `NullableSchema` 及其子类通过 `.nullable(bool)` 设置，
-     * `UnknownSchema` / `NullSchema` 不使用该字段（它们本身就接受 null）。
-     * `kind` 永远表示值的真实形状，不会被 nullability 污染。
-     */
     nullable?: boolean;
     constraints?: Record<string, unknown>;
-    children?: Record<string, unknown>;
 }
+export interface LeafSchemaDescription extends BaseSchemaDescription {
+    kind: "string" | "number" | "boolean" | "literal" | "enum" | "unknown" | "null";
+}
+export interface ObjectSchemaDescription extends BaseSchemaDescription {
+    kind: "object";
+    properties: Record<string, SchemaDescription>;
+}
+export interface ArraySchemaDescription extends BaseSchemaDescription {
+    kind: "array";
+    element: SchemaDescription;
+}
+export interface RecordSchemaDescription extends BaseSchemaDescription {
+    kind: "record";
+    value: SchemaDescription;
+}
+export interface UnionSchemaDescription extends BaseSchemaDescription {
+    kind: "union";
+    options: SchemaDescription[];
+}
+export interface TupleSchemaDescription extends BaseSchemaDescription {
+    kind: "tuple";
+    elements: SchemaDescription[];
+}
+export type SchemaDescription = LeafSchemaDescription | ObjectSchemaDescription | ArraySchemaDescription | RecordSchemaDescription | UnionSchemaDescription | TupleSchemaDescription;
 export declare class SchemaValidationError extends Error {
     readonly path: string[];
     constructor(message: string, path?: string[]);
@@ -36,14 +52,13 @@ export declare class SchemaValidationError extends Error {
  */
 export declare abstract class Schema<T> {
     abstract readonly kind: SchemaKind;
-    private description?;
-    constructor(description?: string);
+    private description;
     describe(description: string): this;
     /**
      * 创建保留原型和现有字段的新实例，供不可变链式方法使用。
      */
     protected cloneWith(updates: Record<string, unknown>): this;
-    getDescription(): string | undefined;
+    getDescription(): string;
     parse(input: unknown): T;
     safeParse(input: unknown): {
         success: true;
@@ -84,7 +99,7 @@ export declare class StringSchema<K extends string = "string"> extends NullableS
     min(value: number): this;
     max(value: number): this;
     protected _parseValue(input: unknown, path: string[]): string;
-    protected _describe(): SchemaDescription;
+    protected _describe(): LeafSchemaDescription;
     protected validateBound(value: number): void;
 }
 export declare class NumberSchema extends NullableSchema<number> {
@@ -95,28 +110,22 @@ export declare class NumberSchema extends NullableSchema<number> {
     min(value: number): this;
     max(value: number): this;
     protected _parseValue(input: unknown, path: string[]): number;
-    protected _describe(): SchemaDescription;
+    protected _describe(): LeafSchemaDescription;
     protected validateBound(value: number): void;
 }
 export declare class BooleanSchema extends NullableSchema<boolean> {
     readonly kind: "boolean";
     constructor();
     protected _parseValue(input: unknown, path: string[]): boolean;
-    protected _describe(): SchemaDescription;
+    protected _describe(): LeafSchemaDescription;
 }
-/**
- * 字面量只支持 string / number / boolean。
- *
- * null 由 `s.null()` 表达；需要「该字面量或 null」时，对字面量调用
- * `.nullable()`。`literal(null)` 会抛 TypeError。
- */
 export type LiteralValue = string | number | boolean;
 export declare class LiteralSchema<const T extends LiteralValue> extends NullableSchema<T> {
     private readonly expected;
     readonly kind: "literal";
     constructor(expected: T);
     protected _parseValue(input: unknown, path: string[]): T;
-    protected _describe(): SchemaDescription;
+    protected _describe(): LeafSchemaDescription;
 }
 export declare class ArraySchema<T> extends NullableSchema<T[]> {
     private readonly itemSchema;
@@ -127,28 +136,25 @@ export declare class ArraySchema<T> extends NullableSchema<T[]> {
     min(value: number): this;
     max(value: number): this;
     protected _parseValue(input: unknown, path: string[]): T[];
-    protected _describe(): SchemaDescription;
+    protected _describe(): ArraySchemaDescription;
     protected validateBound(value: number): void;
 }
 export type ObjectShape = Record<string, Schema<unknown>>;
 type SchemaValue<S> = S extends Schema<infer T> ? T : never;
-type ShapeOutput<S extends ObjectShape> = {
-    [K in keyof S]: SchemaValue<S[K]>;
-};
-type OptionalShapeOutput<S extends ObjectShape> = {
+export type ObjectOutput<S extends ObjectShape> = {
     [K in keyof S]?: SchemaValue<S[K]>;
 };
-export declare class ObjectSchema<S extends ObjectShape, Strict extends boolean = false> extends NullableSchema<Strict extends true ? ShapeOutput<S> : OptionalShapeOutput<S>> {
+export declare class ObjectSchema<S extends ObjectShape> extends NullableSchema<ObjectOutput<S>> {
     private readonly shape;
     readonly kind: "object";
-    private isStrict;
-    constructor(shape: S, strict?: Strict, description?: string);
-    /**
-     * strict() 要求所有声明属性存在，并拒绝未声明属性。
-     */
-    strict(): ObjectSchema<S, true>;
-    protected _parseValue(input: unknown, path: string[]): Strict extends true ? ShapeOutput<S> : OptionalShapeOutput<S>;
-    protected _describe(): SchemaDescription;
+    private optionalProps;
+    private allowUnknownProps;
+    constructor(shape: S);
+    optionalProperties(keys: string[]): this;
+    allowUnknownProperties(value?: boolean): this;
+    strict(value?: boolean): this;
+    protected _parseValue(input: unknown, path: string[]): ObjectOutput<S>;
+    protected _describe(): ObjectSchemaDescription;
 }
 export declare class RecordSchema<T> extends NullableSchema<Record<string, T>> {
     private readonly valueSchema;
@@ -159,68 +165,42 @@ export declare class RecordSchema<T> extends NullableSchema<Record<string, T>> {
     min(value: number): this;
     max(value: number): this;
     protected _parseValue(input: unknown, path: string[]): Record<string, T>;
-    protected _describe(): SchemaDescription;
+    protected _describe(): RecordSchemaDescription;
     protected validateBound(value: number): void;
 }
-/**
- * 联合。
- *
- * 传入的 member schemas 会被 clone 并 `nullable(false)`——因为「某个
- * 分支允许 null」这件事在 union 层面没有意义：null 是否允许应通过
- * `union(...).nullable()` 统一表达。
- */
 export declare class UnionSchema<const S extends readonly [Schema<unknown>, ...Schema<unknown>[]]> extends NullableSchema<SchemaValue<S[number]>> {
     readonly kind: "union";
     private readonly options;
     constructor(schemas: S);
     protected _parseValue(input: unknown, path: string[]): SchemaValue<S[number]>;
-    protected _describe(): SchemaDescription;
+    protected _describe(): UnionSchemaDescription;
 }
 export declare class TupleSchema<const S extends readonly [Schema<unknown>, ...Schema<unknown>[]]> extends NullableSchema<SchemaValue<S[number]>[]> {
     private readonly schemas;
     readonly kind: "tuple";
     constructor(schemas: S);
     protected _parseValue(input: unknown, path: string[]): SchemaValue<S[number]>[];
-    protected _describe(): SchemaDescription;
+    protected _describe(): TupleSchemaDescription;
 }
-/**
- * 字符串枚举。
- *
- * 继承 `NullableSchema`，因此可以 `s.enum([...]).nullable()`；
- * 它不包含嵌套 schema，所以不需要像 union 那样处理成员 nullability。
- */
 export declare class EnumSchema<const T extends readonly [string, ...string[]]> extends NullableSchema<T[number]> {
     private readonly values;
     readonly kind: "enum";
     private readonly allowedValues;
     constructor(values: T);
     protected _parseValue(input: unknown, path: string[]): T[number];
-    protected _describe(): SchemaDescription;
+    protected _describe(): LeafSchemaDescription;
 }
-/**
- * 校验任意 JSON 值。
- *
- * 不允许 undefined、非有限数字、循环引用等非 JSON 数据。
- * null 本身就在接受范围内，因此不继承 `NullableSchema`，也不提供
- * `.nullable()`——那是冗余的。
- */
 export declare class UnknownSchema extends Schema<JSONValue> {
     readonly kind: "unknown";
     constructor();
     protected _parse(input: unknown, path: string[]): JSONValue;
-    protected _describe(): SchemaDescription;
+    protected _describe(): LeafSchemaDescription;
 }
-/**
- * 精确的 null 值。
- *
- * 与 `UnknownSchema` 一样天然表达 null，不需要 `.nullable()`。
- * 想表达「某类型或 null」用 `.nullable()`；想表达「就是 null」用 `s.null()`。
- */
 export declare class NullSchema extends Schema<null> {
     readonly kind: "null";
     constructor();
     protected _parse(input: unknown, path: string[]): null;
-    protected _describe(): SchemaDescription;
+    protected _describe(): LeafSchemaDescription;
 }
 export type Infer<T extends Schema<unknown>> = T extends Schema<infer U> ? U : never;
 export declare const primitives: {
@@ -229,7 +209,7 @@ export declare const primitives: {
     boolean: () => BooleanSchema;
     literal: <const T extends LiteralValue>(value: T) => LiteralSchema<T>;
     array: <T>(item: Schema<T>) => ArraySchema<T>;
-    object: <S extends ObjectShape>(shape: S) => ObjectSchema<S, false>;
+    object: <S extends ObjectShape>(shape: S) => ObjectSchema<S>;
     record: <T>(value: Schema<T>) => RecordSchema<T>;
     union: <const S extends readonly [Schema<unknown>, ...Schema<unknown>[]]>(schemas: S) => UnionSchema<S>;
     tuple: <const S extends readonly [Schema<unknown>, ...Schema<unknown>[]]>(schemas: S) => TupleSchema<S>;
@@ -238,4 +218,3 @@ export declare const primitives: {
     null: () => NullSchema;
 };
 export {};
-//# sourceMappingURL=primitives.d.ts.map