refactor: DASL spec conformance

.changeset/brave-dots-learn.md

···
+---
+'@atcute/cid': minor
+'@atcute/car': minor
+'@atcute/cbor': minor
+---
+
+update to DASL spec 2025-10-20
+
+- remove support for empty CIDs (zero-length digests), which were removed from the spec
+- reject `Infinity` values in CBOR encoder (in addition to `NaN`)
+- optimize streamed CAR reader by removing buffer concatenation for CID reads

packages/utilities/car/lib/index.ts

···
+// implements github:darobin/dasl.ing@cc66c35 (2025-10-20)
+
 export * from './reader.js';
 export * from './streamed-reader.js';
 

packages/utilities/car/lib/reader.ts

···
 };
 
 const readCid = (reader: SyncByteReader): CID.Cid => {
-	const head = reader.exactly(4, false);
+	const bytes = reader.exactly(36, true);
 
-	const version = head[0];
-	const codec = head[1];
-	const digestType = head[2];
-	const digestSize = head[3];
+	const version = bytes[0];
+	const codec = bytes[1];
+	const digestType = bytes[2];
+	const digestSize = bytes[3];
 
 	if (version !== CID.CID_VERSION) {
 		throw new RangeError(`incorrect cid version (got v${version})`);
···
 		throw new RangeError(`incorrect cid digest type (got 0x${digestType.toString(16)})`);
 	}
 
-	if (digestSize !== 32 && digestSize !== 0) {
+	if (digestSize !== 32) {
 		throw new RangeError(`incorrect cid digest size (got ${digestSize})`);
 	}
 
-	const bytes = reader.exactly(4 + digestSize, true);
-	const digest = bytes.subarray(4, 4 + digestSize);
-
-	const cid: CID.Cid = {
+	return {
 		version: version,
 		codec: codec,
 		digest: {
 			codec: digestType,
-			contents: digest,
+			contents: bytes.subarray(4, 36),
 		},
 		bytes: bytes,
 	};
-
-	return cid;
 };

packages/utilities/car/lib/streamed-reader.ts

···
 import * as CBOR from '@atcute/cbor';
 import type { Cid, CidLink } from '@atcute/cid';
 import * as CID from '@atcute/cid';
-import { concat } from '@atcute/uint8array';
 
 import { isCarV1Header, type CarEntry, type CarHeader } from './types.js';
 
···
 	};
 
 	const readCid = async (): Promise<Cid> => {
-		const head = await readExact(4);
+		const bytes = await readExact(36);
 
-		const version = head[0];
-		const codec = head[1];
-		const digestType = head[2];
-		const digestSize = head[3];
+		const version = bytes[0];
+		const codec = bytes[1];
+		const digestType = bytes[2];
+		const digestSize = bytes[3];
 
 		if (version !== CID.CID_VERSION) {
 			throw new RangeError(`incorrect cid version (got v${version})`);
···
 			throw new RangeError(`incorrect cid digest type (got 0x${digestType.toString(16)})`);
 		}
 
-		if (digestSize !== 32 && digestSize !== 0) {
+		if (digestSize !== 32) {
 			throw new RangeError(`incorrect cid digest size (got ${digestSize})`);
 		}
 
-		// concatenate and have digest refer back to this buffer
-		const bytes = concat([head, await readExact(digestSize)]);
-		const digest = bytes.subarray(4, 4 + digestSize);
-
-		const cid: Cid = {
+		return {
 			version: version,
 			codec: codec,
 			digest: {
 				codec: digestType,
-				contents: digest,
+				contents: bytes.subarray(4, 36),
 			},
 			bytes: bytes,
 		};
-
-		return cid;
 	};
 
 	return {

packages/utilities/cbor/lib/encode.ts

···
 const _max = Math.max;
 
 const _isInteger = Number.isInteger;
-const _isNaN = Number.isNaN;
+const _isFinite = Number.isFinite;
 
 const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
 const MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER;
···
 };
 
 const writeNumber = (state: State, val: number): void => {
-	if (_isNaN(val)) {
-		throw new RangeError(`NaN values not supported`);
+	if (!_isFinite(val)) {
+		throw new RangeError(`NaN and Infinity values not supported`);
 	}
 
 	if (val > MAX_SAFE_INTEGER || val < MIN_SAFE_INTEGER) {

packages/utilities/cbor/lib/index.ts

···
+// implements github:darobin/dasl.ing@cc66c35 (2025-10-20)
+
 export { CidLinkWrapper, fromCidLink, isCidLink, toCidLink, type CidLink } from '@atcute/cid';
 
 export { BytesWrapper, fromBytes, isBytes, toBytes, type Bytes } from './bytes.js';

packages/utilities/cid/lib/codec.test.ts

···
 import { describe, expect, it } from 'vitest';
 
-import { create, createEmpty, decode, fromString, toString } from './codec.js';
+import { create, decode, fromString, toString } from './codec.js';
 
 describe('fromString', () => {
 	it('parses a CIDv1 string', () => {
···
 		});
 	});
 
-	it('parses an empty CIDv1 string', () => {
-		const cid = fromString('bafyreaa');
-
-		expect(cid).toEqual({
-			version: 1,
-			codec: 113,
-			digest: {
-				codec: 18,
-				contents: Uint8Array.from([]),
-			},
-			bytes: Uint8Array.from([1, 113, 18, 0]),
-		});
-	});
-
 	it('fails on non-v1 CID string', () => {
 		expect(() => fromString('QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n')).toThrow(
-			`not a multibase base32 string`,
+			`not a valid cid string`,
 		);
+	});
+
+	it('fails on empty CID string', () => {
+		expect(() => fromString('bafyreaa')).toThrow(`not a valid cid string`);
 	});
 });
 
···
 		});
 	});
 
-	it('decodes an empty CIDv1', () => {
+	it('fails on empty CIDv1', () => {
 		const buf = Uint8Array.from([1, 113, 18, 0]);
-
-		const cid = decode(buf);
-
-		expect(cid).toEqual({
-			version: 1,
-			codec: 113,
-			digest: {
-				codec: 18,
-				contents: Uint8Array.from([]),
-			},
-			bytes: Uint8Array.from([1, 113, 18, 0]),
-		});
+		expect(() => decode(buf)).toThrow(`cid too short`);
 	});
 });
 
-describe('create', () => [
+describe('create', () => {
 	it('creates a CIDv1 string', async () => {
 		const contents = new TextEncoder().encode('abc');
 		const cid = await create(113, contents);
 
 		expect(toString(cid)).toBe('bafyreif2pall7dybz7vecqka3zo24irdwabwdi4wc55jznaq75q7eaavvu');
-	}),
-
-	it('creates an empty CIDv1 string', () => {
-		const cid = createEmpty(113);
-
-		expect(toString(cid)).toBe('bafyreaa');
-	}),
-]);
+	});
+});

packages/utilities/cid/lib/codec.ts

···
 export const CID_STRINGIFY_CACHE = new WeakMap<Cid, string>();
 
 /**
- * Represents a Content Identifier (CID), in particular, a limited subset of
+ * represents a Content Identifier (CID), in particular, a limited subset of
  * CIDv1 as described by DASL specifications.
  * https://dasl.ing/cid.html
  */
···
 };
 
 /**
- * creates an empty CID with a zero-length digest
- * @param codec multicodec type for the data
- * @returns CID object with empty digest
- */
-export const createEmpty = (codec: 0x55 | 0x71): Cid => {
-	const bytes = Uint8Array.from([CID_VERSION, codec, HASH_SHA256, 0]);
-	const digest = bytes.subarray(4);
-
-	const cid: Cid = {
-		version: CID_VERSION,
-		codec: codec,
-		digest: {
-			codec: HASH_SHA256,
-			contents: digest,
-		},
-		bytes: bytes,
-	};
-
-	return cid;
-};
-
-/**
  * decodes a CID from bytes, returning the CID and any remaining bytes
  * @param bytes raw CID bytes
  * @returns tuple of decoded CID and remainder bytes
  * @throws {RangeError} if the bytes are too short or contain invalid values
  */
 export const decodeFirst = (bytes: Uint8Array): [decoded: Cid, remainder: Uint8Array] => {
-	const length = bytes.length;
-
-	if (length < 4) {
+	if (bytes.length < 36) {
 		throw new RangeError(`cid too short`);
 	}
 
···
 		throw new RangeError(`incorrect cid digest codec (got 0x${digestType.toString(16)})`);
 	}
 
-	if (digestSize !== 32 && digestSize !== 0) {
+	if (digestSize !== 32) {
 		throw new RangeError(`incorrect cid digest size (got ${digestSize})`);
 	}
 
-	if (length < 4 + digestSize) {
-		throw new RangeError(`cid too short`);
-	}
-
 	const cid: Cid = {
 		version: CID_VERSION,
 		codec: codec,
 		digest: {
 			codec: digestType,
-			contents: bytes.subarray(4, 4 + digestSize),
+			contents: bytes.subarray(4, 36),
 		},
-		bytes: bytes.subarray(0, 4 + digestSize),
+		bytes: bytes.subarray(0, 36),
 	};
 
-	return [cid, bytes.subarray(4 + digestSize)];
+	return [cid, bytes.subarray(36)];
 };
 
 /**
···
  * @throws {RangeError} if the string length is invalid
  */
 export const fromString = (input: string): Cid => {
-	if (input.length < 2 || input[0] !== 'b') {
-		throw new SyntaxError(`not a multibase base32 string`);
-	}
-
-	// 4 bytes in base32 = 7 characters + 1 character for the prefix
 	// 36 bytes in base32 = 58 characters + 1 character for the prefix
-	if (input.length !== 59 && input.length !== 8) {
-		throw new RangeError(`cid too short`);
+	if (input.length !== 59 || input[0] !== 'b') {
+		throw new SyntaxError(`not a valid cid string`);
 	}
 
 	const bytes = fromBase32(input.slice(1));
···
  * @throws {SyntaxError} if the prefix byte is not 0x00
  */
 export const fromBinary = (input: Uint8Array): Cid => {
-	// 4 bytes + 1 byte for the 0x00 prefix
 	// 36 bytes + 1 byte for the 0x00 prefix
-	if (input.length !== 37 && input.length !== 5) {
-		throw new RangeError(`cid bytes too short`);
-	}
-
-	if (input[0] !== 0) {
-		throw new SyntaxError(`incorrect binary cid`);
+	if (input.length !== 37 || input[0] !== 0) {
+		throw new SyntaxError(`invalid binary cid`);
 	}
 
-	const bytes = input.subarray(1);
-	return decode(bytes);
+	return decode(input.subarray(1));
 };
 
 /**

packages/utilities/cid/lib/index.ts

···
+// implements github:darobin/dasl.ing@cc66c35 (2025-10-20)
+
 export * from './cid-link.js';
 export * from './codec.js';