@atproto/lex-schema 0.0.12 → 0.0.14

package/src/schema/string.test.ts

@@ -1,5 +1,6 @@
-import { describe, expect, it } from 'vitest'
-import { string } from './string.js'
+import { describe, expect, expectTypeOf, it } from 'vitest'
+import { Infer, UnknownString } from '../core.js'
+import { StringSchemaOptions, string } from './string.js'
 import { token } from './token.js'
 import { withDefault } from './with-default.js'
 
@@ -610,4 +611,100 @@ describe('StringSchema', () => {
       expect(result.success).toBe(true)
     })
   })
+
+  describe('knownValues option', () => {
+    it('allows omitting knownValues at runtime', () => {
+      string<{ knownValues: ['active', 'inactive'] }>()
+
+      // @ts-expect-error format requires options to be set
+      string<{ knownValues: ['active', 'inactive']; format: 'did' }>()
+
+      // @ts-expect-error any options, besides knownValues, must be provided
+      string<{ knownValues: ['active', 'inactive']; minLength: 5 }>()
+
+      string<{
+        knownValues: ['john.doe', 'someone.else']
+        format: 'handle'
+      }>({
+        format: 'handle',
+      })
+
+      string<{
+        knownValues: ['john.doe', 'someone.else']
+      }>({
+        // Being *more* precise than the generic if fine
+        format: 'handle',
+      })
+
+      string<{
+        knownValues: ['did', 'inactive']
+        format: 'did'
+      }>({
+        // @ts-expect-error does not match format form generic constraint
+        format: 'handle',
+      })
+
+      string<{
+        knownValues: ['active', 'inactive']
+        minLength: 10
+      }>({
+        minLength: 10,
+      })
+
+      string<{
+        knownValues: ['active', 'inactive']
+        minLength: 5
+      }>({
+        // @ts-expect-error mismatch
+        minLength: 10,
+      })
+    })
+  })
+
+  it('properly types knownValues in parameters', () => {
+    const schema = string({
+      knownValues: ['active', 'inactive'],
+    })
+    type SchemaType = Infer<typeof schema>
+    expectTypeOf<{
+      foo: SchemaType
+    }>().toMatchObjectType<{
+      foo: 'active' | 'inactive' | UnknownString
+    }>()
+    expectTypeOf<{
+      foo: SchemaType
+    }>().not.toMatchObjectType<{
+      foo: string
+    }>()
+    expectTypeOf<{
+      foo: SchemaType
+    }>().not.toMatchObjectType<{
+      foo: 'active' | 'inactive'
+    }>()
+    expectTypeOf<{
+      foo: SchemaType
+    }>().not.toMatchObjectType<{
+      foo: UnknownString
+    }>()
+  })
+
+  it('type string<any>() as string', () => {
+    const schema = string<any>()
+    type SchemaType = Infer<typeof schema>
+    expectTypeOf<{
+      foo: SchemaType
+    }>().toMatchObjectType<{
+      foo: string
+    }>()
+  })
+
+  it('type string<StringSchemaOptions>({}) as string', () => {
+    const schema = string<StringSchemaOptions>({})
+    type SchemaType = Infer<typeof schema>
+    expectTypeOf<{
+      foo: SchemaType
+    }>().toMatchObjectType<{
+      foo: string
+    }>()
+  })
 })

package/src/schema/string.ts

@@ -1,11 +1,14 @@
 import { graphemeLen, ifCid, utf8Len } from '@atproto/lex-data'
 import {
   InferStringFormat,
+  Restricted,
   Schema,
   StringFormat,
+  UnknownString,
   ValidationContext,
   isStringFormat,
 } from '../core.js'
+import { IfAny } from '../util/if-any.js'
 import { memoizedOptions } from '../util/memoize.js'
 import { TokenSchema } from './token.js'
 
@@ -13,6 +16,7 @@ import { TokenSchema } from './token.js'
  * Configuration options for string schema validation.
  *
  * @property format - Expected string format (e.g., 'datetime', 'uri', 'at-uri', 'did', 'handle', 'nsid', 'cid', 'tid', 'record-key', 'at-identifier', 'language')
+ * @property knownValues - Known string literal values for type narrowing
  * @property minLength - Minimum length in UTF-8 bytes
  * @property maxLength - Maximum length in UTF-8 bytes
  * @property minGraphemes - Minimum number of grapheme clusters
@@ -20,6 +24,7 @@ import { TokenSchema } from './token.js'
  */
 export type StringSchemaOptions = {
   format?: StringFormat
+  knownValues?: readonly string[]
   minLength?: number
   maxLength?: number
   minGraphemes?: number
@@ -43,30 +48,46 @@ export type StringSchemaOptions = {
 export class StringSchema<
   const TOptions extends StringSchemaOptions = StringSchemaOptions,
 > extends Schema<
-  TOptions extends { format: infer F extends StringFormat }
-    ? InferStringFormat<F>
-    : string
+  IfAny<
+    TOptions,
+    string,
+    TOptions extends { format: infer F extends StringFormat }
+      ? InferStringFormat<F>
+      : TOptions extends { knownValues: readonly (infer V extends string)[] }
+        ? V | UnknownString
+        : string
+  >
 > {
-  constructor(readonly options?: TOptions) {
+  readonly type = 'string' as const
+
+  // @NOTE since the _string utility allows omitting knownValues when TOptions
+  // *does* include it (since it's only used for typing), we cannot type options
+  // as TOptions directly since it may not actually include knownValues at
+  // runtime, making schema.options.knownValues potentially undefined even when
+  // TOptions includes it.
+  readonly options: StringSchemaOptions
+
+  constructor(options: TOptions) {
     super()
+    this.options = options
   }
 
   validateInContext(input: unknown, ctx: ValidationContext) {
     const str = coerceToString(input)
     if (str == null) {
-      return ctx.issueInvalidType(input, 'string')
+      return ctx.issueUnexpectedType(input, 'string')
     }
 
     let lazyUtf8Len: number
 
-    const minLength = this.options?.minLength
+    const minLength = this.options.minLength
     if (minLength != null) {
       if ((lazyUtf8Len ??= utf8Len(str)) < minLength) {
         return ctx.issueTooSmall(str, 'string', minLength, lazyUtf8Len)
       }
     }
 
-    const maxLength = this.options?.maxLength
+    const maxLength = this.options.maxLength
     if (maxLength != null) {
       // Optimization: we can avoid computing the UTF-8 length if the maximum
       // possible length, in bytes, of the input JS string is smaller than the
@@ -80,7 +101,7 @@ export class StringSchema<
 
     let lazyGraphLen: number
 
-    const minGraphemes = this.options?.minGraphemes
+    const minGraphemes = this.options.minGraphemes
     if (minGraphemes != null) {
       // Optimization: avoid counting graphemes if the length check already fails
       if (str.length < minGraphemes) {
@@ -90,14 +111,14 @@ export class StringSchema<
       }
     }
 
-    const maxGraphemes = this.options?.maxGraphemes
+    const maxGraphemes = this.options.maxGraphemes
     if (maxGraphemes != null) {
       if ((lazyGraphLen ??= graphemeLen(str)) > maxGraphemes) {
         return ctx.issueTooBig(str, 'grapheme', maxGraphemes, lazyGraphLen)
       }
     }
 
-    const format = this.options?.format
+    const format = this.options.format
     if (format != null && !isStringFormat(str, format)) {
       return ctx.issueInvalidFormat(str, format)
     }
@@ -146,6 +167,32 @@ export function coerceToString(input: unknown): string | null {
   }
 }
 
+function _string(): StringSchema<NonNullable<unknown>>
+function _string<
+  // Allow calling `string<{ knownValues: [...] }>()` without passing an options
+  // object, since knownValues is only used for typing and has no runtime
+  // effect, so it can be safely omitted at runtime.
+  const TOptions extends {
+    knownValues: StringSchemaOptions['knownValues']
+  } & {
+    [K in Exclude<
+      keyof StringSchemaOptions,
+      'knownValues'
+    >]?: Restricted<`An options argument is required when using the "${K}" option`>
+  },
+>(): StringSchema<
+  IfAny<TOptions, any, { knownValues: TOptions['knownValues'] }>
+>
+function _string<const TOptions extends StringSchemaOptions>(
+  // If TOptions is explicitly provided (e.g. `string<{ ... }>({ ... })`), we
+  // allow the actual options argument to omit the "knownValues" property since
+  // it's only used for inferring the type and has no runtime effect.
+  options: TOptions | Omit<TOptions, 'knownValues'>,
+): StringSchema<TOptions>
+function _string(options: StringSchemaOptions = {}) {
+  return new StringSchema(options)
+}
+
 /**
  * Creates a string schema with optional format and length constraints.
  *
@@ -173,8 +220,4 @@ export function coerceToString(input: unknown): string | null {
  * const handleSchema = l.string({ format: 'handle', minLength: 3, maxLength: 253 })
  * ```
  */
-export const string = /*#__PURE__*/ memoizedOptions(function <
-  const O extends StringSchemaOptions = NonNullable<unknown>,
->(options?: StringSchemaOptions & O) {
-  return new StringSchema<O>(options)
-})
+export const string = /*#__PURE__*/ memoizedOptions(_string)

package/src/schema/token.ts

@@ -18,6 +18,8 @@ import { $type, NsidString, Schema, ValidationContext } from '../core.js'
 export class TokenSchema<
   const TValue extends string = string,
 > extends Schema<TValue> {
+  readonly type = 'token' as const
+
   constructor(readonly value: TValue) {
     super()
   }
@@ -34,7 +36,7 @@ export class TokenSchema<
     }
 
     if (typeof input !== 'string') {
-      return ctx.issueInvalidType(input, 'token')
+      return ctx.issueUnexpectedType(input, 'token')
     }
 
     return ctx.issueInvalidValue(input, [this.value])

package/src/schema/typed-object.test.ts

@@ -332,6 +332,44 @@ describe('TypedObjectSchema', () => {
     })
   })
 
+  describe('bound $ methods', () => {
+    it('$build can be used as a detached function', () => {
+      const { $build } = schema
+      const result = $build({ text: 'Hello' })
+      expect(result).toEqual({
+        text: 'Hello',
+        $type: 'app.bsky.feed.post',
+      })
+    })
+
+    it('$isTypeOf can be used as a detached function', () => {
+      const { $isTypeOf } = schema
+      expect($isTypeOf({ text: 'Hello' })).toBe(true)
+      expect($isTypeOf({ $type: 'app.bsky.feed.post', text: 'Hello' })).toBe(
+        true,
+      )
+      expect($isTypeOf({ $type: 'other.type', text: 'Hello' })).toBe(false)
+    })
+
+    it('$parse can be used as a detached function', () => {
+      const { $parse } = schema
+      const result = $parse({ text: 'Hello' })
+      expect(result).toEqual({ text: 'Hello' })
+    })
+
+    it('$matches can be used as a detached function', () => {
+      const { $matches } = schema
+      expect($matches({ text: 'Hello' })).toBe(true)
+      expect($matches(42)).toBe(false)
+    })
+
+    it('lazy property returns the same function on repeated access', () => {
+      const fn1 = schema.$build
+      const fn2 = schema.$build
+      expect(fn1).toBe(fn2)
+    })
+  })
+
   describe('with complex nested schemas', () => {
     const complexSchema = typedObject(
       'app.bsky.actor.profile',

package/src/schema/typed-object.ts

@@ -14,6 +14,14 @@ import {
   ValidationContext,
   Validator,
 } from '../core.js'
+import { lazyProperty } from '../util/lazy-property.js'
+
+export type MaybeTypedObject<
+  TType extends $Type,
+  TValue extends { $type?: unknown } = { $type?: unknown },
+> = TValue extends { $type?: TType }
+  ? TValue
+  : $TypedMaybe<Exclude<TValue, Unknown$TypedObject>, TType>
 
 /**
  * Schema for typed objects in Lexicon unions.
@@ -40,6 +48,8 @@ export class TypedObjectSchema<
   $TypedMaybe<InferInput<TShape>, TType>,
   $TypedMaybe<InferOutput<TShape>, TType>
 > {
+  readonly type = 'typedObject' as const
+
   constructor(
     readonly $type: TType,
     readonly schema: TShape,
@@ -47,12 +57,20 @@ export class TypedObjectSchema<
     super()
   }
 
-  isTypeOf<X extends Record<string, unknown>>(
-    value: X,
-  ): value is X extends { $type?: TType }
-    ? X
-    : $TypedMaybe<Exclude<X, Unknown$TypedObject>, TType> {
-    return value.$type === undefined || value.$type === this.$type
+  validateInContext(input: unknown, ctx: ValidationContext) {
+    if (!isPlainObject(input)) {
+      return ctx.issueUnexpectedType(input, 'object')
+    }
+
+    if (
+      '$type' in input &&
+      input.$type !== undefined &&
+      input.$type !== this.$type
+    ) {
+      return ctx.issueInvalidPropertyValue(input, '$type', [this.$type])
+    }
+
+    return ctx.validate(input, this.schema)
   }
 
   build(
@@ -64,28 +82,26 @@ export class TypedObjectSchema<
     >
   }
 
-  $isTypeOf<X extends Record<string, unknown>>(value: X) {
-    return this.isTypeOf(value)
+  isTypeOf<TValue extends Record<string, unknown>>(
+    value: TValue,
+  ): value is MaybeTypedObject<TType, TValue> {
+    return value.$type === undefined || value.$type === this.$type
   }
 
-  $build(input: Omit<InferInput<this>, '$type'>) {
-    return this.build(input)
+  /**
+   * Bound alias for {@link build} for compatibility with generated utilities.
+   * @see {@link build}
+   */
+  get $build(): typeof this.build {
+    return lazyProperty(this, '$build', this.build.bind(this))
   }
 
-  validateInContext(input: unknown, ctx: ValidationContext) {
-    if (!isPlainObject(input)) {
-      return ctx.issueInvalidType(input, 'object')
-    }
-
-    if (
-      '$type' in input &&
-      input.$type !== undefined &&
-      input.$type !== this.$type
-    ) {
-      return ctx.issueInvalidPropertyValue(input, '$type', [this.$type])
-    }
-
-    return ctx.validate(input, this.schema)
+  /**
+   * Bound alias for {@link isTypeOf} for compatibility with generated utilities.
+   * @see {@link isTypeOf}
+   */
+  get $isTypeOf(): typeof this.isTypeOf {
+    return lazyProperty(this, '$isTypeOf', this.isTypeOf.bind(this))
   }
 }
 

package/src/schema/typed-ref.ts

@@ -51,6 +51,8 @@ export class TypedRefSchema<
   $Typed<InferInput<TValidator>>,
   $Typed<InferOutput<TValidator>>
 > {
+  readonly type = 'typedRef' as const
+
   #getter: TypedRefGetter<TValidator>
 
   constructor(getter: TypedRefGetter<TValidator>) {

package/src/schema/typed-union.ts

@@ -42,6 +42,8 @@ export class TypedUnionSchema<
     ? InferOutput<TValidators[number]>
     : InferOutput<TValidators[number]> | Unknown$TypedObject
 > {
+  readonly type = 'typedUnion' as const
+
   constructor(
     protected readonly validators: TValidators,
     public readonly closed: TClosed,
@@ -67,7 +69,7 @@ export class TypedUnionSchema<
 
   validateInContext(input: unknown, ctx: ValidationContext) {
     if (!isPlainObject(input) || !('$type' in input)) {
-      return ctx.issueInvalidType(input, '$typed')
+      return ctx.issueUnexpectedType(input, '$typed')
     }
 
     const { $type } = input

package/src/schema/union.ts

@@ -1,9 +1,9 @@
 import {
   InferInput,
   InferOutput,
+  LexValidationError,
   Schema,
   ValidationContext,
-  ValidationError,
   ValidationFailure,
   Validator,
 } from '../core.js'
@@ -37,6 +37,8 @@ export class UnionSchema<
   InferInput<TValidators[number]>,
   InferOutput<TValidators[number]>
 > {
+  readonly type = 'union' as const
+
   constructor(protected readonly validators: TValidators) {
     super()
   }
@@ -51,7 +53,7 @@ export class UnionSchema<
       failures.push(result)
     }
 
-    return ctx.failure(ValidationError.fromFailures(failures))
+    return ctx.failure(LexValidationError.fromFailures(failures))
   }
 }
 

package/src/schema/unknown.ts

@@ -15,6 +15,8 @@ import { memoizedOptions } from '../util/memoize.js'
  * ```
  */
 export class UnknownSchema extends Schema<unknown> {
+  readonly type = 'unknown' as const
+
   validateInContext(input: unknown, ctx: ValidationContext) {
     return ctx.success(input)
   }

package/src/schema/with-default.ts

@@ -25,6 +25,8 @@ import {
 export class WithDefaultSchema<
   const TValidator extends Validator,
 > extends Schema<InferInput<TValidator>, InferOutput<TValidator>> {
+  readonly type = 'withDefault' as const
+
   constructor(
     readonly validator: TValidator,
     readonly defaultValue: InferInput<TValidator>,

package/src/schema.ts

@@ -7,13 +7,14 @@ export * from './schema/cid.js'
 export * from './schema/dict.js'
 export * from './schema/enum.js'
 export * from './schema/integer.js'
+export * from './schema/lex-map.js'
+export * from './schema/lex-value.js'
 export * from './schema/literal.js'
 export * from './schema/never.js'
 export * from './schema/null.js'
 export * from './schema/object.js'
 export * from './schema/regexp.js'
 export * from './schema/string.js'
-export * from './schema/unknown-object.js'
 export * from './schema/unknown.js'
 
 // Composite Types

package/src/util/if-any.ts

@@ -0,0 +1,3 @@
+export type IfAny<T, TrueValue, FalseValue> = 0 extends 1 & T
+  ? TrueValue
+  : FalseValue

package/dist/schema/unknown-object.d.ts

@@ -1,42 +0,0 @@
-import { LexMap } from '@atproto/lex-data';
-import { Schema, ValidationContext } from '../core.js';
-/**
- * Type alias for a plain object with unknown values.
- */
-export type UnknownObject = LexMap;
-/**
- * Schema that accepts any plain object without validating its properties.
- *
- * Validates that the input is a plain object (not an array, Date, or other
- * special object type), but does not validate the object's properties.
- *
- * @example
- * ```ts
- * const schema = new UnknownObjectSchema()
- * schema.validate({ any: 'props' }) // success
- * schema.validate([1, 2, 3])        // fails - arrays not accepted
- * ```
- */
-export declare class UnknownObjectSchema extends Schema<UnknownObject> {
-    validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").ValidationResult<LexMap>;
-}
-/**
- * Creates a schema that accepts any plain object.
- *
- * Unlike `l.unknown()` which accepts any value, this validates that the input
- * is specifically a plain object (not an array, null, or primitive).
- *
- * @returns A new {@link UnknownObjectSchema} instance
- *
- * @example
- * ```ts
- * // Accept any object shape
- * const metadataSchema = l.unknownObject()
- *
- * metadataSchema.parse({ foo: 1, bar: 'baz' }) // success
- * metadataSchema.parse([1, 2, 3])              // throws - not a plain object
- * metadataSchema.parse(null)                   // throws
- * ```
- */
-export declare const unknownObject: () => UnknownObjectSchema;
-//# sourceMappingURL=unknown-object.d.ts.map

package/dist/schema/unknown-object.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"unknown-object.d.ts","sourceRoot":"","sources":["../../src/schema/unknown-object.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAY,MAAM,mBAAmB,CAAA;AACpD,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAGtD;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAA;AAElC;;;;;;;;;;;;GAYG;AACH,qBAAa,mBAAoB,SAAQ,MAAM,CAAC,aAAa,CAAC;IAC5D,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAOzD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,aAAa,2BAExB,CAAA"}

package/dist/schema/unknown-object.js

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.unknownObject = exports.UnknownObjectSchema = void 0;
-const lex_data_1 = require("@atproto/lex-data");
-const core_js_1 = require("../core.js");
-const memoize_js_1 = require("../util/memoize.js");
-/**
- * Schema that accepts any plain object without validating its properties.
- *
- * Validates that the input is a plain object (not an array, Date, or other
- * special object type), but does not validate the object's properties.
- *
- * @example
- * ```ts
- * const schema = new UnknownObjectSchema()
- * schema.validate({ any: 'props' }) // success
- * schema.validate([1, 2, 3])        // fails - arrays not accepted
- * ```
- */
-class UnknownObjectSchema extends core_js_1.Schema {
-    validateInContext(input, ctx) {
-        if ((0, lex_data_1.isLexMap)(input)) {
-            return ctx.success(input);
-        }
-        return ctx.issueInvalidType(input, 'unknown');
-    }
-}
-exports.UnknownObjectSchema = UnknownObjectSchema;
-/**
- * Creates a schema that accepts any plain object.
- *
- * Unlike `l.unknown()` which accepts any value, this validates that the input
- * is specifically a plain object (not an array, null, or primitive).
- *
- * @returns A new {@link UnknownObjectSchema} instance
- *
- * @example
- * ```ts
- * // Accept any object shape
- * const metadataSchema = l.unknownObject()
- *
- * metadataSchema.parse({ foo: 1, bar: 'baz' }) // success
- * metadataSchema.parse([1, 2, 3])              // throws - not a plain object
- * metadataSchema.parse(null)                   // throws
- * ```
- */
-exports.unknownObject = (0, memoize_js_1.memoizedOptions)(function () {
-    return new UnknownObjectSchema();
-});
-//# sourceMappingURL=unknown-object.js.map

package/dist/schema/unknown-object.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"unknown-object.js","sourceRoot":"","sources":["../../src/schema/unknown-object.ts"],"names":[],"mappings":";;;AAAA,gDAAoD;AACpD,wCAAsD;AACtD,mDAAoD;AAOpD;;;;;;;;;;;;GAYG;AACH,MAAa,mBAAoB,SAAQ,gBAAqB;IAC5D,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,IAAA,mBAAQ,EAAC,KAAK,CAAC,EAAE,CAAC;YACpB,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;QAC3B,CAAC;QAED,OAAO,GAAG,CAAC,gBAAgB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAA;IAC/C,CAAC;CACF;AARD,kDAQC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACU,QAAA,aAAa,GAAiB,IAAA,4BAAe,EAAC;IACzD,OAAO,IAAI,mBAAmB,EAAE,CAAA;AAClC,CAAC,CAAC,CAAA","sourcesContent":["import { LexMap, isLexMap } from '@atproto/lex-data'\nimport { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\n/**\n * Type alias for a plain object with unknown values.\n */\nexport type UnknownObject = LexMap\n\n/**\n * Schema that accepts any plain object without validating its properties.\n *\n * Validates that the input is a plain object (not an array, Date, or other\n * special object type), but does not validate the object's properties.\n *\n * @example\n * ```ts\n * const schema = new UnknownObjectSchema()\n * schema.validate({ any: 'props' }) // success\n * schema.validate([1, 2, 3])        // fails - arrays not accepted\n * ```\n */\nexport class UnknownObjectSchema extends Schema<UnknownObject> {\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (isLexMap(input)) {\n      return ctx.success(input)\n    }\n\n    return ctx.issueInvalidType(input, 'unknown')\n  }\n}\n\n/**\n * Creates a schema that accepts any plain object.\n *\n * Unlike `l.unknown()` which accepts any value, this validates that the input\n * is specifically a plain object (not an array, null, or primitive).\n *\n * @returns A new {@link UnknownObjectSchema} instance\n *\n * @example\n * ```ts\n * // Accept any object shape\n * const metadataSchema = l.unknownObject()\n *\n * metadataSchema.parse({ foo: 1, bar: 'baz' }) // success\n * metadataSchema.parse([1, 2, 3])              // throws - not a plain object\n * metadataSchema.parse(null)                   // throws\n * ```\n */\nexport const unknownObject = /*#__PURE__*/ memoizedOptions(function () {\n  return new UnknownObjectSchema()\n})\n"]}

package/src/schema/unknown-object.ts

@@ -1,53 +0,0 @@
-import { LexMap, isLexMap } from '@atproto/lex-data'
-import { Schema, ValidationContext } from '../core.js'
-import { memoizedOptions } from '../util/memoize.js'
-
-/**
- * Type alias for a plain object with unknown values.
- */
-export type UnknownObject = LexMap
-
-/**
- * Schema that accepts any plain object without validating its properties.
- *
- * Validates that the input is a plain object (not an array, Date, or other
- * special object type), but does not validate the object's properties.
- *
- * @example
- * ```ts
- * const schema = new UnknownObjectSchema()
- * schema.validate({ any: 'props' }) // success
- * schema.validate([1, 2, 3])        // fails - arrays not accepted
- * ```
- */
-export class UnknownObjectSchema extends Schema<UnknownObject> {
-  validateInContext(input: unknown, ctx: ValidationContext) {
-    if (isLexMap(input)) {
-      return ctx.success(input)
-    }
-
-    return ctx.issueInvalidType(input, 'unknown')
-  }
-}
-
-/**
- * Creates a schema that accepts any plain object.
- *
- * Unlike `l.unknown()` which accepts any value, this validates that the input
- * is specifically a plain object (not an array, null, or primitive).
- *
- * @returns A new {@link UnknownObjectSchema} instance
- *
- * @example
- * ```ts
- * // Accept any object shape
- * const metadataSchema = l.unknownObject()
- *
- * metadataSchema.parse({ foo: 1, bar: 'baz' }) // success
- * metadataSchema.parse([1, 2, 3])              // throws - not a plain object
- * metadataSchema.parse(null)                   // throws
- * ```
- */
-export const unknownObject = /*#__PURE__*/ memoizedOptions(function () {
-  return new UnknownObjectSchema()
-})