@atproto/lex-schema 0.0.9 → 0.0.10

package/dist/util/memoize.d.ts

@@ -1,3 +1,3 @@
-export declare function memoizedOptions<F extends (options?: NonNullable<unknown>) => any>(fn: F, keyFn?: (options: NonNullable<Parameters<F>[0]>) => string | number | boolean | null | void): F;
-export declare function memoizedTransformer<F extends (arg: any) => any>(fn: F): F;
+export declare function memoizedOptions<F extends (...args: any[]) => any>(fn: F): F;
+export declare function memoizedTransformer<F extends (key: any, ...args: any[]) => unknown>(fn: F): F;
 //# sourceMappingURL=memoize.d.ts.map

package/dist/util/memoize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memoize.d.ts","sourceRoot":"","sources":["../../src/util/memoize.ts"],"names":[],"mappings":"AACA,wBAAgB,eAAe,CAC7B,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,WAAW,CAAC,OAAO,CAAC,KAAK,GAAG,EAEjD,EAAE,EAAE,CAAC,EACL,KAAK,CAAC,EAAE,CACN,OAAO,EAAE,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KACnC,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,IAAI,GAC3C,CAAC,CAoCH;AAGD,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE,GAAG,KAAK,GAAG,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,CASzE"}
+{"version":3,"file":"memoize.d.ts","sourceRoot":"","sources":["../../src/util/memoize.ts"],"names":[],"mappings":"AACA,wBAAgB,eAAe,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,CAiB3E;AAGD,wBAAgB,mBAAmB,CACjC,CAAC,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,EAC/C,EAAE,EAAE,CAAC,GAAG,CAAC,CAaV"}

package/dist/util/memoize.js

@@ -3,50 +3,34 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.memoizedOptions = memoizedOptions;
 exports.memoizedTransformer = memoizedTransformer;
 /*@__NO_SIDE_EFFECTS__*/
-function memoizedOptions(fn, keyFn) {
-    let emptyOptionsValue;
-    if (keyFn) {
-        const cache = new Map();
-        const fromCache = (options) => {
-            const key = keyFn(options);
-            if (key !== undefined) {
-                const cached = cache.get(key);
-                if (cached)
-                    return cached;
-                const result = fn(options);
-                cache.set(key, result);
-                return result;
-            }
-            return fn(options);
-        };
-        return ((options) => {
-            // Non-empty options case
-            if (options)
-                for (const _ in options)
-                    return fromCache(options);
-            // Empty or missing options case
-            return (emptyOptionsValue ??= fn(options));
-        });
-    }
-    return ((options) => {
-        // Non-empty options case
-        if (options)
-            for (const _ in options)
-                return fn(options);
-        // Empty or missing options case
-        return (emptyOptionsValue ??= fn(options));
-    });
+function memoizedOptions(fn) {
+    let cache = null;
+    return function cached(...args) {
+        // Not using the cache if there are args
+        if (args.length > 0) {
+            return fn(...args);
+        }
+        if (cache != null) {
+            return cache.value;
+        }
+        const value = fn(...args);
+        cache = { value };
+        return value;
+    };
 }
 /*@__NO_SIDE_EFFECTS__*/
 function memoizedTransformer(fn) {
-    const cache = new WeakMap();
-    return ((arg) => {
-        const cached = cache.get(arg);
+    let cache;
+    return function cached(key, ...args) {
+        if (args.length > 0)
+            return fn(key, ...args);
+        cache ??= new WeakMap();
+        const cached = cache.get(key);
         if (cached)
             return cached;
-        const result = fn(arg);
-        cache.set(arg, result);
+        const result = fn(key, ...args);
+        cache.set(key, result);
         return result;
-    });
+    };
 }
 //# sourceMappingURL=memoize.js.map

package/dist/util/memoize.js.map

@@ -1 +1 @@
-{"version":3,"file":"memoize.js","sourceRoot":"","sources":["../../src/util/memoize.ts"],"names":[],"mappings":";;AACA,0CA2CC;AAGD,kDASC;AAxDD,wBAAwB;AACxB,SAAgB,eAAe,CAG7B,EAAK,EACL,KAE4C;IAE5C,IAAI,iBAA4C,CAAA;IAEhD,IAAI,KAAK,EAAE,CAAC;QACV,MAAM,KAAK,GAAG,IAAI,GAAG,EAAmD,CAAA;QACxE,MAAM,SAAS,GAAG,CAChB,OAAsC,EACvB,EAAE;YACjB,MAAM,GAAG,GAAG,KAAK,CAAC,OAAO,CAAC,CAAA;YAC1B,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;gBACtB,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;gBAC7B,IAAI,MAAM;oBAAE,OAAO,MAAM,CAAA;gBACzB,MAAM,MAAM,GAAG,EAAE,CAAC,OAAO,CAAkB,CAAA;gBAC3C,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAA;gBACtB,OAAO,MAAM,CAAA;YACf,CAAC;YAED,OAAO,EAAE,CAAC,OAAO,CAAC,CAAA;QACpB,CAAC,CAAA;QAED,OAAO,CAAC,CAAC,OAAyB,EAAiB,EAAE;YACnD,yBAAyB;YACzB,IAAI,OAAO;gBAAE,KAAK,MAAM,CAAC,IAAI,OAAO;oBAAE,OAAO,SAAS,CAAC,OAAO,CAAC,CAAA;YAE/D,gCAAgC;YAChC,OAAO,CAAC,iBAAiB,KAAK,EAAE,CAAC,OAAO,CAAC,CAAC,CAAA;QAC5C,CAAC,CAAM,CAAA;IACT,CAAC;IAED,OAAO,CAAC,CAAC,OAAyB,EAAiB,EAAE;QACnD,yBAAyB;QACzB,IAAI,OAAO;YAAE,KAAK,MAAM,CAAC,IAAI,OAAO;gBAAE,OAAO,EAAE,CAAC,OAAO,CAAC,CAAA;QAExD,gCAAgC;QAChC,OAAO,CAAC,iBAAiB,KAAK,EAAE,CAAC,OAAO,CAAC,CAAC,CAAA;IAC5C,CAAC,CAAM,CAAA;AACT,CAAC;AAED,wBAAwB;AACxB,SAAgB,mBAAmB,CAA8B,EAAK;IACpE,MAAM,KAAK,GAAG,IAAI,OAAO,EAAyB,CAAA;IAClD,OAAO,CAAC,CAAC,GAAqB,EAAiB,EAAE;QAC/C,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;QAC7B,IAAI,MAAM;YAAE,OAAO,MAAM,CAAA;QACzB,MAAM,MAAM,GAAG,EAAE,CAAC,GAAG,CAAkB,CAAA;QACvC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAA;QACtB,OAAO,MAAM,CAAA;IACf,CAAC,CAAM,CAAA;AACT,CAAC","sourcesContent":["/*@__NO_SIDE_EFFECTS__*/\nexport function memoizedOptions<\n  F extends (options?: NonNullable<unknown>) => any,\n>(\n  fn: F,\n  keyFn?: (\n    options: NonNullable<Parameters<F>[0]>,\n  ) => string | number | boolean | null | void,\n): F {\n  let emptyOptionsValue: ReturnType<F> | undefined\n\n  if (keyFn) {\n    const cache = new Map<string | number | boolean | null, ReturnType<F>>()\n    const fromCache = (\n      options: NonNullable<Parameters<F>[0]>,\n    ): ReturnType<F> => {\n      const key = keyFn(options)\n      if (key !== undefined) {\n        const cached = cache.get(key)\n        if (cached) return cached\n        const result = fn(options) as ReturnType<F>\n        cache.set(key, result)\n        return result\n      }\n\n      return fn(options)\n    }\n\n    return ((options: Parameters<F>[0]): ReturnType<F> => {\n      // Non-empty options case\n      if (options) for (const _ in options) return fromCache(options)\n\n      // Empty or missing options case\n      return (emptyOptionsValue ??= fn(options))\n    }) as F\n  }\n\n  return ((options: Parameters<F>[0]): ReturnType<F> => {\n    // Non-empty options case\n    if (options) for (const _ in options) return fn(options)\n\n    // Empty or missing options case\n    return (emptyOptionsValue ??= fn(options))\n  }) as F\n}\n\n/*@__NO_SIDE_EFFECTS__*/\nexport function memoizedTransformer<F extends (arg: any) => any>(fn: F): F {\n  const cache = new WeakMap<object, ReturnType<F>>()\n  return ((arg: Parameters<F>[0]): ReturnType<F> => {\n    const cached = cache.get(arg)\n    if (cached) return cached\n    const result = fn(arg) as ReturnType<F>\n    cache.set(arg, result)\n    return result\n  }) as F\n}\n"]}
+{"version":3,"file":"memoize.js","sourceRoot":"","sources":["../../src/util/memoize.ts"],"names":[],"mappings":";;AACA,0CAiBC;AAGD,kDAeC;AApCD,wBAAwB;AACxB,SAAgB,eAAe,CAAoC,EAAK;IACtE,IAAI,KAAK,GAAoC,IAAI,CAAA;IAEjD,OAAO,SAAS,MAAM,CAAC,GAAG,IAAW;QACnC,wCAAwC;QACxC,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACpB,OAAO,EAAE,CAAC,GAAG,IAAI,CAAC,CAAA;QACpB,CAAC;QAED,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;YAClB,OAAO,KAAK,CAAC,KAAK,CAAA;QACpB,CAAC;QAED,MAAM,KAAK,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC,CAAA;QACzB,KAAK,GAAG,EAAE,KAAK,EAAE,CAAA;QACjB,OAAO,KAAK,CAAA;IACd,CAAM,CAAA;AACR,CAAC;AAED,wBAAwB;AACxB,SAAgB,mBAAmB,CAEjC,EAAK;IACL,IAAI,KAAqC,CAAA;IAEzC,OAAO,SAAS,MAAM,CAAC,GAAQ,EAAE,GAAG,IAAW;QAC7C,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC;YAAE,OAAO,EAAE,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,CAAA;QAE5C,KAAK,KAAK,IAAI,OAAO,EAAE,CAAA;QACvB,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;QAC7B,IAAI,MAAM;YAAE,OAAO,MAAM,CAAA;QACzB,MAAM,MAAM,GAAG,EAAE,CAAC,GAAG,EAAE,GAAG,IAAI,CAAkB,CAAA;QAChD,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAA;QACtB,OAAO,MAAM,CAAA;IACf,CAAM,CAAA;AACR,CAAC","sourcesContent":["/*@__NO_SIDE_EFFECTS__*/\nexport function memoizedOptions<F extends (...args: any[]) => any>(fn: F): F {\n  let cache: null | { value: ReturnType<F> } = null\n\n  return function cached(...args: any[]): ReturnType<F> {\n    // Not using the cache if there are args\n    if (args.length > 0) {\n      return fn(...args)\n    }\n\n    if (cache != null) {\n      return cache.value\n    }\n\n    const value = fn(...args)\n    cache = { value }\n    return value\n  } as F\n}\n\n/*@__NO_SIDE_EFFECTS__*/\nexport function memoizedTransformer<\n  F extends (key: any, ...args: any[]) => unknown,\n>(fn: F): F {\n  let cache: WeakMap<object, ReturnType<F>>\n\n  return function cached(key: any, ...args: any[]): any {\n    if (args.length > 0) return fn(key, ...args)\n\n    cache ??= new WeakMap()\n    const cached = cache.get(key)\n    if (cached) return cached\n    const result = fn(key, ...args) as ReturnType<F>\n    cache.set(key, result)\n    return result\n  } as F\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/lex-schema",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "license": "MIT",
   "description": "Lexicon schema system for AT Lexicons",
   "keywords": [
@@ -36,8 +36,8 @@
   },
   "dependencies": {
     "tslib": "^2.8.1",
-    "@atproto/syntax": "0.4.2",
-    "@atproto/lex-data": "0.0.8"
+    "@atproto/syntax": "0.4.3",
+    "@atproto/lex-data": "0.0.9"
   },
   "devDependencies": {
     "vitest": "^4.0.16"

package/src/core/$type.test.ts

@@ -0,0 +1,20 @@
+import { describe, it } from 'vitest'
+import { LexMap } from '@atproto/lex-data'
+import { Unknown$TypedObject } from './$type.js'
+
+describe('Unknown$TypedObject', () => {
+  it('allows assigning Unknown$TypedObject to LexMap', () => {
+    function expectLexMap(_value: LexMap) {}
+
+    const someObject = {
+      $type: 'some-type',
+    } as Unknown$TypedObject
+
+    expectLexMap(someObject)
+
+    expectLexMap({
+      arr: [someObject],
+      val: someObject,
+    })
+  })
+})

package/src/core/$type.ts

@@ -28,6 +28,13 @@ export type $Typed<V, T extends string = string> = Simplify<
   }
 >
 
+export function $typed<V extends { $type?: unknown }, T extends string>(
+  value: V,
+  $type: T,
+): $Typed<V, T> {
+  return value.$type === $type ? (value as $Typed<V, T>) : { ...value, $type }
+}
+
 export type $TypedMaybe<V, T extends string = string> = Simplify<
   V & {
     $type?: T
@@ -35,3 +42,26 @@ export type $TypedMaybe<V, T extends string = string> = Simplify<
 >
 
 export type Un$Typed<V extends { $type?: string }> = OmitKey<V, '$type'>
+
+declare const unknown$TypeSymbol: unique symbol
+export type Unknown$Type = string & { [unknown$TypeSymbol]: true }
+
+// In order to prevent places that expect a union of known and unknown $typed
+// objects (like lexicons schema open unions), from accepting an invalid version
+// of the known $typed objects, we need to prevent any other properties from
+// being present.
+//
+// For example, if we expect:
+// ```ts
+// type MyOpenUnion = { $type: 'A'; a: number } | Unknown$TypedObject
+// ```
+// we want to make that that the following is rejected:
+// ```ts
+// { $type: 'A' }
+// ```
+//
+// If we typed `Unknown$TypedObject` as `{ $type: string }`, `{ $type: 'A' }`
+// would be a valid `MyOpenUnion` as it would match the `Unknown$TypedObject`.
+// By using a $type property that uniquely describes unknown values, we ensure
+// that only valid known typed objects, or a type casted value, can be used.
+export type Unknown$TypedObject = { $type: Unknown$Type }

package/src/core/schema.ts

@@ -1,17 +1,38 @@
 import {
+  InferInput,
+  InferOutput,
+  ValidationContext,
   ValidationOptions,
   ValidationResult,
   Validator,
-  ValidatorContext,
 } from './validator.js'
 
-export abstract class Schema<Output = any> implements Validator<Output> {
-  declare readonly ['__lex']: { output: Output }
+type ParseOptions = Omit<ValidationOptions, 'mode'>
+type ValidateOptions = Omit<ValidationOptions, 'mode'>
+
+export interface SchemaInternals<out TInput = unknown, out TOutput = TInput> {
+  /** @internal The inferred validation type */
+  input: TInput
+
+  /** @internal The inferred parse type */
+  output: TOutput
+}
+
+export abstract class Schema<
+  out TInput = unknown,
+  out TOutput = TInput,
+  out TInternals extends SchemaInternals<TInput, TOutput> = SchemaInternals<
+    TInput,
+    TOutput
+  >,
+> implements Validator<TInternals['input'], TInternals['output']>
+{
+  declare readonly ['__lex']: TInternals
 
   abstract validateInContext(
     input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<Output>
+    ctx: ValidationContext,
+  ): ValidationResult
 
   /**
    * @note use {@link check}() instead of {@link assert}() if you encounter a
@@ -19,8 +40,8 @@ export abstract class Schema<Output = any> implements Validator<Output> {
    * will typically arise in generic contexts, where the narrowed type is not
    * needed.
    */
-  assert(input: unknown): asserts input is Output {
-    const result = this.safeParse(input, { allowTransform: false })
+  assert(input: unknown): asserts input is InferInput<this> {
+    const result = ValidationContext.validate(input, this)
     if (!result.success) throw result.reason
   }
 
@@ -37,45 +58,53 @@ export abstract class Schema<Output = any> implements Validator<Output> {
   /**
    * Casts the input (by validating it) to the output type if it matches the
    * schema, otherwise throws. This is the same as calling {@link parse}() with
-   * `allowTransform: false`.
+   * `mode: "validate"`.
    */
-  cast<I>(input: I): I & Output {
-    return this.parse(input, { allowTransform: false })
+  cast<I>(input: I): I & InferInput<this> {
+    const result = ValidationContext.validate(input, this)
+    if (result.success) return result.value
+    throw result.reason
   }
 
-  matches(input: unknown): input is Output {
-    const result = this.safeParse(input, { allowTransform: false })
+  matches<I>(input: I): input is I & InferInput<this> {
+    const result = ValidationContext.validate(input, this)
     return result.success
   }
 
-  ifMatches<I>(input: I): (I & Output) | undefined {
+  ifMatches<I>(input: I): (I & InferInput<this>) | undefined {
     return this.matches(input) ? input : undefined
   }
 
-  parse<I>(
-    input: I,
-    options: ValidationOptions & { allowTransform: false },
-  ): I & Output
-  parse(input: unknown, options?: ValidationOptions): Output
-  parse(input: unknown, options?: ValidationOptions): Output {
+  parse(input: unknown, options?: ParseOptions): InferOutput<this> {
     const result = this.safeParse(input, options)
-    if (!result.success) throw result.reason
-    return result.value
+    if (result.success) return result.value
+    throw result.reason
   }
 
-  safeParse<I>(
-    input: I,
-    options: ValidationOptions & { allowTransform: false },
-  ): ValidationResult<I & Output>
-  safeParse(
-    input: unknown,
-    options?: ValidationOptions,
-  ): ValidationResult<Output>
   safeParse(
     input: unknown,
-    options?: ValidationOptions,
-  ): ValidationResult<Output> {
-    return ValidatorContext.validate(input, this, options)
+    options?: ParseOptions,
+  ): ValidationResult<InferOutput<this>> {
+    return ValidationContext.validate(input, this, {
+      ...options,
+      mode: 'parse',
+    })
+  }
+
+  validate<I>(input: I, options?: ValidateOptions): I & InferInput<this> {
+    const result = this.safeValidate(input, options)
+    if (result.success) return result.value
+    throw result.reason
+  }
+
+  safeValidate<I>(
+    input: I,
+    options?: ValidateOptions,
+  ): ValidationResult<I & InferInput<this>> {
+    return ValidationContext.validate(input, this, {
+      ...options,
+      mode: 'validate',
+    })
   }
 
   // @NOTE The built lexicons namespaces will export utility functions that
@@ -92,26 +121,45 @@ export abstract class Schema<Output = any> implements Validator<Output> {
   // - "app.bsky.feed.post.$parse(...)" // calls a utility function created by "lex build"
   // - "app.bsky.feed.defs.postView.$parse(...)" // uses the alias defined below on the schema instance
 
-  $assert(input: unknown): asserts input is Output {
+  $assert(input: unknown): asserts input is InferInput<this> {
     return this.assert(input)
   }
 
-  $matches(input: unknown): input is Output {
+  $check(input: unknown): void {
+    return this.check(input)
+  }
+
+  $cast<I>(input: I): I & InferInput<this> {
+    return this.cast(input)
+  }
+
+  $matches(input: unknown): input is InferInput<this> {
     return this.matches(input)
   }
 
-  $ifMatches<I>(input: I): (I & Output) | undefined {
+  $ifMatches<I>(input: I): (I & InferInput<this>) | undefined {
     return this.ifMatches(input)
   }
 
-  $parse(input: unknown, options?: ValidationOptions): Output {
+  $parse(input: unknown, options?: ValidateOptions): InferOutput<this> {
     return this.parse(input, options)
   }
 
   $safeParse(
     input: unknown,
-    options?: ValidationOptions,
-  ): ValidationResult<Output> {
+    options?: ValidateOptions,
+  ): ValidationResult<InferOutput<this>> {
     return this.safeParse(input, options)
   }
+
+  $validate<I>(input: I, options?: ValidateOptions): I & InferInput<this> {
+    return this.validate(input, options)
+  }
+
+  $safeValidate<I>(
+    input: I,
+    options?: ValidateOptions,
+  ): ValidationResult<I & InferInput<this>> {
+    return this.safeValidate(input, options)
+  }
 }

package/src/core/string-format.ts

@@ -1,4 +1,4 @@
-import { ensureValidCidString, isLanguageString } from '@atproto/lex-data'
+import { validateCidString } from '@atproto/lex-data'
 import {
   AtIdentifierString,
   AtUriString,
@@ -8,173 +8,134 @@ import {
   NsidString,
   RecordKeyString,
   TidString,
-  ensureValidAtIdentifier,
-  ensureValidAtUri,
-  ensureValidDatetime,
-  ensureValidDid,
-  ensureValidHandle,
-  ensureValidNsid,
-  ensureValidRecordKey,
-  ensureValidTid,
+  UriString,
+  isValidAtIdentifier as isValidAtId,
+  isValidAtUri,
+  isValidDatetime,
+  isValidDid,
+  isValidHandle,
+  isValidLanguage,
+  isValidNsid,
+  isValidRecordKey,
+  isValidTid,
+  isValidUri,
 } from '@atproto/syntax'
-import {
-  AssertFn,
-  CastFn,
-  CheckFn,
-  createAssertFunction,
-  createCastFunction,
-  createCheckFunction,
-} from '../util/assertion-util.js'
-
-// Format utilities missing from @atproto/syntax
+import { CheckFn } from '../util/assertion-util.js'
+
+// Expose all individual string format types and type guards
+
+export type { AtIdentifierString }
+export const isAtIdentifierString: CheckFn<AtIdentifierString> = isValidAtId
+
+export type { AtUriString }
+export const isAtUriString: CheckFn<AtUriString> = isValidAtUri
+
 export type CidString = string
+export const isCidString = ((v) => validateCidString(v)) as CheckFn<CidString>
+
+export type { DatetimeString }
+export const isDatetimeString: CheckFn<DatetimeString> = isValidDatetime
+
+export type { DidString }
+export const isDidString: CheckFn<DidString> = isValidDid
+
+export type { HandleString }
+export const isHandleString: CheckFn<HandleString> = isValidHandle
+
 export type LanguageString = string
-export type UriString = `${string}:${string}`
+export const isLanguageString = isValidLanguage as CheckFn<LanguageString>
 
-/*@__NO_SIDE_EFFECTS__*/
-export function isUriString<T extends string>(
-  input: T,
-): input is T & UriString {
-  return /^\w+:(?:\/\/)?[^\s/][^\s]*$/.test(input)
+export type { NsidString }
+export const isNsidString: CheckFn<NsidString> = isValidNsid
+
+export type { RecordKeyString }
+export const isRecordKeyString: CheckFn<RecordKeyString> = isValidRecordKey
+
+export type { TidString }
+export const isTidString: CheckFn<TidString> = isValidTid
+
+export type { UriString }
+export const isUriString: CheckFn<UriString> = isValidUri
+
+// String format registry (maps format names to their types and type guards)
+
+type StringFormats = {
+  'at-identifier': AtIdentifierString
+  'at-uri': AtUriString
+  cid: CidString
+  datetime: DatetimeString
+  did: DidString
+  handle: HandleString
+  language: LanguageString
+  nsid: NsidString
+  'record-key': RecordKeyString
+  tid: TidString
+  uri: UriString
 }
 
-// Re-export utility typed as assertion functions so that TypeScript can
-// infer the narrowed type after calling them.
+export type StringFormat = Extract<keyof StringFormats, string>
 
-export type {
-  AtIdentifierString,
-  AtUriString,
-  DatetimeString,
-  DidString,
-  HandleString,
-  NsidString,
-  RecordKeyString,
-  TidString,
-} from '@atproto/syntax'
+const stringFormatVerifiers: {
+  readonly [K in StringFormat]: CheckFn<StringFormats[K]>
+} = /*#__PURE__*/ Object.freeze({
+  __proto__: null,
+
+  'at-identifier': isAtIdentifierString,
+  'at-uri': isAtUriString,
+  cid: isCidString,
+  datetime: isDatetimeString,
+  did: isDidString,
+  handle: isHandleString,
+  language: isLanguageString,
+  nsid: isNsidString,
+  'record-key': isRecordKeyString,
+  tid: isTidString,
+  uri: isUriString,
+})
 
-// Export utilities for formats missing from @atproto/syntax
-
-export const assertAtIdentifierString: AssertFn<AtIdentifierString> =
-  ensureValidAtIdentifier
-export const assertAtUriString: AssertFn<AtUriString> = ensureValidAtUri
-export const assertCidString: AssertFn<CidString> = ensureValidCidString
-export const assertDatetimeString: AssertFn<DatetimeString> =
-  ensureValidDatetime
-export const assertDidString: AssertFn<DidString> = ensureValidDid
-export const assertHandleString: AssertFn<HandleString> = ensureValidHandle
-export const assertLanguageString: AssertFn<LanguageString> =
-  createAssertFunction<LanguageString>(
-    isLanguageString,
-    'Invalid BCP 47 string',
-  )
-export const assertNsidString: AssertFn<NsidString> = ensureValidNsid
-export const assertRecordKeyString: AssertFn<RecordKeyString> =
-  ensureValidRecordKey
-export const assertTidString: AssertFn<TidString> = ensureValidTid
-export const assertUriString: AssertFn<UriString> =
-  createAssertFunction<UriString>(isUriString, 'Invalid URI')
-
-export const asAtIdentifierString: CastFn<AtIdentifierString> =
-  /*#__PURE__*/ createCastFunction(assertAtIdentifierString)
-export const asAtUriString: CastFn<AtUriString> =
-  /*#__PURE__*/ createCastFunction(ensureValidAtUri)
-export const asCidString: CastFn<CidString> =
-  /*#__PURE__*/ createCastFunction(ensureValidCidString)
-export const asDatetimeString: CastFn<DatetimeString> =
-  /*#__PURE__*/ createCastFunction(ensureValidDatetime)
-export const asDidString: CastFn<DidString> =
-  /*#__PURE__*/ createCastFunction(ensureValidDid)
-export const asHandleString: CastFn<HandleString> =
-  /*#__PURE__*/ createCastFunction(ensureValidHandle)
-export const asLanguageString: CastFn<LanguageString> =
-  /*#__PURE__*/ createCastFunction(assertLanguageString)
-export const asNsidString: CastFn<NsidString> =
-  /*#__PURE__*/ createCastFunction(ensureValidNsid)
-export const asRecordKeyString: CastFn<RecordKeyString> =
-  /*#__PURE__*/ createCastFunction(ensureValidRecordKey)
-export const asTidString: CastFn<TidString> =
-  /*#__PURE__*/ createCastFunction(ensureValidTid)
-export const asUriString: CastFn<UriString> =
-  /*#__PURE__*/ createCastFunction(assertUriString)
-
-export { isLanguageString }
-export const isAtIdentifierString: CheckFn<AtIdentifierString> =
-  /*#__PURE__*/ createCheckFunction(assertAtIdentifierString)
-export const isAtUriString: CheckFn<AtUriString> =
-  /*#__PURE__*/ createCheckFunction(assertAtIdentifierString)
-export const isCidString: CheckFn<CidString> =
-  /*#__PURE__*/ createCheckFunction(assertCidString)
-export const isDatetimeString: CheckFn<DatetimeString> =
-  /*#__PURE__*/ createCheckFunction(assertDatetimeString)
-export const isDidString: CheckFn<DidString> =
-  /*#__PURE__*/ createCheckFunction(assertDidString)
-export const isHandleString: CheckFn<HandleString> =
-  /*#__PURE__*/ createCheckFunction(assertHandleString)
-export const isNsidString: CheckFn<NsidString> =
-  /*#__PURE__*/ createCheckFunction(assertNsidString)
-export const isRecordKeyString: CheckFn<RecordKeyString> =
-  /*#__PURE__*/ createCheckFunction(assertRecordKeyString)
-export const isTidString: CheckFn<TidString> =
-  /*#__PURE__*/ createCheckFunction(assertTidString)
-
-// String formatting types and utilities
-
-export const STRING_FORMATS = Object.freeze([
-  'datetime',
-  'uri',
-  'at-uri',
-  'did',
-  'handle',
-  'at-identifier',
-  'nsid',
-  'cid',
-  'language',
-  'tid',
-  'record-key',
-] as const)
-
-export type StringFormat = (typeof STRING_FORMATS)[number]
-
-export type InferStringFormat<F> =
-  //
-  F extends 'datetime'
-    ? DatetimeString
-    : F extends 'uri'
-      ? UriString
-      : F extends 'at-uri'
-        ? AtUriString
-        : F extends 'did'
-          ? DidString
-          : F extends 'handle'
-            ? HandleString
-            : F extends 'at-identifier'
-              ? AtIdentifierString
-              : F extends 'nsid'
-                ? NsidString
-                : // LanguageString | CidString | TidString | RecordKeyString
-                  string
-
-const formatters = /*#__PURE__*/ new Map<StringFormat, (str: string) => void>([
-  ['at-identifier', assertAtIdentifierString],
-  ['at-uri', assertAtUriString],
-  ['cid', assertCidString],
-  ['datetime', assertDatetimeString],
-  ['did', assertDidString],
-  ['handle', assertHandleString],
-  ['language', assertLanguageString],
-  ['nsid', assertNsidString],
-  ['record-key', assertRecordKeyString],
-  ['tid', assertTidString],
-  ['uri', assertUriString],
-] as const)
+export type InferStringFormat<F extends StringFormat> = F extends StringFormat
+  ? StringFormats[F]
+  : never
 
 /*@__NO_SIDE_EFFECTS__*/
-export function assertStringFormat<F extends StringFormat>(
-  input: string,
+export function isStringFormat<I extends string, F extends StringFormat>(
+  input: I,
   format: F,
-): asserts input is InferStringFormat<F> {
-  const assertFn = formatters.get(format)
-  if (assertFn) assertFn(input)
+): input is I & StringFormats[F] {
+  const formatVerifier = stringFormatVerifiers[format]
   // Fool-proof
-  else throw new Error(`Unknown string format: ${format}`)
+  if (!formatVerifier) throw new TypeError(`Unknown string format: ${format}`)
+
+  return formatVerifier(input)
+}
+
+/*@__NO_SIDE_EFFECTS__*/
+export function assertStringFormat<I extends string, F extends StringFormat>(
+  input: I,
+  format: F,
+): asserts input is I & StringFormats[F] {
+  if (!isStringFormat(input, format)) {
+    throw new TypeError(`Invalid string format (${format}): ${input}`)
+  }
 }
+
+/*@__NO_SIDE_EFFECTS__*/
+export function asStringFormat<I extends string, F extends StringFormat>(
+  input: I,
+  format: F,
+): I & StringFormats[F] {
+  assertStringFormat(input, format)
+  return input
+}
+
+/*@__NO_SIDE_EFFECTS__*/
+export function ifStringFormat<I extends string, F extends StringFormat>(
+  input: I,
+  format: F,
+): undefined | (I & StringFormats[F]) {
+  return isStringFormat(input, format) ? input : undefined
+}
+
+export const STRING_FORMATS = /*#__PURE__*/ Object.freeze(
+  /*#__PURE__*/ Object.keys(stringFormatVerifiers),
+) as readonly StringFormat[]