@tomgiee/tsdp 1.0.0

package/dist/src/validator/session-validator.js

@@ -0,0 +1,280 @@
+"use strict";
+/**
+ * Session validators for SDP (RFC 8866)
+ *
+ * Validates session-level fields and constraints per RFC 8866.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validResult = validResult;
+exports.invalidResult = invalidResult;
+exports.validateSessionDescription = validateSessionDescription;
+const errors_1 = require("../types/errors");
+const primitives_1 = require("../types/primitives");
+const attributes_1 = require("../types/attributes");
+const format_validators_1 = require("../utils/format-validators");
+/**
+ * Create a valid result
+ */
+function validResult() {
+    return { valid: true, errors: [] };
+}
+/**
+ * Create an invalid result with errors
+ */
+function invalidResult(errors) {
+    return { valid: false, errors };
+}
+// ============================================================================
+// Session Validator
+// ============================================================================
+/**
+ * Validate a complete session description
+ *
+ * Checks RFC 8866 Section 5 requirements:
+ * - Required fields are present (v, o, s, t)
+ * - Version is 0
+ * - At least one time description
+ * - Connection coverage (session or all media)
+ *
+ * @param session - Session description to validate
+ * @returns ValidationResult with any errors found
+ */
+function validateSessionDescription(session) {
+    const errors = [];
+    // 1. Validate version (RFC 8866 Section 5.1)
+    validateVersion(session.version, errors);
+    // 2. Validate origin (RFC 8866 Section 5.2)
+    validateOrigin(session, errors);
+    // 3. Validate session name (RFC 8866 Section 5.3)
+    validateSessionName(session, errors);
+    // 4. Validate time descriptions (RFC 8866 Section 5.9)
+    validateTimeDescriptions(session, errors);
+    // 5. Validate connection coverage (RFC 8866 Section 5.7)
+    validateConnectionCoverage(session, errors);
+    // 6. Validate bandwidths (RFC 8866 Section 5.8)
+    validateBandwidths(session, errors);
+    // 7. Validate attributes (RFC 8866 Section 6)
+    validateSessionAttributes(session, errors);
+    // 8. Validate email format (RFC 8866 Section 5.6)
+    validateEmails(session, errors);
+    // 9. Validate phone format (RFC 8866 Section 5.6)
+    validatePhones(session, errors);
+    // 10. Validate URI format (RFC 8866 Section 5.5)
+    validateUri(session, errors);
+    return errors.length === 0 ? validResult() : invalidResult(errors);
+}
+/**
+ * Validate version field
+ *
+ * RFC 8866 Section 5.1: Version MUST be 0
+ */
+function validateVersion(version, errors) {
+    if (version !== 0) {
+        errors.push(errors_1.ValidationError.invalidValue('version', version, 'SDP version must be 0', 'RFC8866:5.1'));
+    }
+}
+/**
+ * Validate origin field
+ *
+ * RFC 8866 Section 5.2: Origin is required
+ * RFC 8866 Section 9 (Grammar): sess-id = 1*DIGIT, sess-version = 1*DIGIT
+ */
+function validateOrigin(session, errors) {
+    if (!session.origin) {
+        errors.push(errors_1.ValidationError.missingField('origin', 'RFC8866:5.2'));
+        return;
+    }
+    // Validate username is not empty
+    if (!session.origin.username || session.origin.username.length === 0) {
+        errors.push(errors_1.ValidationError.invalidValue('origin.username', session.origin.username, 'Username cannot be empty', 'RFC8866:5.2'));
+    }
+    // Validate session ID is not empty and contains only digits
+    if (!session.origin.sessId || session.origin.sessId.length === 0) {
+        errors.push(errors_1.ValidationError.invalidValue('origin.sessId', session.origin.sessId, 'Session ID cannot be empty', 'RFC8866:5.2'));
+    }
+    else if (!(0, primitives_1.isNumericString)(session.origin.sessId)) {
+        errors.push(errors_1.ValidationError.invalidValue('origin.sessId', session.origin.sessId, 'Session ID must contain only digits (0-9)', 'RFC8866:5.2'));
+    }
+    // Validate session version is not empty and contains only digits
+    if (!session.origin.sessVersion || session.origin.sessVersion.length === 0) {
+        errors.push(errors_1.ValidationError.invalidValue('origin.sessVersion', session.origin.sessVersion, 'Session version cannot be empty', 'RFC8866:5.2'));
+    }
+    else if (!(0, primitives_1.isNumericString)(session.origin.sessVersion)) {
+        errors.push(errors_1.ValidationError.invalidValue('origin.sessVersion', session.origin.sessVersion, 'Session version must contain only digits (0-9)', 'RFC8866:5.2'));
+    }
+    // Validate network type
+    if (!session.origin.netType || session.origin.netType.length === 0) {
+        errors.push(errors_1.ValidationError.invalidValue('origin.netType', session.origin.netType, 'Network type cannot be empty', 'RFC8866:5.2'));
+    }
+    // Validate address type
+    if (!session.origin.addrType || session.origin.addrType.length === 0) {
+        errors.push(errors_1.ValidationError.invalidValue('origin.addrType', session.origin.addrType, 'Address type cannot be empty', 'RFC8866:5.2'));
+    }
+    // Validate unicast address
+    if (!session.origin.unicastAddress || session.origin.unicastAddress.length === 0) {
+        errors.push(errors_1.ValidationError.invalidValue('origin.unicastAddress', session.origin.unicastAddress, 'Unicast address cannot be empty', 'RFC8866:5.2'));
+    }
+}
+/**
+ * Validate session name field
+ *
+ * RFC 8866 Section 5.3: Session name is required and cannot be empty
+ * (use " " if no meaningful name)
+ */
+function validateSessionName(session, errors) {
+    if (session.sessionName === undefined || session.sessionName === null) {
+        errors.push(errors_1.ValidationError.missingField('sessionName', 'RFC8866:5.3'));
+    }
+    else if (session.sessionName.length === 0) {
+        errors.push(errors_1.ValidationError.invalidValue('sessionName', session.sessionName, 'Session name cannot be empty (use " " if no meaningful name)', 'RFC8866:5.3'));
+    }
+}
+/**
+ * Validate time descriptions
+ *
+ * RFC 8866 Section 5.9: At least one time description is required
+ */
+function validateTimeDescriptions(session, errors) {
+    if (!session.timeDescriptions || session.timeDescriptions.length === 0) {
+        errors.push(errors_1.ValidationError.constraintViolation('At least one time description (t=) is required', 'RFC8866:5.9'));
+        return;
+    }
+    // Validate each time description
+    for (let i = 0; i < session.timeDescriptions.length; i++) {
+        const td = session.timeDescriptions[i];
+        // Validate timing
+        if (!td.timing) {
+            errors.push(errors_1.ValidationError.missingField(`timeDescriptions[${i}].timing`, 'RFC8866:5.9'));
+            continue;
+        }
+        // Validate start/stop time relationship
+        const { startTime, stopTime } = td.timing;
+        if (startTime !== 0 && stopTime !== 0 && startTime > stopTime) {
+            errors.push(errors_1.ValidationError.constraintViolation(`Time description ${i}: start time (${startTime}) must be before or equal to stop time (${stopTime})`, 'RFC8866:5.9'));
+        }
+        // Validate repeat times have at least one offset
+        for (let j = 0; j < td.repeats.length; j++) {
+            const repeat = td.repeats[j];
+            if (!repeat.offsets || repeat.offsets.length === 0) {
+                errors.push(errors_1.ValidationError.constraintViolation(`Time description ${i}, repeat ${j}: at least one offset is required`, 'RFC8866:5.10'));
+            }
+        }
+        // Validate timezone adjustments
+        if (td.timezone) {
+            if (!td.timezone.adjustments || td.timezone.adjustments.length === 0) {
+                errors.push(errors_1.ValidationError.constraintViolation(`Time description ${i}: timezone field requires at least one adjustment`, 'RFC8866:5.11'));
+            }
+        }
+    }
+}
+/**
+ * Validate connection coverage
+ *
+ * RFC 8866 Section 5.7: Connection information MUST be present either
+ * at the session level OR in every media description
+ */
+function validateConnectionCoverage(session, errors) {
+    var _a;
+    const hasSessionConnection = session.connection !== undefined;
+    const mediaDescriptions = (_a = session.mediaDescriptions) !== null && _a !== void 0 ? _a : [];
+    // If no media descriptions, session-level connection is optional
+    if (mediaDescriptions.length === 0) {
+        return;
+    }
+    // If session has connection, all media are covered
+    if (hasSessionConnection) {
+        return;
+    }
+    // Check each media has connection
+    for (let i = 0; i < mediaDescriptions.length; i++) {
+        const md = mediaDescriptions[i];
+        if (!md.connections || md.connections.length === 0) {
+            errors.push(errors_1.ValidationError.constraintViolation(`Media description ${i} (${md.media.type}): connection information required when no session-level connection is present`, 'RFC8866:5.7'));
+        }
+    }
+}
+/**
+ * Validate bandwidth fields
+ *
+ * RFC 8866 Section 5.8: Bandwidth values must be non-negative
+ */
+function validateBandwidths(session, errors) {
+    for (let i = 0; i < session.bandwidths.length; i++) {
+        const bw = session.bandwidths[i];
+        if (bw.value < 0) {
+            errors.push(errors_1.ValidationError.invalidValue(`bandwidths[${i}].value`, bw.value, 'Bandwidth value must be non-negative', 'RFC8866:5.8'));
+        }
+    }
+}
+/**
+ * Validate session-level attributes
+ *
+ * RFC 8866 Section 6: Various attribute constraints including:
+ * - Only one direction attribute allowed
+ * - Media-only attributes cannot appear at session level
+ */
+function validateSessionAttributes(session, errors) {
+    const directionAttrs = ['sendrecv', 'sendonly', 'recvonly', 'inactive'];
+    let directionCount = 0;
+    for (const attr of session.attributes) {
+        // Check for multiple direction attributes (only one allowed)
+        if (attr.kind === 'property' && directionAttrs.includes(attr.name)) {
+            directionCount++;
+        }
+        // Check for media-only attributes at session level (RFC 8866 Section 6)
+        if (attributes_1.MEDIA_ONLY_ATTRIBUTES.includes(attr.name)) {
+            errors.push(errors_1.ValidationError.constraintViolation(`Attribute '${attr.name}' is only valid at media level, not session level`, 'RFC8866:6'));
+        }
+    }
+    if (directionCount > 1) {
+        errors.push(errors_1.ValidationError.constraintViolation('Only one direction attribute (sendrecv/sendonly/recvonly/inactive) allowed at session level', 'RFC8866:6.7'));
+    }
+}
+/**
+ * Validate email addresses
+ *
+ * RFC 8866 Section 5.6: Email formats
+ * RFC 8866 Section 9: email-address = address-and-comment / dispname-and-address / addr-spec
+ */
+function validateEmails(session, errors) {
+    if (!session.emails || session.emails.length === 0) {
+        return;
+    }
+    for (let i = 0; i < session.emails.length; i++) {
+        const email = session.emails[i];
+        if (!(0, format_validators_1.isValidEmailFormat)(email)) {
+            errors.push(errors_1.ValidationError.invalidValue(`emails[${i}]`, email, 'Invalid email format. Expected: addr-spec, addr-spec (comment), or Display Name <addr-spec>', 'RFC8866:5.6'));
+        }
+    }
+}
+/**
+ * Validate phone numbers
+ *
+ * RFC 8866 Section 5.6: Phone formats
+ * RFC 8866 Section 9: phone-number = phone *SP "(" 1*email-safe ")" / 1*email-safe "<" phone ">" / phone
+ */
+function validatePhones(session, errors) {
+    if (!session.phones || session.phones.length === 0) {
+        return;
+    }
+    for (let i = 0; i < session.phones.length; i++) {
+        const phone = session.phones[i];
+        if (!(0, format_validators_1.isValidPhoneFormat)(phone)) {
+            errors.push(errors_1.ValidationError.invalidValue(`phones[${i}]`, phone, 'Invalid phone format. Expected: phone, phone (comment), or Display Name <phone>', 'RFC8866:5.6'));
+        }
+    }
+}
+/**
+ * Validate URI
+ *
+ * RFC 8866 Section 5.5: URI field
+ * RFC 3986: URI-reference format
+ */
+function validateUri(session, errors) {
+    if (!session.uri) {
+        return;
+    }
+    if (!(0, format_validators_1.isValidURIReference)(session.uri)) {
+        errors.push(errors_1.ValidationError.invalidValue('uri', session.uri, 'Invalid URI format per RFC 3986', 'RFC8866:5.5'));
+    }
+}

package/dist/tests/integration/round-trip.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Integration tests for round-trip parsing, validation, and serialization
+ */
+export {};
+//# sourceMappingURL=round-trip.test.d.ts.map

package/dist/tests/integration/round-trip.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"round-trip.test.d.ts","sourceRoot":"","sources":["../../../tests/integration/round-trip.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/tests/integration/round-trip.test.js

@@ -0,0 +1,320 @@
+"use strict";
+/**
+ * Integration tests for round-trip parsing, validation, and serialization
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const src_1 = require("../../src");
+describe('Round-trip integration tests', () => {
+    describe('parse -> serialize', () => {
+        it('should round-trip minimal SDP', () => {
+            const originalSdp = [
+                'v=0',
+                'o=jdoe 2890844526 2890842807 IN IP4 10.47.16.5',
+                's=Test Session',
+                't=0 0',
+                '',
+            ].join('\r\n');
+            const parsed = (0, src_1.parseSessionDescription)(originalSdp);
+            const serialized = (0, src_1.serializeSessionDescription)(parsed);
+            expect(serialized).toBe(originalSdp);
+        });
+        it('should round-trip SDP with connection', () => {
+            const originalSdp = [
+                'v=0',
+                'o=jdoe 2890844526 2890842807 IN IP4 10.47.16.5',
+                's=Test Session',
+                'c=IN IP4 224.2.17.12/127',
+                't=0 0',
+                '',
+            ].join('\r\n');
+            const parsed = (0, src_1.parseSessionDescription)(originalSdp);
+            const serialized = (0, src_1.serializeSessionDescription)(parsed);
+            expect(serialized).toBe(originalSdp);
+        });
+        it('should round-trip SDP with media description', () => {
+            const originalSdp = [
+                'v=0',
+                'o=jdoe 2890844526 2890842807 IN IP4 10.47.16.5',
+                's=Test Session',
+                'c=IN IP4 192.168.1.1',
+                't=0 0',
+                'm=audio 49170 RTP/AVP 0 8',
+                'a=rtpmap:0 PCMU/8000',
+                'a=rtpmap:8 PCMA/8000',
+                '',
+            ].join('\r\n');
+            const parsed = (0, src_1.parseSessionDescription)(originalSdp);
+            const serialized = (0, src_1.serializeSessionDescription)(parsed);
+            expect(serialized).toBe(originalSdp);
+        });
+        it('should round-trip SDP with multiple media descriptions', () => {
+            const originalSdp = [
+                'v=0',
+                'o=jdoe 2890844526 2890842807 IN IP4 10.47.16.5',
+                's=Test Session',
+                'c=IN IP4 192.168.1.1',
+                't=0 0',
+                'm=audio 49170 RTP/AVP 0',
+                'a=rtpmap:0 PCMU/8000',
+                'm=video 51372 RTP/AVP 96',
+                'a=rtpmap:96 H264/90000',
+                '',
+            ].join('\r\n');
+            const parsed = (0, src_1.parseSessionDescription)(originalSdp);
+            const serialized = (0, src_1.serializeSessionDescription)(parsed);
+            expect(serialized).toBe(originalSdp);
+        });
+        it('should round-trip SDP with all optional fields', () => {
+            const originalSdp = [
+                'v=0',
+                'o=jdoe 2890844526 2890842807 IN IP4 10.47.16.5',
+                's=SDP Seminar',
+                'i=A seminar on SDP',
+                'u=http://www.example.com/seminars/sdp.pdf',
+                'e=j.doe@example.com',
+                'p=+1-555-1234',
+                'c=IN IP4 224.2.17.12/127',
+                'b=CT:1000',
+                't=2873397496 2873404696',
+                'a=recvonly',
+                'm=audio 49170 RTP/AVP 0',
+                'i=Audio stream',
+                'b=AS:128',
+                'a=rtpmap:0 PCMU/8000',
+                '',
+            ].join('\r\n');
+            const parsed = (0, src_1.parseSessionDescription)(originalSdp);
+            const serialized = (0, src_1.serializeSessionDescription)(parsed);
+            expect(serialized).toBe(originalSdp);
+        });
+    });
+    describe('parse -> validate -> serialize', () => {
+        it('should parse, validate, and serialize valid SDP', () => {
+            const sdpString = [
+                'v=0',
+                'o=alice 2890844526 2890842807 IN IP4 192.168.1.1',
+                's=Call',
+                'c=IN IP4 192.168.1.100',
+                't=0 0',
+                'm=audio 49170 RTP/AVP 0 8',
+                'a=rtpmap:0 PCMU/8000',
+                'a=rtpmap:8 PCMA/8000',
+                'a=sendrecv',
+                '',
+            ].join('\r\n');
+            const parsed = (0, src_1.parseSessionDescription)(sdpString);
+            const validationResult = (0, src_1.validateSdp)(parsed);
+            const serialized = (0, src_1.serializeSessionDescription)(parsed);
+            expect(validationResult.valid).toBe(true);
+            expect(validationResult.errors).toHaveLength(0);
+            expect(serialized).toBe(sdpString);
+        });
+        it('should detect validation errors in parsed SDP', () => {
+            // Create a session that will have validation issues
+            const sdpString = [
+                'v=0',
+                'o=alice 2890844526 2890842807 IN IP4 192.168.1.1',
+                's=Call',
+                'c=IN IP4 192.168.1.100',
+                't=0 0',
+                'm=audio 49170 RTP/AVP 0',
+                'a=sendrecv',
+                'a=recvonly', // Multiple direction attributes - invalid
+                '',
+            ].join('\r\n');
+            const parsed = (0, src_1.parseSessionDescription)(sdpString);
+            const validationResult = (0, src_1.validateSdp)(parsed);
+            expect(validationResult.valid).toBe(false);
+            expect(validationResult.errors.some((e) => e.constraint === 'RFC8866:6.7')).toBe(true);
+        });
+    });
+    describe('build -> validate -> serialize', () => {
+        it('should build, validate, and serialize minimal SDP', () => {
+            const session = new src_1.SessionBuilder()
+                .origin('alice', '123456789', '123456789', '192.168.1.1')
+                .sessionName('Test Call')
+                .connection('192.168.1.100')
+                .build();
+            const validationResult = (0, src_1.validateSdp)(session);
+            const serialized = (0, src_1.serializeSessionDescription)(session);
+            expect(validationResult.valid).toBe(true);
+            expect(serialized).toContain('v=0');
+            expect(serialized).toContain('o=alice 123456789 123456789 IN IP4 192.168.1.1');
+            expect(serialized).toContain('s=Test Call');
+            expect(serialized).toContain('c=IN IP4 192.168.1.100');
+            expect(serialized).toContain('t=0 0');
+        });
+        it('should build, validate, and serialize SDP with audio media', () => {
+            const session = new src_1.SessionBuilder()
+                .origin('alice', '123', '456', '192.168.1.1')
+                .sessionName('Audio Call')
+                .connection('192.168.1.100')
+                .addMediaBuilder((b) => b
+                .type('audio')
+                .port(49170)
+                .protocol('RTP/AVP')
+                .formats(['0', '8'])
+                .rtpmap(0, 'PCMU', 8000)
+                .rtpmap(8, 'PCMA', 8000)
+                .ptime(20)
+                .sendrecv())
+                .build();
+            const validationResult = (0, src_1.validateSdp)(session);
+            const serialized = (0, src_1.serializeSessionDescription)(session);
+            expect(validationResult.valid).toBe(true);
+            expect(serialized).toContain('m=audio 49170 RTP/AVP 0 8');
+            expect(serialized).toContain('a=rtpmap:0 PCMU/8000');
+            expect(serialized).toContain('a=rtpmap:8 PCMA/8000');
+            expect(serialized).toContain('a=ptime:20');
+            expect(serialized).toContain('a=sendrecv');
+        });
+        it('should build, validate, and serialize SDP with video media', () => {
+            const session = new src_1.SessionBuilder()
+                .origin('bob', '123', '456', '10.0.0.1')
+                .sessionName('Video Call')
+                .connection('10.0.0.100')
+                .addMediaBuilder((b) => b
+                .type('video')
+                .port(51372)
+                .protocol('RTP/AVP')
+                .formats(['96', '97'])
+                .rtpmap(96, 'VP8', 90000)
+                .rtpmap(97, 'H264', 90000)
+                .fmtp(97, 'profile-level-id=42e01f')
+                .framerate(30)
+                .sendrecv())
+                .build();
+            const validationResult = (0, src_1.validateSdp)(session);
+            const serialized = (0, src_1.serializeSessionDescription)(session);
+            expect(validationResult.valid).toBe(true);
+            expect(serialized).toContain('m=video 51372 RTP/AVP 96 97');
+            expect(serialized).toContain('a=rtpmap:96 VP8/90000');
+            expect(serialized).toContain('a=rtpmap:97 H264/90000');
+            expect(serialized).toContain('a=fmtp:97 profile-level-id=42e01f');
+            expect(serialized).toContain('a=framerate:30');
+        });
+        it('should build SDP with both audio and video using factory functions', () => {
+            const session = new src_1.SessionBuilder()
+                .origin('charlie', '111', '222', '172.16.0.1')
+                .sessionName('A/V Call')
+                .connection('172.16.0.50')
+                .addMedia((0, src_1.audioBuilder)()
+                .port(49170)
+                .protocol('RTP/SAVPF')
+                .formats(['111'])
+                .rtpmap(111, 'opus', 48000, 2)
+                .fmtp(111, 'minptime=10;useinbandfec=1')
+                .sendrecv()
+                .rtcpMux()
+                .build())
+                .addMedia((0, src_1.videoBuilder)()
+                .port(51372)
+                .protocol('RTP/SAVPF')
+                .formats(['96'])
+                .rtpmap(96, 'VP8', 90000)
+                .sendrecv()
+                .rtcpMux()
+                .build())
+                .build();
+            const validationResult = (0, src_1.validateSdp)(session);
+            const serialized = (0, src_1.serializeSessionDescription)(session);
+            expect(validationResult.valid).toBe(true);
+            expect(serialized).toContain('m=audio 49170 RTP/SAVPF 111');
+            expect(serialized).toContain('m=video 51372 RTP/SAVPF 96');
+            expect(serialized).toContain('a=rtcp-mux');
+        });
+    });
+    describe('build -> serialize -> parse -> validate', () => {
+        it('should complete full round-trip with builder', () => {
+            // Build
+            const original = new src_1.SessionBuilder()
+                .origin('user1', '2890844526', '2890842807', '192.168.1.1')
+                .sessionName('Round Trip Test')
+                .sessionInformation('Testing full round trip')
+                .connection('192.168.1.100')
+                .addBandwidth('CT', 1000)
+                .addTiming(0, 0)
+                .tool('tsdp/1.0')
+                .addMediaBuilder((b) => b
+                .type('audio')
+                .port(49170)
+                .protocol('RTP/AVP')
+                .formats(['0', '8', '96'])
+                .rtpmap(0, 'PCMU', 8000)
+                .rtpmap(8, 'PCMA', 8000)
+                .rtpmap(96, 'telephone-event', 8000)
+                .fmtp(96, '0-15')
+                .ptime(20)
+                .bandwidth(128)
+                .sendrecv())
+                .build();
+            // Serialize
+            const serialized = (0, src_1.serializeSessionDescription)(original);
+            // Parse
+            const parsed = (0, src_1.parseSessionDescription)(serialized);
+            // Validate
+            const validationResult = (0, src_1.validateSdp)(parsed);
+            // Assertions
+            expect(validationResult.valid).toBe(true);
+            expect(parsed.version).toBe(original.version);
+            expect(parsed.origin.username).toBe(original.origin.username);
+            expect(parsed.sessionName).toBe(original.sessionName);
+            expect(parsed.sessionInformation).toBe(original.sessionInformation);
+            expect(parsed.mediaDescriptions).toHaveLength(1);
+            expect(parsed.mediaDescriptions[0].media.type).toBe('audio');
+            expect(parsed.mediaDescriptions[0].media.formats).toEqual(['0', '8', '96']);
+        });
+    });
+    describe('validation options', () => {
+        it('should allow deprecated key field when option is set', () => {
+            const sdpString = [
+                'v=0',
+                'o=alice 123 456 IN IP4 192.168.1.1',
+                's=Test',
+                'c=IN IP4 192.168.1.100',
+                't=0 0',
+                'k=clear:password',
+                '',
+            ].join('\r\n');
+            const parsed = (0, src_1.parseSessionDescription)(sdpString);
+            // Without allowing deprecated key
+            const strictResult = (0, src_1.validateSdp)(parsed, { allowDeprecatedKeyField: false });
+            expect(strictResult.valid).toBe(false);
+            expect(strictResult.errors.some((e) => e.message.includes('deprecated'))).toBe(true);
+            // With allowing deprecated key
+            const lenientResult = (0, src_1.validateSdp)(parsed, { allowDeprecatedKeyField: true });
+            expect(lenientResult.valid).toBe(true);
+        });
+        it('should require session connection when option is set', () => {
+            const session = new src_1.SessionBuilder()
+                .origin('alice', '123', '456', '192.168.1.1')
+                .sessionName('Test')
+                .build();
+            const result = (0, src_1.validateSdp)(session, { requireSessionConnection: true });
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((e) => e.message.includes('Session-level connection'))).toBe(true);
+        });
+        it('should skip semantic validation when option is set', () => {
+            // Create session with CT < sum of AS (semantic violation)
+            const session = new src_1.SessionBuilder()
+                .origin('alice', '123', '456', '192.168.1.1')
+                .sessionName('Test')
+                .connection('192.168.1.100')
+                .addBandwidth('CT', 100)
+                .addMediaBuilder((b) => b
+                .type('audio')
+                .port(49170)
+                .protocol('RTP/AVP')
+                .formats(['0'])
+                .addBandwidth('AS', 500) // Exceeds CT
+            )
+                .build();
+            // With semantic validation
+            const withSemantic = (0, src_1.validateSdp)(session, { skipSemanticValidation: false });
+            expect(withSemantic.valid).toBe(false);
+            // Without semantic validation
+            const withoutSemantic = (0, src_1.validateSdp)(session, { skipSemanticValidation: true });
+            expect(withoutSemantic.valid).toBe(true);
+        });
+    });
+});

package/dist/tests/integration/voip-examples.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Integration tests with real-world VoIP/SIP SDP examples
+ */
+export {};
+//# sourceMappingURL=voip-examples.test.d.ts.map

package/dist/tests/integration/voip-examples.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"voip-examples.test.d.ts","sourceRoot":"","sources":["../../../tests/integration/voip-examples.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}