@totemsdk/edge-coap 0.1.0 → 0.3.0

package/dist/cbor.js

@@ -0,0 +1,266 @@
+/**
+ * Minimal CBOR (RFC 8949) decoder for constrained-device payloads.
+ *
+ * Supports the deterministic core used by sensors: unsigned/negative
+ * integers, byte/text strings, arrays, maps, tags (unwrapped), booleans, null,
+ * undefined, half/single/double floats and indefinite-length containers.
+ * Maps with all-text keys decode to plain objects; other maps decode to `Map`.
+ *
+ * This is a decoder, not a general CBOR library: it does not expose tag
+ * semantics and rejects malformed, truncated, duplicate-key or over-deep input.
+ */
+export class CborDecodeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CborDecodeError';
+    }
+}
+const BREAK = 0xff;
+const MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);
+export function decodeCbor(input, options = {}) {
+    if (!(input instanceof Uint8Array))
+        throw new CborDecodeError('CBOR input must be a Uint8Array');
+    const state = { offset: 0 };
+    const value = decodeItem(input, state, 0, options.maxDepth ?? 32);
+    if (state.offset !== input.length) {
+        throw new CborDecodeError(`Trailing ${input.length - state.offset} byte(s) after CBOR item`);
+    }
+    return value;
+}
+function decodeItem(input, cursor, depth, maxDepth) {
+    if (depth > maxDepth)
+        throw new CborDecodeError(`CBOR nesting exceeds ${maxDepth}`);
+    const initial = readByte(input, cursor);
+    const major = initial >> 5;
+    const additional = initial & 0x1f;
+    switch (major) {
+        case 0: {
+            const argument = readArgument(input, cursor, additional);
+            return integer(argument);
+        }
+        case 1: {
+            const argument = readArgument(input, cursor, additional);
+            const value = integer(argument);
+            if (typeof value === 'bigint')
+                return -1n - value;
+            return -1 - value;
+        }
+        case 2:
+            return decodeByteString(input, cursor, additional);
+        case 3:
+            return decodeTextString(input, cursor, additional);
+        case 4:
+            return decodeArray(input, cursor, additional, depth, maxDepth);
+        case 5:
+            return decodeMap(input, cursor, additional, depth, maxDepth);
+        case 6: {
+            // Tags are structural metadata; sensor claims do not need them. Read and
+            // unwrap, but reject indefinite tag numbers.
+            const argument = readArgument(input, cursor, additional);
+            if (argument === 'indefinite')
+                throw new CborDecodeError('Indefinite CBOR tag');
+            return decodeItem(input, cursor, depth + 1, maxDepth);
+        }
+        default:
+            return decodeSimple(input, cursor, additional);
+    }
+}
+function integer(argument) {
+    if (argument === 'indefinite')
+        throw new CborDecodeError('Indefinite CBOR integer');
+    return argument <= MAX_SAFE ? Number(argument) : argument;
+}
+function decodeByteString(input, cursor, additional) {
+    const argument = readArgument(input, cursor, additional);
+    if (argument !== 'indefinite')
+        return readBytes(input, cursor, toLength(argument, 'byte string'));
+    const chunks = [];
+    let total = 0;
+    while (!atBreak(input, cursor)) {
+        const header = peekByte(input, cursor);
+        if (header >> 5 !== 2 || (header & 0x1f) === 0x1f) {
+            throw new CborDecodeError('Indefinite CBOR byte string contains a non-definite chunk');
+        }
+        cursor.offset++;
+        const length = toLength(readArgument(input, cursor, header & 0x1f), 'byte string chunk');
+        chunks.push(readBytes(input, cursor, length));
+        total += length;
+    }
+    cursor.offset++;
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        out.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return out;
+}
+function decodeTextString(input, cursor, additional) {
+    const argument = readArgument(input, cursor, additional);
+    const decoder = new TextDecoder('utf-8', { fatal: true });
+    if (argument !== 'indefinite') {
+        return decodeUtf8(decoder, readBytes(input, cursor, toLength(argument, 'text string')));
+    }
+    let text = '';
+    while (!atBreak(input, cursor)) {
+        const header = peekByte(input, cursor);
+        if (header >> 5 !== 3 || (header & 0x1f) === 0x1f) {
+            throw new CborDecodeError('Indefinite CBOR text string contains a non-definite chunk');
+        }
+        cursor.offset++;
+        const length = toLength(readArgument(input, cursor, header & 0x1f), 'text string chunk');
+        text += decodeUtf8(decoder, readBytes(input, cursor, length));
+    }
+    cursor.offset++;
+    return text;
+}
+function decodeArray(input, cursor, additional, depth, maxDepth) {
+    const argument = readArgument(input, cursor, additional);
+    const values = [];
+    if (argument === 'indefinite') {
+        while (!atBreak(input, cursor))
+            values.push(decodeItem(input, cursor, depth + 1, maxDepth));
+        cursor.offset++;
+        return values;
+    }
+    const length = toLength(argument, 'array');
+    for (let i = 0; i < length; i++)
+        values.push(decodeItem(input, cursor, depth + 1, maxDepth));
+    return values;
+}
+function decodeMap(input, cursor, additional, depth, maxDepth) {
+    const argument = readArgument(input, cursor, additional);
+    const entries = [];
+    const readPair = () => {
+        const key = decodeItem(input, cursor, depth + 1, maxDepth);
+        const value = decodeItem(input, cursor, depth + 1, maxDepth);
+        entries.push([key, value]);
+    };
+    if (argument === 'indefinite') {
+        while (!atBreak(input, cursor))
+            readPair();
+        cursor.offset++;
+    }
+    else {
+        const length = toLength(argument, 'map');
+        for (let i = 0; i < length; i++)
+            readPair();
+    }
+    if (entries.every(([key]) => typeof key === 'string')) {
+        const object = {};
+        const keys = new Set();
+        for (const [key, value] of entries) {
+            const name = key;
+            if (name === '__proto__')
+                throw new CborDecodeError('CBOR map contains a reserved key');
+            if (keys.has(name))
+                throw new CborDecodeError(`Duplicate CBOR map key '${name}'`);
+            keys.add(name);
+            object[name] = value;
+        }
+        return object;
+    }
+    const map = new Map();
+    for (const [key, value] of entries) {
+        if (map.has(key))
+            throw new CborDecodeError('Duplicate CBOR map key');
+        map.set(key, value);
+    }
+    return map;
+}
+function decodeSimple(input, cursor, additional) {
+    switch (additional) {
+        case 20: return false;
+        case 21: return true;
+        case 22: return null;
+        case 23: return undefined;
+        case 24:
+            // Simple values outside the well-known set are not used by this profile.
+            throw new CborDecodeError(`Unsupported CBOR simple value ${readByte(input, cursor)}`);
+        case 25: {
+            const bits = readUint(input, cursor, 2);
+            return decodeFloat16(Number(bits));
+        }
+        case 26: return readFloat(input, cursor, 4).getFloat32(0, false);
+        case 27: return readFloat(input, cursor, 8).getFloat64(0, false);
+        case 31: throw new CborDecodeError('Unexpected CBOR break');
+        default: throw new CborDecodeError(`Unsupported CBOR simple value ${additional}`);
+    }
+}
+function decodeFloat16(bits) {
+    const sign = bits & 0x8000 ? -1 : 1;
+    const exponent = (bits >> 10) & 0x1f;
+    const fraction = bits & 0x3ff;
+    if (exponent === 0)
+        return sign * 2 ** -14 * (fraction / 1024);
+    if (exponent === 31)
+        return fraction === 0 ? sign * Infinity : Number.NaN;
+    return sign * 2 ** (exponent - 15) * (1 + fraction / 1024);
+}
+function readArgument(input, cursor, additional) {
+    if (additional < 24)
+        return BigInt(additional);
+    if (additional === 24)
+        return readUint(input, cursor, 1);
+    if (additional === 25)
+        return readUint(input, cursor, 2);
+    if (additional === 26)
+        return readUint(input, cursor, 4);
+    if (additional === 27)
+        return readUint(input, cursor, 8);
+    if (additional === 31)
+        return 'indefinite';
+    throw new CborDecodeError(`Reserved CBOR additional information ${additional}`);
+}
+function toLength(argument, label) {
+    if (argument > BigInt(Number.MAX_SAFE_INTEGER))
+        throw new CborDecodeError(`CBOR ${label} length is too large`);
+    const length = Number(argument);
+    if (length > 0xffffffff)
+        throw new CborDecodeError(`CBOR ${label} length is too large`);
+    return length;
+}
+function readByte(input, cursor) {
+    if (cursor.offset >= input.length)
+        throw new CborDecodeError('Truncated CBOR input');
+    return input[cursor.offset++];
+}
+function peekByte(input, cursor) {
+    if (cursor.offset >= input.length)
+        throw new CborDecodeError('Truncated CBOR input');
+    return input[cursor.offset];
+}
+function readBytes(input, cursor, length) {
+    if (cursor.offset + length > input.length)
+        throw new CborDecodeError('Truncated CBOR string');
+    const value = input.slice(cursor.offset, cursor.offset + length);
+    cursor.offset += length;
+    return value;
+}
+function readUint(input, cursor, length) {
+    if (cursor.offset + length > input.length)
+        throw new CborDecodeError('Truncated CBOR argument');
+    let value = 0n;
+    for (let i = 0; i < length; i++)
+        value = (value << 8n) | BigInt(input[cursor.offset + i]);
+    cursor.offset += length;
+    return value;
+}
+function readFloat(input, cursor, length) {
+    if (cursor.offset + length > input.length)
+        throw new CborDecodeError('Truncated CBOR float');
+    const view = new DataView(input.buffer, input.byteOffset + cursor.offset, length);
+    cursor.offset += length;
+    return view;
+}
+function atBreak(input, cursor) {
+    return peekByte(input, cursor) === BREAK;
+}
+function decodeUtf8(decoder, bytes) {
+    try {
+        return decoder.decode(bytes);
+    }
+    catch {
+        throw new CborDecodeError('Invalid UTF-8 in CBOR text string');
+    }
+}

package/dist/cjs/cbor.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Minimal CBOR (RFC 8949) decoder for constrained-device payloads.
+ *
+ * Supports the deterministic core used by sensors: unsigned/negative
+ * integers, byte/text strings, arrays, maps, tags (unwrapped), booleans, null,
+ * undefined, half/single/double floats and indefinite-length containers.
+ * Maps with all-text keys decode to plain objects; other maps decode to `Map`.
+ *
+ * This is a decoder, not a general CBOR library: it does not expose tag
+ * semantics and rejects malformed, truncated, duplicate-key or over-deep input.
+ */
+export type CborValue = null | undefined | boolean | number | bigint | string | Uint8Array | CborValue[] | {
+    [key: string]: CborValue;
+} | Map<CborValue, CborValue>;
+export interface CborDecodeOptions {
+    /** Maximum nesting depth. Default 32. */
+    maxDepth?: number;
+}
+export declare class CborDecodeError extends Error {
+    constructor(message: string);
+}
+export declare function decodeCbor(input: Uint8Array, options?: CborDecodeOptions): CborValue;

package/dist/cjs/cbor.js

@@ -0,0 +1,271 @@
+"use strict";
+/**
+ * Minimal CBOR (RFC 8949) decoder for constrained-device payloads.
+ *
+ * Supports the deterministic core used by sensors: unsigned/negative
+ * integers, byte/text strings, arrays, maps, tags (unwrapped), booleans, null,
+ * undefined, half/single/double floats and indefinite-length containers.
+ * Maps with all-text keys decode to plain objects; other maps decode to `Map`.
+ *
+ * This is a decoder, not a general CBOR library: it does not expose tag
+ * semantics and rejects malformed, truncated, duplicate-key or over-deep input.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CborDecodeError = void 0;
+exports.decodeCbor = decodeCbor;
+class CborDecodeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CborDecodeError';
+    }
+}
+exports.CborDecodeError = CborDecodeError;
+const BREAK = 0xff;
+const MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);
+function decodeCbor(input, options = {}) {
+    if (!(input instanceof Uint8Array))
+        throw new CborDecodeError('CBOR input must be a Uint8Array');
+    const state = { offset: 0 };
+    const value = decodeItem(input, state, 0, options.maxDepth ?? 32);
+    if (state.offset !== input.length) {
+        throw new CborDecodeError(`Trailing ${input.length - state.offset} byte(s) after CBOR item`);
+    }
+    return value;
+}
+function decodeItem(input, cursor, depth, maxDepth) {
+    if (depth > maxDepth)
+        throw new CborDecodeError(`CBOR nesting exceeds ${maxDepth}`);
+    const initial = readByte(input, cursor);
+    const major = initial >> 5;
+    const additional = initial & 0x1f;
+    switch (major) {
+        case 0: {
+            const argument = readArgument(input, cursor, additional);
+            return integer(argument);
+        }
+        case 1: {
+            const argument = readArgument(input, cursor, additional);
+            const value = integer(argument);
+            if (typeof value === 'bigint')
+                return -1n - value;
+            return -1 - value;
+        }
+        case 2:
+            return decodeByteString(input, cursor, additional);
+        case 3:
+            return decodeTextString(input, cursor, additional);
+        case 4:
+            return decodeArray(input, cursor, additional, depth, maxDepth);
+        case 5:
+            return decodeMap(input, cursor, additional, depth, maxDepth);
+        case 6: {
+            // Tags are structural metadata; sensor claims do not need them. Read and
+            // unwrap, but reject indefinite tag numbers.
+            const argument = readArgument(input, cursor, additional);
+            if (argument === 'indefinite')
+                throw new CborDecodeError('Indefinite CBOR tag');
+            return decodeItem(input, cursor, depth + 1, maxDepth);
+        }
+        default:
+            return decodeSimple(input, cursor, additional);
+    }
+}
+function integer(argument) {
+    if (argument === 'indefinite')
+        throw new CborDecodeError('Indefinite CBOR integer');
+    return argument <= MAX_SAFE ? Number(argument) : argument;
+}
+function decodeByteString(input, cursor, additional) {
+    const argument = readArgument(input, cursor, additional);
+    if (argument !== 'indefinite')
+        return readBytes(input, cursor, toLength(argument, 'byte string'));
+    const chunks = [];
+    let total = 0;
+    while (!atBreak(input, cursor)) {
+        const header = peekByte(input, cursor);
+        if (header >> 5 !== 2 || (header & 0x1f) === 0x1f) {
+            throw new CborDecodeError('Indefinite CBOR byte string contains a non-definite chunk');
+        }
+        cursor.offset++;
+        const length = toLength(readArgument(input, cursor, header & 0x1f), 'byte string chunk');
+        chunks.push(readBytes(input, cursor, length));
+        total += length;
+    }
+    cursor.offset++;
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        out.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return out;
+}
+function decodeTextString(input, cursor, additional) {
+    const argument = readArgument(input, cursor, additional);
+    const decoder = new TextDecoder('utf-8', { fatal: true });
+    if (argument !== 'indefinite') {
+        return decodeUtf8(decoder, readBytes(input, cursor, toLength(argument, 'text string')));
+    }
+    let text = '';
+    while (!atBreak(input, cursor)) {
+        const header = peekByte(input, cursor);
+        if (header >> 5 !== 3 || (header & 0x1f) === 0x1f) {
+            throw new CborDecodeError('Indefinite CBOR text string contains a non-definite chunk');
+        }
+        cursor.offset++;
+        const length = toLength(readArgument(input, cursor, header & 0x1f), 'text string chunk');
+        text += decodeUtf8(decoder, readBytes(input, cursor, length));
+    }
+    cursor.offset++;
+    return text;
+}
+function decodeArray(input, cursor, additional, depth, maxDepth) {
+    const argument = readArgument(input, cursor, additional);
+    const values = [];
+    if (argument === 'indefinite') {
+        while (!atBreak(input, cursor))
+            values.push(decodeItem(input, cursor, depth + 1, maxDepth));
+        cursor.offset++;
+        return values;
+    }
+    const length = toLength(argument, 'array');
+    for (let i = 0; i < length; i++)
+        values.push(decodeItem(input, cursor, depth + 1, maxDepth));
+    return values;
+}
+function decodeMap(input, cursor, additional, depth, maxDepth) {
+    const argument = readArgument(input, cursor, additional);
+    const entries = [];
+    const readPair = () => {
+        const key = decodeItem(input, cursor, depth + 1, maxDepth);
+        const value = decodeItem(input, cursor, depth + 1, maxDepth);
+        entries.push([key, value]);
+    };
+    if (argument === 'indefinite') {
+        while (!atBreak(input, cursor))
+            readPair();
+        cursor.offset++;
+    }
+    else {
+        const length = toLength(argument, 'map');
+        for (let i = 0; i < length; i++)
+            readPair();
+    }
+    if (entries.every(([key]) => typeof key === 'string')) {
+        const object = {};
+        const keys = new Set();
+        for (const [key, value] of entries) {
+            const name = key;
+            if (name === '__proto__')
+                throw new CborDecodeError('CBOR map contains a reserved key');
+            if (keys.has(name))
+                throw new CborDecodeError(`Duplicate CBOR map key '${name}'`);
+            keys.add(name);
+            object[name] = value;
+        }
+        return object;
+    }
+    const map = new Map();
+    for (const [key, value] of entries) {
+        if (map.has(key))
+            throw new CborDecodeError('Duplicate CBOR map key');
+        map.set(key, value);
+    }
+    return map;
+}
+function decodeSimple(input, cursor, additional) {
+    switch (additional) {
+        case 20: return false;
+        case 21: return true;
+        case 22: return null;
+        case 23: return undefined;
+        case 24:
+            // Simple values outside the well-known set are not used by this profile.
+            throw new CborDecodeError(`Unsupported CBOR simple value ${readByte(input, cursor)}`);
+        case 25: {
+            const bits = readUint(input, cursor, 2);
+            return decodeFloat16(Number(bits));
+        }
+        case 26: return readFloat(input, cursor, 4).getFloat32(0, false);
+        case 27: return readFloat(input, cursor, 8).getFloat64(0, false);
+        case 31: throw new CborDecodeError('Unexpected CBOR break');
+        default: throw new CborDecodeError(`Unsupported CBOR simple value ${additional}`);
+    }
+}
+function decodeFloat16(bits) {
+    const sign = bits & 0x8000 ? -1 : 1;
+    const exponent = (bits >> 10) & 0x1f;
+    const fraction = bits & 0x3ff;
+    if (exponent === 0)
+        return sign * 2 ** -14 * (fraction / 1024);
+    if (exponent === 31)
+        return fraction === 0 ? sign * Infinity : Number.NaN;
+    return sign * 2 ** (exponent - 15) * (1 + fraction / 1024);
+}
+function readArgument(input, cursor, additional) {
+    if (additional < 24)
+        return BigInt(additional);
+    if (additional === 24)
+        return readUint(input, cursor, 1);
+    if (additional === 25)
+        return readUint(input, cursor, 2);
+    if (additional === 26)
+        return readUint(input, cursor, 4);
+    if (additional === 27)
+        return readUint(input, cursor, 8);
+    if (additional === 31)
+        return 'indefinite';
+    throw new CborDecodeError(`Reserved CBOR additional information ${additional}`);
+}
+function toLength(argument, label) {
+    if (argument > BigInt(Number.MAX_SAFE_INTEGER))
+        throw new CborDecodeError(`CBOR ${label} length is too large`);
+    const length = Number(argument);
+    if (length > 0xffffffff)
+        throw new CborDecodeError(`CBOR ${label} length is too large`);
+    return length;
+}
+function readByte(input, cursor) {
+    if (cursor.offset >= input.length)
+        throw new CborDecodeError('Truncated CBOR input');
+    return input[cursor.offset++];
+}
+function peekByte(input, cursor) {
+    if (cursor.offset >= input.length)
+        throw new CborDecodeError('Truncated CBOR input');
+    return input[cursor.offset];
+}
+function readBytes(input, cursor, length) {
+    if (cursor.offset + length > input.length)
+        throw new CborDecodeError('Truncated CBOR string');
+    const value = input.slice(cursor.offset, cursor.offset + length);
+    cursor.offset += length;
+    return value;
+}
+function readUint(input, cursor, length) {
+    if (cursor.offset + length > input.length)
+        throw new CborDecodeError('Truncated CBOR argument');
+    let value = 0n;
+    for (let i = 0; i < length; i++)
+        value = (value << 8n) | BigInt(input[cursor.offset + i]);
+    cursor.offset += length;
+    return value;
+}
+function readFloat(input, cursor, length) {
+    if (cursor.offset + length > input.length)
+        throw new CborDecodeError('Truncated CBOR float');
+    const view = new DataView(input.buffer, input.byteOffset + cursor.offset, length);
+    cursor.offset += length;
+    return view;
+}
+function atBreak(input, cursor) {
+    return peekByte(input, cursor) === BREAK;
+}
+function decodeUtf8(decoder, bytes) {
+    try {
+        return decoder.decode(bytes);
+    }
+    catch {
+        throw new CborDecodeError('Invalid UTF-8 in CBOR text string');
+    }
+}

package/dist/cjs/codec.d.ts

@@ -0,0 +1,30 @@
+/**
+ * CoAP wire codec (RFC 7252 §3).
+ *
+ * Kept independent of the transport so the encoding can be exercised against
+ * RFC vectors without a socket. Only Uri-Path (option 11) is emitted; Uri-Host
+ * and Uri-Port default to the destination address, so they are not sent.
+ */
+import type { CoapMessage } from './transport.js';
+export declare const URI_HOST_OPTION = 3;
+export declare const OBSERVE_OPTION = 6;
+export declare const URI_PORT_OPTION = 7;
+export declare const OSCORE_OPTION = 9;
+export declare const BLOCK2_OPTION = 23;
+export declare const BLOCK1_OPTION = 27;
+export declare const SIZE2_OPTION = 28;
+export declare const SIZE1_OPTION = 60;
+export declare const URI_PATH_OPTION = 11;
+export declare const CONTENT_FORMAT_OPTION = 12;
+export declare const ACCEPT_OPTION = 17;
+export declare const URI_QUERY_OPTION = 15;
+export declare function tokenToKey(token: Uint8Array): string;
+export declare function encodeCoap(msg: CoapMessage): Uint8Array;
+export declare function decodeCoap(raw: Uint8Array, remote: {
+    host: string;
+    port: number;
+}): CoapMessage;
+export declare function encodeBlock(block: import('./transport.js').CoapBlockOption): number;
+export declare function decodeBlock(value: Uint8Array): import('./transport.js').CoapBlockOption;
+export declare function formatResponseCode(code: number): string;
+export declare function parseResponseCode(code: string): number;