Compatibility-Aware Protocol Layer

A lightweight module that bootstraps a container loader with a custom protocol layer enforcing audience rules, compatibility checks, and URL normalization.

Capabilities

Protocol rule enforcement

• Given a rule limiting participants, connection handling accepts clients until the limit is reached and rejects additional or improperly configured clients while keeping prior members intact @test
• After processing messages, a disconnection triggers snapshot reporting that returns the last known members, proposals, and values so callers can persist protocol state @test

Compatibility assessment

• Given runtime and driver versions, produces a report that marks runtime/driver support and lists missing feature identifiers when requirements are not satisfied @test

URL normalization

• A fluid-style URL string with id, path, query, and optional version is parsed into structured fields; malformed URLs throw a descriptive error @test

Implementation

@generates

API

export interface ProtocolRule {
  maxAudience: number;
  requiredModes?: string[];
}

export interface CompatibilityInput {
  runtimeVersion: string;
  driverVersion: string;
}

export interface CompatibilityReport {
  runtimeOk: boolean;
  driverOk: boolean;
  missing: string[];
  summary: string;
}

export interface ParsedRequest {
  id: string;
  path: string;
  query: string;
  version?: string;
}

export function buildProtocolHarness(rule: ProtocolRule): {
  handleConnect(clientId: string, mode?: string): boolean;
  handleDisconnect(clientId: string): void;
  processOp(message: any, local: boolean): { accepted: boolean };
  snapshot(): {
    members: [string, any][];
    proposals: any[];
    values: any[];
  };
};

export function assessCompatibility(input: CompatibilityInput): CompatibilityReport;

export function normalizeRequestUrl(url: string): ParsedRequest;

Dependencies { .dependencies }

@fluidframework/container-loader { .dependency }

Provides the loader protocol hooks, URL helpers, and compatibility metadata used to implement the module.