@atproto/lex-schema 0.0.17 → 0.0.18

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @atproto/lex-schema
 
+## 0.0.18
+
+### Patch Changes
+
+- [#4828](https://github.com/bluesky-social/atproto/pull/4828) [`c62651d`](https://github.com/bluesky-social/atproto/commit/c62651dd69f1e18bd854b66e499b91fee9eaa856) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Accept legacy blob references in non-strict mode. Legacy blob references (objects with `cid` and `mimeType` properties) are now accepted when `strict: false`, which is the default behavior when `strictResponseProcessing` is disabled on the Client.
+
+  BREAKING: The `allowLegacy` option has been removed from the blob schema builder, and legacy blobs are now handled automatically based on the strictness mode: in strict mode they are rejected, and in non-strict mode they are accepted. Consumers should stop passing `allowLegacy` and rely on strictness configuration instead. Likewise, CLI consumers should stop using the removed `--allowLegacyBlobs` flag and use the default strict/non-strict behavior.
+
+- Updated dependencies [[`c62651d`](https://github.com/bluesky-social/atproto/commit/c62651dd69f1e18bd854b66e499b91fee9eaa856), [`f6f100c`](https://github.com/bluesky-social/atproto/commit/f6f100c33700a7ff58a1458109cc7420131feed0), [`c62651d`](https://github.com/bluesky-social/atproto/commit/c62651dd69f1e18bd854b66e499b91fee9eaa856), [`c62651d`](https://github.com/bluesky-social/atproto/commit/c62651dd69f1e18bd854b66e499b91fee9eaa856)]:
+  - @atproto/lex-data@0.0.15
+
 ## 0.0.17
 
 ### Patch Changes

package/dist/schema/blob.d.ts

@@ -1,16 +1,9 @@
-import { BlobRef, LegacyBlobRef, isBlobRef, isLegacyBlobRef } from '@atproto/lex-data';
+import { BlobRef, LegacyBlobRef, TypedBlobRef, isBlobRef, isLegacyBlobRef, isTypedBlobRef } from '@atproto/lex-data';
 import { Schema, ValidationContext } from '../core.js';
 /**
  * Configuration options for blob schema validation.
  */
 export type BlobSchemaOptions = {
-    /**
-     * Whether to allow legacy blob references format
-     *
-     * @default false
-     * @see {@link LegacyBlobRef}
-     */
-    allowLegacy?: boolean;
     /**
      * List of accepted MIME types (supports wildcards like 'image/*' or '*\/*')
      *
@@ -24,8 +17,8 @@ export type BlobSchemaOptions = {
      */
     maxSize?: number;
 };
-export type { BlobRef, LegacyBlobRef };
-export { isBlobRef, isLegacyBlobRef };
+export type { BlobRef, LegacyBlobRef, TypedBlobRef };
+export { isBlobRef, isLegacyBlobRef, isTypedBlobRef };
 /**
  * Schema for validating blob references in AT Protocol.
  *
@@ -41,13 +34,11 @@ export { isBlobRef, isLegacyBlobRef };
  * const result = schema.validate(blobRef)
  * ```
  */
-export declare class BlobSchema<const TOptions extends BlobSchemaOptions = NonNullable<unknown>> extends Schema<TOptions extends {
-    allowLegacy: true;
-} ? BlobRef | LegacyBlobRef : BlobRef> {
+export declare class BlobSchema<const TOptions extends BlobSchemaOptions = NonNullable<unknown>> extends Schema<BlobRef> {
     readonly options?: TOptions | undefined;
     readonly type: "blob";
     constructor(options?: TOptions | undefined);
-    validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").ValidationResult<LegacyBlobRef | BlobRef>;
+    validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").ValidationResult<BlobRef>;
     matchesMime(mime: string): boolean;
 }
 /**
@@ -69,12 +60,7 @@ export declare class BlobSchema<const TOptions extends BlobSchemaOptions = NonNu
  *
  * // Any image type with size limit
  * const avatarSchema = l.blob({ accept: ['image/*'], maxSize: 1000000 })
- *
- * // Allow legacy format
- * const legacySchema = l.blob({ allowLegacy: true })
  * ```
  */
-export declare const blob: <O extends BlobSchemaOptions = {
-    allowLegacy?: false;
-}>(options?: O) => BlobSchema<O>;
+export declare const blob: <O extends BlobSchemaOptions = {}>(options?: O) => BlobSchema<O>;
 //# sourceMappingURL=blob.d.ts.map

package/dist/schema/blob.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"blob.d.ts","sourceRoot":"","sources":["../../src/schema/blob.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,aAAa,EACb,SAAS,EACT,eAAe,EAEhB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAGtD;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAA;IAErB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IAEjB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,YAAY,EAAE,OAAO,EAAE,aAAa,EAAE,CAAA;AACtC,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,CAAA;AAErC;;;;;;;;;;;;;;GAcG;AACH,qBAAa,UAAU,CACrB,KAAK,CAAC,QAAQ,SAAS,iBAAiB,GAAG,WAAW,CAAC,OAAO,CAAC,CAC/D,SAAQ,MAAM,CACd,QAAQ,SAAS;IAAE,WAAW,EAAE,IAAI,CAAA;CAAE,GAAG,OAAO,GAAG,aAAa,GAAG,OAAO,CAC3E;IAGa,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ;IAFvC,QAAQ,CAAC,IAAI,EAAG,MAAM,CAAS;gBAEV,OAAO,CAAC,EAAE,QAAQ,YAAA;IAIvC,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;IAwBxD,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;CAKnC;AA6CD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,IAAI,GACf,CAAC,SAAS,iBAAiB;kBAAmB,KAAK;aACzC,CAAC,kBAEX,CAAA"}
+{"version":3,"file":"blob.d.ts","sourceRoot":"","sources":["../../src/schema/blob.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,aAAa,EACb,YAAY,EAEZ,SAAS,EACT,eAAe,EACf,cAAc,EACf,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAGtD;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IAEjB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,YAAY,EAAE,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,CAAA;AACpD,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,cAAc,EAAE,CAAA;AAErD;;;;;;;;;;;;;;GAcG;AACH,qBAAa,UAAU,CACrB,KAAK,CAAC,QAAQ,SAAS,iBAAiB,GAAG,WAAW,CAAC,OAAO,CAAC,CAC/D,SAAQ,MAAM,CAAC,OAAO,CAAC;IAGX,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ;IAFvC,QAAQ,CAAC,IAAI,EAAG,MAAM,CAAS;gBAEV,OAAO,CAAC,EAAE,QAAQ,YAAA;IAIvC,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;IA8BxD,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;CAKnC;AA+BD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,IAAI,GACf,CAAC,SAAS,iBAAiB,iBACjB,CAAC,kBAEX,CAAA"}

package/dist/schema/blob.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.blob = exports.BlobSchema = exports.isLegacyBlobRef = exports.isBlobRef = void 0;
+exports.blob = exports.BlobSchema = exports.isTypedBlobRef = exports.isLegacyBlobRef = exports.isBlobRef = void 0;
 const lex_data_1 = require("@atproto/lex-data");
 Object.defineProperty(exports, "isBlobRef", { enumerable: true, get: function () { return lex_data_1.isBlobRef; } });
 Object.defineProperty(exports, "isLegacyBlobRef", { enumerable: true, get: function () { return lex_data_1.isLegacyBlobRef; } });
+Object.defineProperty(exports, "isTypedBlobRef", { enumerable: true, get: function () { return lex_data_1.isTypedBlobRef; } });
 const core_js_1 = require("../core.js");
 const memoize_js_1 = require("../util/memoize.js");
 /**
@@ -29,20 +30,28 @@ class BlobSchema extends core_js_1.Schema {
         this.options = options;
     }
     validateInContext(input, ctx) {
-        const blob = parseValue.call(ctx, input, this.options);
+        const blob = parseValue.call(ctx, input);
         if (!blob) {
             return ctx.issueUnexpectedType(input, 'blob');
         }
         // In non-strict mode, we allow blob refs to pass through without MIME
         // type or size checks.
-        if (ctx.options.strict) {
-            const accept = this.options?.accept;
+        if (ctx.options.strict && this.options != null) {
+            const { accept } = this.options;
             if (accept && !matchesMime(blob.mimeType, accept)) {
                 return ctx.issueInvalidPropertyValue(blob, 'mimeType', accept);
             }
-            const maxSize = this.options?.maxSize;
-            if (maxSize != null && 'size' in blob && blob.size > maxSize) {
-                return ctx.issueTooBig(blob, 'blob', maxSize, blob.size);
+            const { maxSize } = this.options;
+            if (maxSize != null) {
+                const size = (0, lex_data_1.getBlobSize)(blob);
+                if (size === undefined) {
+                    // Unable to enforce size constraint if size is not available (legacy
+                    // blob ref), so we treat it as a validation failure in strict mode.
+                    return ctx.issueInvalidPropertyType(blob, 'size', 'integer');
+                }
+                else if (size > maxSize) {
+                    return ctx.issueTooBig(blob, 'blob', maxSize, size);
+                }
             }
         }
         return ctx.success(blob);
@@ -55,30 +64,19 @@ class BlobSchema extends core_js_1.Schema {
     }
 }
 exports.BlobSchema = BlobSchema;
-function parseValue(input, options) {
-    // If there is a $type property, we treat if as a potential BlobRef and
+function parseValue(input) {
+    // If there is a $type property, we treat if as a potential TypedBlobRef and
     // validate accordingly.
     if (input?.$type !== undefined) {
         // Use the context's option for the "strict" check
-        return (0, lex_data_1.isBlobRef)(input, this.options) ? input : null;
+        return (0, lex_data_1.isTypedBlobRef)(input, this.options) ? input : null;
     }
     // If there is no $type property, we may be dealing with a legacy blob ref. If
-    // legacy refs are allowed, validate against the legacy format. If not
-    // allowed, but we are in non-strict "parse" mode, coerce legacy refs into
-    // standard BlobRef format for backward compatibility. Otherwise, reject the
-    // value.
-    if (options?.allowLegacy) {
-        if ((0, lex_data_1.isLegacyBlobRef)(input)) {
+    // legacy refs are allowed (non-strict mode), we check if the input matches
+    // the legacy format.
+    if (!this.options.strict) {
+        if ((0, lex_data_1.isLegacyBlobRef)(input, this.options))
             return input;
-        }
-    }
-    else if (!this.options.strict && this.options.mode === 'parse') {
-        if ((0, lex_data_1.isLegacyBlobRef)(input)) {
-            const { cid, mimeType } = input;
-            const ref = (0, lex_data_1.parseCidSafe)(cid);
-            if (ref)
-                return { $type: 'blob', ref, mimeType, size: -1 };
-        }
     }
     return null;
 }
@@ -113,9 +111,6 @@ function matchesMime(mime, accepted) {
  *
  * // Any image type with size limit
  * const avatarSchema = l.blob({ accept: ['image/*'], maxSize: 1000000 })
- *
- * // Allow legacy format
- * const legacySchema = l.blob({ allowLegacy: true })
  * ```
  */
 exports.blob = (0, memoize_js_1.memoizedOptions)(function (options) {

package/dist/schema/blob.js.map

@@ -1 +1 @@
-{"version":3,"file":"blob.js","sourceRoot":"","sources":["../../src/schema/blob.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  BlobRef,\n  LegacyBlobRef,\n  isBlobRef,\n  isLegacyBlobRef,\n  parseCidSafe,\n} from '@atproto/lex-data'\nimport { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\n/**\n * Configuration options for blob schema validation.\n */\nexport type BlobSchemaOptions = {\n  /**\n   * Whether to allow legacy blob references format\n   *\n   * @default false\n   * @see {@link LegacyBlobRef}\n   */\n  allowLegacy?: boolean\n\n  /**\n   * List of accepted MIME types (supports wildcards like 'image/*' or '*\\/*')\n   *\n   * @default undefined // accepts all MIME types\n   */\n  accept?: string[]\n\n  /**\n   * Maximum blob size in bytes\n   *\n   * @default undefined // no size limit\n   */\n  maxSize?: number\n}\n\nexport type { BlobRef, LegacyBlobRef }\nexport { isBlobRef, isLegacyBlobRef }\n\n/**\n * Schema for validating blob references in AT Protocol.\n *\n * Validates BlobRef objects which contain a CID reference to binary data,\n * along with metadata like MIME type and size. Can optionally accept\n * legacy blob reference format.\n *\n * @template TOptions - The configuration options type\n *\n * @example\n * ```ts\n * const schema = new BlobSchema({ accept: ['image/*'], maxSize: 1000000 })\n * const result = schema.validate(blobRef)\n * ```\n */\nexport class BlobSchema<\n  const TOptions extends BlobSchemaOptions = NonNullable<unknown>,\n> extends Schema<\n  TOptions extends { allowLegacy: true } ? BlobRef | LegacyBlobRef : BlobRef\n> {\n  readonly type = 'blob' as const\n\n  constructor(readonly options?: TOptions) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    const blob = parseValue.call(ctx, input, this.options)\n\n    if (!blob) {\n      return ctx.issueUnexpectedType(input, 'blob')\n    }\n\n    // In non-strict mode, we allow blob refs to pass through without MIME\n    // type or size checks.\n    if (ctx.options.strict) {\n      const accept = this.options?.accept\n      if (accept && !matchesMime(blob.mimeType, accept)) {\n        return ctx.issueInvalidPropertyValue(blob, 'mimeType', accept)\n      }\n\n      const maxSize = this.options?.maxSize\n      if (maxSize != null && 'size' in blob && blob.size > maxSize) {\n        return ctx.issueTooBig(blob, 'blob', maxSize, blob.size)\n      }\n    }\n\n    return ctx.success(blob)\n  }\n\n  matchesMime(mime: string): boolean {\n    const accept = this.options?.accept\n    if (!accept) return true\n    return matchesMime(mime, accept)\n  }\n}\n\nfunction parseValue(\n  this: ValidationContext,\n  input: unknown,\n  options?: BlobSchemaOptions,\n): BlobRef | LegacyBlobRef | null {\n  // If there is a $type property, we treat if as a potential BlobRef and\n  // validate accordingly.\n  if ((input as any)?.$type !== undefined) {\n    // Use the context's option for the \"strict\" check\n    return isBlobRef(input, this.options) ? input : null\n  }\n\n  // If there is no $type property, we may be dealing with a legacy blob ref. If\n  // legacy refs are allowed, validate against the legacy format. If not\n  // allowed, but we are in non-strict \"parse\" mode, coerce legacy refs into\n  // standard BlobRef format for backward compatibility. Otherwise, reject the\n  // value.\n  if (options?.allowLegacy) {\n    if (isLegacyBlobRef(input)) {\n      return input\n    }\n  } else if (!this.options.strict && this.options.mode === 'parse') {\n    if (isLegacyBlobRef(input)) {\n      const { cid, mimeType } = input\n      const ref = parseCidSafe(cid)\n      if (ref) return { $type: 'blob', ref, mimeType, size: -1 }\n    }\n  }\n\n  return null\n}\n\nfunction matchesMime(mime: string, accepted: string[]): boolean {\n  if (accepted.includes('*/*')) return true\n  if (accepted.includes(mime)) return true\n  for (const value of accepted) {\n    if (value.endsWith('/*') && mime.startsWith(value.slice(0, -1))) {\n      return true\n    }\n  }\n  return false\n}\n\n/**\n * Creates a blob schema for validating blob references with optional constraints.\n *\n * Blob references are used in AT Protocol to reference binary data stored\n * separately from records. They contain a CID, MIME type, and size information.\n *\n * @param options - Optional configuration for MIME type filtering and size limits\n * @returns A new {@link BlobSchema} instance\n *\n * @example\n * ```ts\n * // Basic blob reference\n * const fileSchema = l.blob()\n *\n * // Image files only\n * const imageSchema = l.blob({ accept: ['image/png', 'image/jpeg', 'image/gif'] })\n *\n * // Any image type with size limit\n * const avatarSchema = l.blob({ accept: ['image/*'], maxSize: 1000000 })\n *\n * // Allow legacy format\n * const legacySchema = l.blob({ allowLegacy: true })\n * ```\n */\nexport const blob = /*#__PURE__*/ memoizedOptions(function <\n  O extends BlobSchemaOptions = { allowLegacy?: false },\n>(options?: O) {\n  return new BlobSchema(options)\n})\n"]}
+{"version":3,"file":"blob.js","sourceRoot":"","sources":["../../src/schema/blob.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  BlobRef,\n  LegacyBlobRef,\n  TypedBlobRef,\n  getBlobSize,\n  isBlobRef,\n  isLegacyBlobRef,\n  isTypedBlobRef,\n} from '@atproto/lex-data'\nimport { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\n/**\n * Configuration options for blob schema validation.\n */\nexport type BlobSchemaOptions = {\n  /**\n   * List of accepted MIME types (supports wildcards like 'image/*' or '*\\/*')\n   *\n   * @default undefined // accepts all MIME types\n   */\n  accept?: string[]\n\n  /**\n   * Maximum blob size in bytes\n   *\n   * @default undefined // no size limit\n   */\n  maxSize?: number\n}\n\nexport type { BlobRef, LegacyBlobRef, TypedBlobRef }\nexport { isBlobRef, isLegacyBlobRef, isTypedBlobRef }\n\n/**\n * Schema for validating blob references in AT Protocol.\n *\n * Validates BlobRef objects which contain a CID reference to binary data,\n * along with metadata like MIME type and size. Can optionally accept\n * legacy blob reference format.\n *\n * @template TOptions - The configuration options type\n *\n * @example\n * ```ts\n * const schema = new BlobSchema({ accept: ['image/*'], maxSize: 1000000 })\n * const result = schema.validate(blobRef)\n * ```\n */\nexport class BlobSchema<\n  const TOptions extends BlobSchemaOptions = NonNullable<unknown>,\n> extends Schema<BlobRef> {\n  readonly type = 'blob' as const\n\n  constructor(readonly options?: TOptions) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    const blob = parseValue.call(ctx, input)\n    if (!blob) {\n      return ctx.issueUnexpectedType(input, 'blob')\n    }\n\n    // In non-strict mode, we allow blob refs to pass through without MIME\n    // type or size checks.\n    if (ctx.options.strict && this.options != null) {\n      const { accept } = this.options\n      if (accept && !matchesMime(blob.mimeType, accept)) {\n        return ctx.issueInvalidPropertyValue(blob, 'mimeType', accept)\n      }\n\n      const { maxSize } = this.options\n      if (maxSize != null) {\n        const size = getBlobSize(blob)\n        if (size === undefined) {\n          // Unable to enforce size constraint if size is not available (legacy\n          // blob ref), so we treat it as a validation failure in strict mode.\n          return ctx.issueInvalidPropertyType(blob, 'size' as any, 'integer')\n        } else if (size > maxSize) {\n          return ctx.issueTooBig(blob, 'blob', maxSize, size)\n        }\n      }\n    }\n\n    return ctx.success(blob)\n  }\n\n  matchesMime(mime: string): boolean {\n    const accept = this.options?.accept\n    if (!accept) return true\n    return matchesMime(mime, accept)\n  }\n}\n\nfunction parseValue(this: ValidationContext, input: unknown): BlobRef | null {\n  // If there is a $type property, we treat if as a potential TypedBlobRef and\n  // validate accordingly.\n  if ((input as any)?.$type !== undefined) {\n    // Use the context's option for the \"strict\" check\n    return isTypedBlobRef(input, this.options) ? input : null\n  }\n\n  // If there is no $type property, we may be dealing with a legacy blob ref. If\n  // legacy refs are allowed (non-strict mode), we check if the input matches\n  // the legacy format.\n  if (!this.options.strict) {\n    if (isLegacyBlobRef(input, this.options)) return input\n  }\n\n  return null\n}\n\nfunction matchesMime(mime: string, accepted: string[]): boolean {\n  if (accepted.includes('*/*')) return true\n  if (accepted.includes(mime)) return true\n  for (const value of accepted) {\n    if (value.endsWith('/*') && mime.startsWith(value.slice(0, -1))) {\n      return true\n    }\n  }\n  return false\n}\n\n/**\n * Creates a blob schema for validating blob references with optional constraints.\n *\n * Blob references are used in AT Protocol to reference binary data stored\n * separately from records. They contain a CID, MIME type, and size information.\n *\n * @param options - Optional configuration for MIME type filtering and size limits\n * @returns A new {@link BlobSchema} instance\n *\n * @example\n * ```ts\n * // Basic blob reference\n * const fileSchema = l.blob()\n *\n * // Image files only\n * const imageSchema = l.blob({ accept: ['image/png', 'image/jpeg', 'image/gif'] })\n *\n * // Any image type with size limit\n * const avatarSchema = l.blob({ accept: ['image/*'], maxSize: 1000000 })\n * ```\n */\nexport const blob = /*#__PURE__*/ memoizedOptions(function <\n  O extends BlobSchemaOptions = NonNullable<unknown>,\n>(options?: O) {\n  return new BlobSchema(options)\n})\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/lex-schema",
-  "version": "0.0.17",
+  "version": "0.0.18",
   "license": "MIT",
   "description": "Lexicon schema system for AT Lexicons",
   "keywords": [
@@ -38,8 +38,8 @@
     "@standard-schema/spec": "^1.1.0",
     "iso-datestring-validator": "^2.2.2",
     "tslib": "^2.8.1",
-    "@atproto/syntax": "^0.5.2",
-    "@atproto/lex-data": "^0.0.14"
+    "@atproto/syntax": "^0.5.3",
+    "@atproto/lex-data": "^0.0.15"
   },
   "devDependencies": {
     "vitest": "^4.0.16"

package/src/schema/blob.test.ts

@@ -1,5 +1,5 @@
 import { assert, describe, expect, it } from 'vitest'
-import { parseCid } from '@atproto/lex-data'
+import { isLegacyBlobRef, isTypedBlobRef, parseCid } from '@atproto/lex-data'
 import { blob } from './blob.js'
 
 // await cidForRawBytes(Buffer.from('Hello, World!'))
@@ -22,12 +22,11 @@ describe('BlobSchema', () => {
         mimeType: 'image/jpeg',
         size: 10000,
       })
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value.$type).toBe('blob')
-        expect(result.value.mimeType).toBe('image/jpeg')
-        expect(result.value.size).toBe(10000)
-      }
+      assert(result.success)
+      assert(isTypedBlobRef(result.value))
+      expect(result.value.$type).toBe('blob')
+      expect(result.value.mimeType).toBe('image/jpeg')
+      expect(result.value.size).toBe(10000)
     })
 
     it('validates blob with different mime types', () => {
@@ -37,7 +36,7 @@ describe('BlobSchema', () => {
         mimeType: 'image/png',
         size: 5000,
       })
-      expect(result.success).toBe(true)
+      assert(result.success)
     })
 
     it('validates blob with size 0', () => {
@@ -47,37 +46,37 @@ describe('BlobSchema', () => {
         mimeType: 'text/plain',
         size: 0,
       })
-      expect(result.success).toBe(true)
+      assert(result.success)
     })
 
     it('rejects non-objects', () => {
       const result = schema.safeParse('not an object')
-      expect(result.success).toBe(false)
+      assert(!result.success)
     })
 
     it('rejects null', () => {
       const result = schema.safeParse(null)
-      expect(result.success).toBe(false)
+      assert(!result.success)
     })
 
     it('rejects undefined', () => {
       const result = schema.safeParse(undefined)
-      expect(result.success).toBe(false)
+      assert(!result.success)
     })
 
     it('rejects arrays', () => {
       const result = schema.safeParse([])
-      expect(result.success).toBe(false)
+      assert(!result.success)
     })
 
     it('rejects numbers', () => {
       const result = schema.safeParse(123)
-      expect(result.success).toBe(false)
+      assert(!result.success)
     })
 
     it('rejects booleans', () => {
       const result = schema.safeParse(true)
-      expect(result.success).toBe(false)
+      assert(!result.success)
     })
   })
 
@@ -90,7 +89,7 @@ describe('BlobSchema', () => {
         mimeType: 'image/jpeg',
         size: 10000,
       })
-      expect(result.success).toBe(false)
+      assert(!result.success)
     })
 
     it('rejects blob with wrong $type', () => {
@@ -100,7 +99,7 @@ describe('BlobSchema', () => {
         mimeType: 'image/jpeg',
         size: 10000,
       })
-      expect(result.success).toBe(false)
+      assert(!result.success)
     })
 
     it('rejects blob without ref', () => {
@@ -109,7 +108,7 @@ describe('BlobSchema', () => {
         mimeType: 'image/jpeg',
         size: 10000,
       })
-      expect(result.success).toBe(false)
+      assert(!result.success)
     })
 
     it('rejects blob without mimeType', () => {
@@ -118,7 +117,7 @@ describe('BlobSchema', () => {
         ref: blobCid,
         size: 10000,
       })
-      expect(result.success).toBe(false)
+      assert(!result.success)
     })
 
     it('rejects blob without size', () => {
@@ -127,7 +126,7 @@ describe('BlobSchema', () => {
         ref: blobCid,
         mimeType: 'image/jpeg',
       })
-      expect(result.success).toBe(false)
+      assert(!result.success)
     })
 
     it('rejects blob with invalid ref type', () => {
@@ -137,7 +136,7 @@ describe('BlobSchema', () => {
         mimeType: 'image/jpeg',
         size: 10000,
       })
-      expect(result.success).toBe(false)
+      assert(!result.success)
     })
 
     it('rejects blob with invalid mimeType type', () => {
@@ -147,7 +146,7 @@ describe('BlobSchema', () => {
         mimeType: 123,
         size: 10000,
       })
-      expect(result.success).toBe(false)
+      assert(!result.success)
     })
 
     it('rejects blob with invalid size type', () => {
@@ -157,7 +156,7 @@ describe('BlobSchema', () => {
         mimeType: 'image/jpeg',
         size: '10000',
       })
-      expect(result.success).toBe(false)
+      assert(!result.success)
     })
 
     it('rejects blob with negative size', () => {
@@ -167,7 +166,7 @@ describe('BlobSchema', () => {
         mimeType: 'image/jpeg',
         size: -1,
       })
-      expect(result.success).toBe(false)
+      assert(!result.success)
     })
 
     it('rejects blob with decimal size', () => {
@@ -177,7 +176,7 @@ describe('BlobSchema', () => {
         mimeType: 'image/jpeg',
         size: 10000.5,
       })
-      expect(result.success).toBe(false)
+      assert(!result.success)
     })
 
     it('rejects blob with extra properties', () => {
@@ -188,7 +187,7 @@ describe('BlobSchema', () => {
         size: 10000,
         extra: 'not allowed',
       })
-      expect(result.success).toBe(false)
+      assert(!result.success)
     })
 
     it('rejects blob with $link format for ref', () => {
@@ -198,7 +197,7 @@ describe('BlobSchema', () => {
         mimeType: 'image/jpeg',
         size: 10000,
       })
-      expect(result.success).toBe(false)
+      assert(!result.success)
     })
 
     it('rejects blob with unknown properties', () => {
@@ -209,7 +208,7 @@ describe('BlobSchema', () => {
         size: 10000,
         unknownProp: 42,
       })
-      expect(result.success).toBe(false)
+      assert(!result.success)
     })
   })
 
@@ -226,7 +225,7 @@ describe('BlobSchema', () => {
         },
         { strict: true },
       )
-      expect(result.success).toBe(true)
+      assert(result.success)
     })
 
     it('rejects non-raw CID in strict mode', () => {
@@ -239,7 +238,7 @@ describe('BlobSchema', () => {
         },
         { strict: true },
       )
-      expect(result.success).toBe(false)
+      assert(!result.success)
     })
 
     it('accepts non-raw CID in non-strict mode', () => {
@@ -252,107 +251,148 @@ describe('BlobSchema', () => {
         },
         { strict: false },
       )
-      expect(result.success).toBe(true)
-    })
-
-    it('coerces legacy blob format in non-strict parse mode', () => {
-      const result = schema.safeParse(
-        {
-          cid: lexCid.toString(),
-          mimeType: 'image/jpeg',
-        },
-        { strict: false },
-      )
       assert(result.success)
-      expect(result.value).toEqual({
-        $type: 'blob',
-        ref: lexCid,
-        mimeType: 'image/jpeg',
-        size: -1,
-      })
     })
   })
 
   describe('legacy blob format', () => {
-    it('rejects legacy format by default', () => {
+    it('rejects legacy format by default (strict mode)', () => {
       const schema = blob({})
-      const result = schema.safeParse({
+      const parseResult = schema.safeParse({
         cid: blobCid.toString(),
         mimeType: 'image/jpeg',
       })
-      expect(result.success).toBe(false)
-    })
+      assert(!parseResult.success)
 
-    it('accepts legacy format when allowLegacy is true', () => {
-      const schema = blob({ allowLegacy: true })
-      const result = schema.safeParse({
+      const validateResult = schema.safeValidate({
         cid: blobCid.toString(),
         mimeType: 'image/jpeg',
       })
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect('cid' in result.value && result.value.cid).toBe(
-          blobCid.toString(),
-        )
-        expect(result.value.mimeType).toBe('image/jpeg')
-      }
+      assert(!validateResult.success)
     })
 
-    it('accepts legacy format with lexCid when allowLegacy is true', () => {
-      const schema = blob({ allowLegacy: true })
-      const result = schema.safeParse({
-        cid: lexCid.toString(),
-        mimeType: 'image/png',
-      })
-      expect(result.success).toBe(true)
+    it('rejects legacy format when strict: true is explicit', () => {
+      const schema = blob({})
+      const parseResult = schema.safeParse(
+        {
+          cid: blobCid.toString(),
+          mimeType: 'image/jpeg',
+        },
+        { strict: true },
+      )
+      assert(!parseResult.success)
+
+      const validateResult = schema.safeValidate(
+        {
+          cid: blobCid.toString(),
+          mimeType: 'image/jpeg',
+        },
+        { strict: true },
+      )
+      assert(!validateResult.success)
     })
 
-    it('rejects legacy format without cid', () => {
-      const schema = blob({ allowLegacy: true })
-      const result = schema.safeParse({
+    it('accepts legacy format with strict: false in both parse and validate', () => {
+      const schema = blob({})
+      const parseResult = schema.safeParse(
+        {
+          cid: blobCid.toString(),
+          mimeType: 'image/jpeg',
+        },
+        { strict: false },
+      )
+      assert(parseResult.success)
+      assert(isLegacyBlobRef(parseResult.value))
+      expect(parseResult.value).toMatchObject({
+        cid: blobCid.toString(),
         mimeType: 'image/jpeg',
       })
-      expect(result.success).toBe(false)
+      expect(parseResult.value.cid).toBe(blobCid.toString())
+
+      const validateResult = schema.safeValidate(
+        {
+          cid: blobCid.toString(),
+          mimeType: 'image/jpeg',
+        },
+        { strict: false },
+      )
+      assert(validateResult.success)
+      assert(isLegacyBlobRef(validateResult.value))
+    })
+
+    it('accepts legacy format with lexCid in non-strict mode', () => {
+      const schema = blob({})
+      const result = schema.safeParse(
+        {
+          cid: lexCid.toString(),
+          mimeType: 'image/png',
+        },
+        { strict: false },
+      )
+      assert(result.success)
+    })
+
+    it('rejects legacy format without cid', () => {
+      const schema = blob({})
+      const result = schema.safeParse(
+        {
+          mimeType: 'image/jpeg',
+        },
+        { strict: false },
+      )
+      assert(!result.success)
     })
 
     it('rejects legacy format without mimeType', () => {
-      const schema = blob({ allowLegacy: true })
-      const result = schema.safeParse({
-        cid: blobCid.toString(),
-      })
-      expect(result.success).toBe(false)
+      const schema = blob({})
+      const result = schema.safeParse(
+        {
+          cid: blobCid.toString(),
+        },
+        { strict: false },
+      )
+      assert(!result.success)
     })
 
     it('rejects legacy format with invalid cid', () => {
-      const schema = blob({ allowLegacy: true })
-      const result = schema.safeParse({
-        cid: 'invalid-cid',
-        mimeType: 'image/jpeg',
-      })
-      expect(result.success).toBe(false)
+      const schema = blob({})
+      const result = schema.safeParse(
+        {
+          cid: 'invalid-cid',
+          mimeType: 'image/jpeg',
+        },
+        { strict: false },
+      )
+      assert(!result.success)
     })
 
     it('rejects legacy format with numeric cid', () => {
-      const schema = blob({ allowLegacy: true })
-      const result = schema.safeParse({
-        cid: 123,
-        mimeType: 'image/jpeg',
-      })
-      expect(result.success).toBe(false)
+      const schema = blob({})
+      const result = schema.safeParse(
+        {
+          cid: 123,
+          mimeType: 'image/jpeg',
+        },
+        { strict: false },
+      )
+      assert(!result.success)
     })
 
     it('rejects legacy format with extra properties', () => {
-      const schema = blob({ allowLegacy: true })
-      const result = schema.safeParse({
-        cid: blobCid.toString(),
-        mimeType: 'image/jpeg',
-        extra: 'not allowed',
-      })
-      expect(result.success).toBe(false)
+      const schema = blob({})
+      const result = schema.safeParse(
+        {
+          cid: blobCid.toString(),
+          mimeType: 'image/jpeg',
+          extra: 'not allowed',
+        },
+        { strict: false },
+      )
+      assert(!result.success)
     })
 
-    it('accepts both BlobRef and LegacyBlobRef formats when allowLegacy is true', () => {
-      const schema = blob({ allowLegacy: true })
+    it('accepts standard BlobRef always, LegacyBlobRef only with strict: false', () => {
+      const schema = blob({})
 
       const blobRefResult = schema.safeParse({
         $type: 'blob',
@@ -360,13 +400,22 @@ describe('BlobSchema', () => {
         mimeType: 'image/jpeg',
         size: 10000,
       })
-      expect(blobRefResult.success).toBe(true)
+      assert(blobRefResult.success)
 
-      const legacyResult = schema.safeParse({
+      const legacyResultStrict = schema.safeParse({
         cid: blobCid.toString(),
         mimeType: 'image/jpeg',
       })
-      expect(legacyResult.success).toBe(true)
+      assert(!legacyResultStrict.success)
+
+      const legacyResultNonStrict = schema.safeParse(
+        {
+          cid: blobCid.toString(),
+          mimeType: 'image/jpeg',
+        },
+        { strict: false },
+      )
+      assert(legacyResultNonStrict.success)
     })
   })
 
@@ -379,7 +428,7 @@ describe('BlobSchema', () => {
         mimeType: 'image/gif',
         size: 10000,
       })
-      expect(result.success).toBe(false)
+      assert(!result.success)
     })
 
     it('accepts blob with maxSize option (not enforced)', () => {
@@ -390,7 +439,7 @@ describe('BlobSchema', () => {
         mimeType: 'image/jpeg',
         size: 10000,
       })
-      expect(result.success).toBe(false)
+      assert(!result.success)
     })
 
     it('accepts blob matching accept constraint', () => {
@@ -401,7 +450,7 @@ describe('BlobSchema', () => {
         mimeType: 'image/jpeg',
         size: 10000,
       })
-      expect(result.success).toBe(true)
+      assert(result.success)
     })
 
     it('accepts blob matching maxSize constraint', () => {
@@ -412,7 +461,7 @@ describe('BlobSchema', () => {
         mimeType: 'image/jpeg',
         size: 10000,
       })
-      expect(result.success).toBe(true)
+      assert(result.success)
     })
   })
 
@@ -426,17 +475,17 @@ describe('BlobSchema', () => {
         mimeType: 'video/mp4',
         size: Number.MAX_SAFE_INTEGER,
       })
-      expect(result.success).toBe(true)
+      assert(result.success)
     })
 
     it('rejects empty object', () => {
       const result = schema.safeParse({})
-      expect(result.success).toBe(false)
+      assert(!result.success)
     })
 
     it('rejects object with only $type', () => {
       const result = schema.safeParse({ $type: 'blob' })
-      expect(result.success).toBe(false)
+      assert(!result.success)
     })
 
     it('rejects blob with empty mimeType', () => {
@@ -446,7 +495,7 @@ describe('BlobSchema', () => {
         mimeType: '',
         size: 10000,
       })
-      expect(result.success).toBe(false)
+      assert(!result.success)
     })
 
     it('rejects blob with null ref', () => {
@@ -456,7 +505,7 @@ describe('BlobSchema', () => {
         mimeType: 'image/jpeg',
         size: 10000,
       })
-      expect(result.success).toBe(false)
+      assert(!result.success)
     })
 
     it('rejects blob with null mimeType', () => {
@@ -466,7 +515,7 @@ describe('BlobSchema', () => {
         mimeType: null,
         size: 10000,
       })
-      expect(result.success).toBe(false)
+      assert(!result.success)
     })
 
     it('rejects blob with null size', () => {
@@ -476,171 +525,82 @@ describe('BlobSchema', () => {
         mimeType: 'image/jpeg',
         size: null,
       })
-      expect(result.success).toBe(false)
+      assert(!result.success)
     })
   })
 
   describe('legacy blob format with strict mode combinations', () => {
-    describe('allowLegacy: false (default)', () => {
-      const schema = blob()
+    const schema = blob()
 
-      describe('strict: true (default)', () => {
-        it('rejects legacy blob format', () => {
-          const result = schema.safeParse({
-            cid: blobCid.toString(),
-            mimeType: 'image/jpeg',
-          })
-          expect(result.success).toBe(false)
+    describe('strict: true (default)', () => {
+      it('rejects legacy blob format by default', () => {
+        const parseResult = schema.safeParse({
+          cid: blobCid.toString(),
+          mimeType: 'image/jpeg',
         })
+        assert(!parseResult.success)
 
-        it('accepts standard BlobRef', () => {
-          const result = schema.safeParse({
-            $type: 'blob',
-            ref: blobCid,
-            mimeType: 'image/jpeg',
-            size: 10000,
-          })
-          expect(result.success).toBe(true)
+        const validateResult = schema.safeValidate({
+          cid: blobCid.toString(),
+          mimeType: 'image/jpeg',
         })
+        assert(!validateResult.success)
       })
 
-      describe('strict: false', () => {
-        it('coerces legacy blob format into BlobRef', () => {
-          const result = schema.safeParse(
-            {
-              cid: blobCid.toString(),
-              mimeType: 'image/jpeg',
-            },
-            { strict: false },
-          )
-          assert(result.success)
-          expect(result.value).toEqual({
-            $type: 'blob',
-            ref: blobCid,
-            mimeType: 'image/jpeg',
-            size: -1,
-          })
-        })
-
-        it('coerces legacy blob format with lexCid', () => {
-          const result = schema.safeParse(
-            {
-              cid: lexCid.toString(),
-              mimeType: 'image/png',
-            },
-            { strict: false },
-          )
-          assert(result.success)
-          expect(result.value).toEqual({
-            $type: 'blob',
-            ref: lexCid,
-            mimeType: 'image/png',
-            size: -1,
-          })
-        })
-
-        it('rejects legacy blob format with invalid cid', () => {
-          const result = schema.safeParse(
-            {
-              cid: 'invalid-cid',
-              mimeType: 'image/jpeg',
-            },
-            { strict: false },
-          )
-          expect(result.success).toBe(false)
-        })
-
-        it('accepts standard BlobRef with non-raw CID', () => {
-          const result = schema.safeParse(
-            {
-              $type: 'blob',
-              ref: lexCid,
-              mimeType: 'image/jpeg',
-              size: 10000,
-            },
-            { strict: false },
-          )
-          expect(result.success).toBe(true)
+      it('accepts standard BlobRef', () => {
+        const result = schema.safeParse({
+          $type: 'blob',
+          ref: blobCid,
+          mimeType: 'image/jpeg',
+          size: 10000,
         })
+        assert(result.success)
       })
     })
 
-    describe('allowLegacy: true', () => {
-      const schema = blob({ allowLegacy: true })
-
-      describe('strict: true (default)', () => {
-        it('accepts legacy blob format as LegacyBlobRef', () => {
-          const result = schema.safeParse({
+    describe('strict: false', () => {
+      it('accepts legacy blob format in both parse and validate', () => {
+        const parseResult = schema.safeParse(
+          {
             cid: blobCid.toString(),
             mimeType: 'image/jpeg',
-          })
-          assert(result.success)
-          expect('cid' in result.value && result.value.cid).toBe(
-            blobCid.toString(),
-          )
-        })
+          },
+          { strict: false },
+        )
+        assert(parseResult.success)
 
-        it('accepts standard BlobRef', () => {
-          const result = schema.safeParse({
-            $type: 'blob',
-            ref: blobCid,
+        const validateResult = schema.safeValidate(
+          {
+            cid: blobCid.toString(),
             mimeType: 'image/jpeg',
-            size: 10000,
-          })
-          expect(result.success).toBe(true)
-        })
+          },
+          { strict: false },
+        )
+        assert(validateResult.success)
+      })
+
+      it('accepts legacy blob format with lexCid', () => {
+        const result = schema.safeParse(
+          {
+            cid: lexCid.toString(),
+            mimeType: 'image/png',
+          },
+          { strict: false },
+        )
+        assert(result.success)
+      })
 
-        it('rejects non-raw CID in BlobRef format (strict)', () => {
-          const result = schema.safeParse({
+      it('accepts standard BlobRef with non-raw CID', () => {
+        const result = schema.safeParse(
+          {
             $type: 'blob',
             ref: lexCid,
             mimeType: 'image/jpeg',
             size: 10000,
-          })
-          expect(result.success).toBe(false)
-        })
-      })
-
-      describe('strict: false', () => {
-        it('accepts legacy blob format as LegacyBlobRef', () => {
-          const result = schema.safeParse(
-            {
-              cid: blobCid.toString(),
-              mimeType: 'image/jpeg',
-            },
-            { strict: false },
-          )
-          assert(result.success)
-          expect('cid' in result.value && result.value.cid).toBe(
-            blobCid.toString(),
-          )
-        })
-
-        it('accepts standard BlobRef with non-raw CID (non-strict)', () => {
-          const result = schema.safeParse(
-            {
-              $type: 'blob',
-              ref: lexCid,
-              mimeType: 'image/jpeg',
-              size: 10000,
-            },
-            { strict: false },
-          )
-          expect(result.success).toBe(true)
-        })
-
-        it('accepts standard BlobRef with raw CID', () => {
-          const result = schema.safeParse(
-            {
-              $type: 'blob',
-              ref: blobCid,
-              mimeType: 'image/jpeg',
-              size: 10000,
-            },
-            { strict: false },
-          )
-          expect(result.success).toBe(true)
-        })
+          },
+          { strict: false },
+        )
+        assert(result.success)
       })
     })
   })
@@ -656,7 +616,7 @@ describe('BlobSchema', () => {
           mimeType: 'image/gif',
           size: 10000,
         })
-        expect(result.success).toBe(false)
+        assert(!result.success)
       })
 
       it('accepts non-matching mime type in non-strict mode', () => {
@@ -669,7 +629,7 @@ describe('BlobSchema', () => {
           },
           { strict: false },
         )
-        expect(result.success).toBe(true)
+        assert(result.success)
       })
 
       it('accepts matching mime type in strict mode', () => {
@@ -679,7 +639,7 @@ describe('BlobSchema', () => {
           mimeType: 'image/jpeg',
           size: 10000,
         })
-        expect(result.success).toBe(true)
+        assert(result.success)
       })
     })
 
@@ -693,7 +653,7 @@ describe('BlobSchema', () => {
           mimeType: 'image/jpeg',
           size: 5000,
         })
-        expect(result.success).toBe(false)
+        assert(!result.success)
       })
 
       it('accepts oversized blob in non-strict mode', () => {
@@ -706,7 +666,7 @@ describe('BlobSchema', () => {
           },
           { strict: false },
         )
-        expect(result.success).toBe(true)
+        assert(result.success)
       })
 
       it('accepts correctly sized blob in strict mode', () => {
@@ -716,7 +676,7 @@ describe('BlobSchema', () => {
           mimeType: 'image/jpeg',
           size: 500,
         })
-        expect(result.success).toBe(true)
+        assert(result.success)
       })
     })
 
@@ -733,7 +693,7 @@ describe('BlobSchema', () => {
           mimeType: 'image/jpeg',
           size: 10000,
         })
-        expect(result.success).toBe(true)
+        assert(result.success)
       })
 
       it('rejects wrong mime in strict mode', () => {
@@ -743,7 +703,7 @@ describe('BlobSchema', () => {
           mimeType: 'image/png',
           size: 10000,
         })
-        expect(result.success).toBe(false)
+        assert(!result.success)
       })
 
       it('rejects oversized in strict mode', () => {
@@ -753,7 +713,7 @@ describe('BlobSchema', () => {
           mimeType: 'image/jpeg',
           size: 30000,
         })
-        expect(result.success).toBe(false)
+        assert(!result.success)
       })
 
       it('accepts wrong mime and oversized in non-strict mode', () => {
@@ -766,7 +726,7 @@ describe('BlobSchema', () => {
           },
           { strict: false },
         )
-        expect(result.success).toBe(true)
+        assert(result.success)
       })
     })
   })

package/src/schema/blob.ts

@@ -1,9 +1,11 @@
 import {
   BlobRef,
   LegacyBlobRef,
+  TypedBlobRef,
+  getBlobSize,
   isBlobRef,
   isLegacyBlobRef,
-  parseCidSafe,
+  isTypedBlobRef,
 } from '@atproto/lex-data'
 import { Schema, ValidationContext } from '../core.js'
 import { memoizedOptions } from '../util/memoize.js'
@@ -12,14 +14,6 @@ import { memoizedOptions } from '../util/memoize.js'
  * Configuration options for blob schema validation.
  */
 export type BlobSchemaOptions = {
-  /**
-   * Whether to allow legacy blob references format
-   *
-   * @default false
-   * @see {@link LegacyBlobRef}
-   */
-  allowLegacy?: boolean
-
   /**
    * List of accepted MIME types (supports wildcards like 'image/*' or '*\/*')
    *
@@ -35,8 +29,8 @@ export type BlobSchemaOptions = {
   maxSize?: number
 }
 
-export type { BlobRef, LegacyBlobRef }
-export { isBlobRef, isLegacyBlobRef }
+export type { BlobRef, LegacyBlobRef, TypedBlobRef }
+export { isBlobRef, isLegacyBlobRef, isTypedBlobRef }
 
 /**
  * Schema for validating blob references in AT Protocol.
@@ -55,9 +49,7 @@ export { isBlobRef, isLegacyBlobRef }
  */
 export class BlobSchema<
   const TOptions extends BlobSchemaOptions = NonNullable<unknown>,
-> extends Schema<
-  TOptions extends { allowLegacy: true } ? BlobRef | LegacyBlobRef : BlobRef
-> {
+> extends Schema<BlobRef> {
   readonly type = 'blob' as const
 
   constructor(readonly options?: TOptions) {
@@ -65,23 +57,29 @@ export class BlobSchema<
   }
 
   validateInContext(input: unknown, ctx: ValidationContext) {
-    const blob = parseValue.call(ctx, input, this.options)
-
+    const blob = parseValue.call(ctx, input)
     if (!blob) {
       return ctx.issueUnexpectedType(input, 'blob')
     }
 
     // In non-strict mode, we allow blob refs to pass through without MIME
     // type or size checks.
-    if (ctx.options.strict) {
-      const accept = this.options?.accept
+    if (ctx.options.strict && this.options != null) {
+      const { accept } = this.options
       if (accept && !matchesMime(blob.mimeType, accept)) {
         return ctx.issueInvalidPropertyValue(blob, 'mimeType', accept)
       }
 
-      const maxSize = this.options?.maxSize
-      if (maxSize != null && 'size' in blob && blob.size > maxSize) {
-        return ctx.issueTooBig(blob, 'blob', maxSize, blob.size)
+      const { maxSize } = this.options
+      if (maxSize != null) {
+        const size = getBlobSize(blob)
+        if (size === undefined) {
+          // Unable to enforce size constraint if size is not available (legacy
+          // blob ref), so we treat it as a validation failure in strict mode.
+          return ctx.issueInvalidPropertyType(blob, 'size' as any, 'integer')
+        } else if (size > maxSize) {
+          return ctx.issueTooBig(blob, 'blob', maxSize, size)
+        }
       }
     }
 
@@ -95,33 +93,19 @@ export class BlobSchema<
   }
 }
 
-function parseValue(
-  this: ValidationContext,
-  input: unknown,
-  options?: BlobSchemaOptions,
-): BlobRef | LegacyBlobRef | null {
-  // If there is a $type property, we treat if as a potential BlobRef and
+function parseValue(this: ValidationContext, input: unknown): BlobRef | null {
+  // If there is a $type property, we treat if as a potential TypedBlobRef and
   // validate accordingly.
   if ((input as any)?.$type !== undefined) {
     // Use the context's option for the "strict" check
-    return isBlobRef(input, this.options) ? input : null
+    return isTypedBlobRef(input, this.options) ? input : null
   }
 
   // If there is no $type property, we may be dealing with a legacy blob ref. If
-  // legacy refs are allowed, validate against the legacy format. If not
-  // allowed, but we are in non-strict "parse" mode, coerce legacy refs into
-  // standard BlobRef format for backward compatibility. Otherwise, reject the
-  // value.
-  if (options?.allowLegacy) {
-    if (isLegacyBlobRef(input)) {
-      return input
-    }
-  } else if (!this.options.strict && this.options.mode === 'parse') {
-    if (isLegacyBlobRef(input)) {
-      const { cid, mimeType } = input
-      const ref = parseCidSafe(cid)
-      if (ref) return { $type: 'blob', ref, mimeType, size: -1 }
-    }
+  // legacy refs are allowed (non-strict mode), we check if the input matches
+  // the legacy format.
+  if (!this.options.strict) {
+    if (isLegacyBlobRef(input, this.options)) return input
   }
 
   return null
@@ -157,13 +141,10 @@ function matchesMime(mime: string, accepted: string[]): boolean {
  *
  * // Any image type with size limit
  * const avatarSchema = l.blob({ accept: ['image/*'], maxSize: 1000000 })
- *
- * // Allow legacy format
- * const legacySchema = l.blob({ allowLegacy: true })
  * ```
  */
 export const blob = /*#__PURE__*/ memoizedOptions(function <
-  O extends BlobSchemaOptions = { allowLegacy?: false },
+  O extends BlobSchemaOptions = NonNullable<unknown>,
 >(options?: O) {
   return new BlobSchema(options)
 })