@zlink-systems/framework 0.10.0

package/src/contracts/Channels/IZLinkChannelClient.ts

@@ -0,0 +1,6 @@
+import type { ZLinkChannelRequestCall, ZLinkSendCall } from './Calls';
+
+export interface ZLinkChannelClient {
+  sendToChannel(channelName: string, message: unknown): ZLinkSendCall;
+  requestToChannel(channelName: string, request: unknown): ZLinkChannelRequestCall;
+}

package/src/contracts/Channels/IZLinkFanoutClient.ts

@@ -0,0 +1,13 @@
+import type { ZLinkFanoutPublishCall } from './Calls';
+
+export interface ZLinkFanoutListenerStatus {
+  readonly channelName: string;
+  readonly endpoint: string;
+  readonly observedAt: Date;
+}
+
+export interface ZLinkFanoutClient {
+  publish(channelName: string, event: unknown): ZLinkFanoutPublishCall;
+  publish(channelName: string, topic: string, event: unknown): ZLinkFanoutPublishCall;
+  getListenerStatus(channelName: string): ZLinkFanoutListenerStatus;
+}

package/src/contracts/Channels/RouteCalls.ts

@@ -0,0 +1,13 @@
+import type { RoutingId } from '../Common';
+import type { ZLinkChannelRequestCall, ZLinkPublishCall, ZLinkRequestCall, ZLinkSendCall } from './Calls';
+
+export interface ZLinkRouteClient {
+  sendToNode(meshName: string, targetNodeRid: RoutingId, message: unknown): ZLinkSendCall;
+  requestToNode(meshName: string, targetNodeRid: RoutingId, request: unknown): ZLinkRequestCall;
+  sendToChannel(channelName: string, message: unknown): ZLinkSendCall;
+  requestToChannel(channelName: string, request: unknown): ZLinkChannelRequestCall;
+}
+
+export interface ZLinkSpotPublisherClient {
+  publish(meshName: string, channelName: string, topic: string, event: unknown): ZLinkPublishCall;
+}

package/src/contracts/Channels/index.ts

@@ -0,0 +1,4 @@
+export * from './Calls';
+export * from './IZLinkChannelClient';
+export * from './IZLinkFanoutClient';
+export * from './RouteCalls';

package/src/contracts/Codecs/IZLinkCodecRegistryBuilder.ts

@@ -0,0 +1,22 @@
+import type { ZLinkMessageSerializer } from './ZLinkMessageSerializer';
+import type { Type } from '../Common';
+
+export type ZLinkMessageTypeSelector = (declaredType: Type) => boolean;
+
+export interface ZLinkCodecExtension {
+  register(codecs: ZLinkCodecRegistrar): void;
+}
+
+export interface ZLinkCodecRegistryBuilder {
+  use(extension: ZLinkCodecExtension): this;
+}
+
+export interface ZLinkCodecRegistrar {
+  addSerializer(contentType: string, serializer: ZLinkMessageSerializer): this;
+  addSerializer(
+    contentType: string,
+    serializer: ZLinkMessageSerializer,
+    canSerialize: ZLinkMessageTypeSelector
+  ): this;
+  addStreamCodec(contentType: string, codec: unknown): this;
+}

package/src/contracts/Codecs/ZLinkMessageSerializer.ts

@@ -0,0 +1,6 @@
+import type { Type, ZLinkEncodedPayload } from '../Common';
+
+export interface ZLinkMessageSerializer {
+  serialize<T>(value: T): ZLinkEncodedPayload;
+  deserialize<T>(payload: ZLinkEncodedPayload, type: Type<T>): T;
+}

package/src/contracts/Codecs/index.ts

@@ -0,0 +1,2 @@
+export * from './IZLinkCodecRegistryBuilder';
+export * from './ZLinkMessageSerializer';

package/src/contracts/Common/ActorRef.ts

@@ -0,0 +1,8 @@
+import type { ActorId, RoutingId } from './CoreTypes';
+
+export interface ActorRef {
+  readonly actorId: ActorId;
+  readonly objectGeneration: bigint;
+  readonly meshName: string;
+  readonly nodeRid: RoutingId;
+}

package/src/contracts/Common/CoreTypes.ts

@@ -0,0 +1,6 @@
+export type Type<T = unknown> = new (...args: never[]) => T;
+export type RoutingId = string;
+/** Global logical Actor identity. It does not encode a Mesh or owner route. */
+export type ActorId = string;
+/** Global logical Spot identity. It is not a transport RoutingId. */
+export type SpotId = string;

package/src/contracts/Common/Message.ts

@@ -0,0 +1,9 @@
+export interface Message {
+  data(): Buffer;
+  toBytes(): Uint8Array;
+  copy(): Message;
+  size(): number;
+  isEmpty(): boolean;
+  getString(encoding?: BufferEncoding): string;
+  close(): void;
+}

package/src/contracts/Common/ZLinkEncodedPayload.ts

@@ -0,0 +1,47 @@
+import { borrowEncodedPayload, storeEncodedPayload } from './encoded-payload-storage';
+
+export class ZLinkEncodedPayload {
+  private constructor(bytes: Uint8Array) {
+    storeEncodedPayload(this, bytes);
+  }
+
+  static from(bytes: Uint8Array): ZLinkEncodedPayload {
+    return new ZLinkEncodedPayload(bytes);
+  }
+
+  data(): Uint8Array {
+    return new Uint8Array(this.stored());
+  }
+
+  toBytes(): Uint8Array {
+    return this.data();
+  }
+
+  copy(): ZLinkEncodedPayload {
+    return ZLinkEncodedPayload.from(this.stored());
+  }
+
+  size(): number {
+    return this.stored().length;
+  }
+
+  isEmpty(): boolean {
+    return this.stored().length === 0;
+  }
+
+  getString(encoding: BufferEncoding = 'utf8'): string {
+    return this.stored().toString(encoding);
+  }
+
+  close(): void {
+    // ZLinkEncodedPayload owns managed memory only; this mirrors Message-like readers.
+  }
+
+  private stored(): Buffer {
+    const payload = borrowEncodedPayload(this);
+    if (payload === undefined) {
+      throw new Error('ZLink encoded payload storage is unavailable.');
+    }
+    return payload;
+  }
+}

package/src/contracts/Common/ZLinkMessage.ts

@@ -0,0 +1,135 @@
+import type { Type } from './CoreTypes';
+import { ZLinkEncodedPayload } from './ZLinkEncodedPayload';
+
+type ZLinkMessageDecoder = <T>(type?: Type<T>) => T;
+const runtimeDecoders = new WeakMap<ZLinkMessage, ZLinkMessageDecoder>();
+const runtimeDecodedValues = new WeakMap<ZLinkMessage, unknown>();
+const runtimeDecodeFailures = new WeakMap<ZLinkMessage, unknown>();
+const runtimeDecoded = new WeakSet<ZLinkMessage>();
+const declaredMessageTypes = new WeakMap<ZLinkMessage, Type>();
+
+export class ZLinkMessage<TValue = unknown> {
+  private constructor(
+    private readonly value: TValue | undefined,
+    private readonly encoded: ZLinkEncodedPayload | undefined
+  ) {}
+
+  static from<T>(value: T, declaredType?: Type<T>): ZLinkMessage<T> {
+    const message = new ZLinkMessage(value, undefined);
+    if (declaredType !== undefined) {
+      declaredMessageTypes.set(message, declaredType);
+    }
+    return message;
+  }
+
+  static fromEncoded(payload: ZLinkEncodedPayload): ZLinkMessage {
+    return new ZLinkMessage(undefined, payload);
+  }
+
+  decode<T>(type?: Type<T>): T {
+    if (this.encoded === undefined) {
+      return this.value as T;
+    }
+    if (runtimeDecoded.has(this)) {
+      if (runtimeDecodeFailures.has(this)) {
+        throw runtimeDecodeFailures.get(this);
+      }
+      return runtimeDecodedValues.get(this) as T;
+    }
+    if (this.encoded.isEmpty()) {
+      runtimeDecoded.add(this);
+      runtimeDecodedValues.set(this, undefined);
+      return undefined as T;
+    }
+    const decoder = runtimeDecoders.get(this);
+    if (decoder !== undefined) {
+      try {
+        const value = decoder(type);
+        runtimeDecoded.add(this);
+        runtimeDecodedValues.set(this, value);
+        return value;
+      } catch (error) {
+        runtimeDecoded.add(this);
+        runtimeDecodeFailures.set(this, error);
+        throw error;
+      }
+    }
+    const text = this.encoded.getString('utf8');
+    try {
+      const value = materializeZLinkMessageValue(JSON.parse(text) as T, type);
+      runtimeDecoded.add(this);
+      runtimeDecodedValues.set(this, value);
+      return value;
+    } catch {
+      runtimeDecoded.add(this);
+      runtimeDecodedValues.set(this, text);
+      return text as T;
+    }
+  }
+
+  toEncodedPayload(): ZLinkEncodedPayload {
+    if (this.encoded !== undefined) {
+      return this.encoded;
+    }
+    if (Buffer.isBuffer(this.value) || this.value instanceof Uint8Array) {
+      return ZLinkEncodedPayload.from(this.value);
+    }
+    return ZLinkEncodedPayload.from(Buffer.from(JSON.stringify(this.value ?? null)));
+  }
+
+  isEncoded(): boolean {
+    return this.encoded !== undefined;
+  }
+}
+
+/** Internal runtime factory that preserves lazy typed decoding without exposing serializer selection. */
+export function createZLinkMessageFromEncoded(
+  payload: ZLinkEncodedPayload,
+  decoder: ZLinkMessageDecoder
+): ZLinkMessage {
+  const message = ZLinkMessage.fromEncoded(payload);
+  runtimeDecoders.set(message, decoder);
+  return message;
+}
+
+export function isZLinkMessage(value: unknown): value is ZLinkMessage {
+  return value instanceof ZLinkMessage;
+}
+
+/** Internal runtime accessor for the type explicitly retained by `ZLinkMessage.from`. */
+export function readZLinkMessageDeclaredType(message: ZLinkMessage): Type | undefined {
+  return declaredMessageTypes.get(message);
+}
+
+/**
+ * Reattaches a caller-provided DTO prototype without invoking its constructor.
+ * The wire decoder owns validation and conversion; this helper only preserves
+ * the runtime type requested by `ZLinkMessage.decode(type)`.
+ */
+export function materializeZLinkMessageValue<T>(value: T, type?: Type<T>): T {
+  if (
+    type === undefined
+    || (type as unknown) === Object
+    || value === null
+    || typeof value !== 'object'
+    || Array.isArray(value)
+  ) {
+    return value;
+  }
+
+  const prototype = (type as Type<T> & { readonly prototype?: object }).prototype;
+  if (prototype === undefined || prototype === Object.prototype) {
+    return value;
+  }
+
+  const materialized = Object.create(prototype) as Record<string, unknown>;
+  for (const [key, item] of Object.entries(value as Record<string, unknown>)) {
+    Object.defineProperty(materialized, key, {
+      configurable: true,
+      enumerable: true,
+      value: item,
+      writable: true
+    });
+  }
+  return materialized as T;
+}

package/src/contracts/Common/ZLinkMessageMetadata.ts

@@ -0,0 +1,77 @@
+export interface ZLinkMessageMetadata {
+  readonly values: ReadonlyMap<string, string>;
+  find(key: string): string | undefined;
+}
+
+export interface ZLinkMessageMetadataPolicy {
+  canForwardSessionToActor(key: string): boolean;
+  canForwardActorToSession(key: string): boolean;
+}
+
+class ImmutableZLinkMessageMetadata implements ZLinkMessageMetadata {
+  readonly values: ReadonlyMap<string, string>;
+
+  constructor(values: ReadonlyMap<string, string> | Readonly<Record<string, string>> = new Map()) {
+    this.values = Object.freeze(new ImmutableMetadataMap(values));
+  }
+
+  find(key: string): string | undefined {
+    return this.values.get(key);
+  }
+}
+
+class ImmutableMetadataMap implements ReadonlyMap<string, string> {
+  readonly #values: Map<string, string>;
+
+  constructor(values: ReadonlyMap<string, string> | Readonly<Record<string, string>>) {
+    this.#values = new Map(
+      typeof (values as ReadonlyMap<string, string>)[Symbol.iterator] === 'function'
+        ? values as ReadonlyMap<string, string>
+        : Object.entries(values)
+    );
+  }
+
+  get size(): number {
+    return this.#values.size;
+  }
+
+  get(key: string): string | undefined {
+    return this.#values.get(key);
+  }
+
+  has(key: string): boolean {
+    return this.#values.has(key);
+  }
+
+  forEach(
+    callbackfn: (value: string, key: string, map: ReadonlyMap<string, string>) => void,
+    thisArg?: unknown
+  ): void {
+    this.#values.forEach((value, key) => callbackfn.call(thisArg, value, key, this));
+  }
+
+  entries(): MapIterator<[string, string]> {
+    return this.#values.entries();
+  }
+
+  keys(): MapIterator<string> {
+    return this.#values.keys();
+  }
+
+  values(): MapIterator<string> {
+    return this.#values.values();
+  }
+
+  [Symbol.iterator](): MapIterator<[string, string]> {
+    return this.#values[Symbol.iterator]();
+  }
+}
+
+export const ZLinkMessageMetadataEmpty: ZLinkMessageMetadata =
+  Object.freeze(new ImmutableZLinkMessageMetadata());
+
+export function zlinkMessageMetadata(
+  values: ReadonlyMap<string, string> | Readonly<Record<string, string>>
+): ZLinkMessageMetadata {
+  return Object.freeze(new ImmutableZLinkMessageMetadata(values));
+}

package/src/contracts/Common/ZLinkProviderResolver.ts

@@ -0,0 +1,6 @@
+import type { Type } from './CoreTypes';
+
+export interface ZLinkProviderResolver {
+  get?<T>(type: Type<T>): T | undefined;
+  create?<T>(type: Type<T>): T | Promise<T>;
+}

package/src/contracts/Common/encoded-payload-storage.ts

@@ -0,0 +1,16 @@
+const encodedPayloadStorage = new WeakMap<object, Buffer>();
+
+export function storeEncodedPayload(owner: object, bytes: Uint8Array): Buffer {
+  const stored = Buffer.from(bytes);
+  encodedPayloadStorage.set(owner, stored);
+  return stored;
+}
+
+export function adoptEncodedPayload(owner: object, bytes: Buffer): Buffer {
+  encodedPayloadStorage.set(owner, bytes);
+  return bytes;
+}
+
+export function borrowEncodedPayload(owner: object): Buffer | undefined {
+  return encodedPayloadStorage.get(owner);
+}

package/src/contracts/Common/index.ts

@@ -0,0 +1,5 @@
+export * from './ActorRef';
+export * from './CoreTypes';
+export * from './ZLinkEncodedPayload';
+export * from './ZLinkMessageMetadata';
+export { ZLinkMessage, isZLinkMessage } from './ZLinkMessage';

package/src/contracts/Configuration/Builders.ts

@@ -0,0 +1,200 @@
+import type { ZLinkActor, ZLinkActorFactory } from '../Actors';
+import type {
+  ZLinkEntrySpot,
+  ZLinkInstanceSpot,
+  ZLinkSpot
+} from '../Spots';
+import type { ZLinkSession, ZLinkSessionFactory, ZLinkStreamCompressionCodec } from '../Streams';
+import type { ZLinkEndpointConnections } from './Connections';
+import type { ZLinkCodecRegistryBuilder } from '../Codecs';
+import type { ZLinkDispatchOptionsBuilder, ZLinkInboundDispatchOptions } from '../Dispatch';
+import type {
+  ZLinkLocationOptions,
+  ZLinkLocationStore,
+  ZLinkRelocationStore
+} from '../Locations';
+import type { RoutingId, Type } from '../Common';
+import type { ZLinkWorkerOptions } from './RegistrationTypes';
+import type { ZLinkSpotPublisherConfig } from './Configs';
+import type {
+  ZLinkActorFactoryBuilder,
+  ZLinkInstanceSpotFactoryBuilder,
+  ZLinkUserSpotFactoryBuilder
+} from './ObjectRoles';
+import type {
+  ZLinkRequestHandler,
+  ZLinkRouteRequestHandler,
+  ZLinkRouteSendHandler,
+  ZLinkSendHandler
+} from '../Handlers';
+
+export interface ZLinkFrameworkOptions {
+  codecs(): ZLinkCodecRegistryBuilder;
+  configureNetwork(): ZLinkNetworkOptions;
+  /**
+   * Configures the bounded worker-thread pool used by `runCpuWorker(...)`.
+   * I/O workers do not consume these threads.
+   */
+  configureWorker(options: ZLinkWorkerOptions): this;
+  configureDispatch(): ZLinkDispatchOptionsBuilder;
+  configureInboundDispatch(): ZLinkInboundDispatchOptions;
+  addLocationStore(store: ZLinkLocationStore): this;
+  addRelocationStore(store: ZLinkRelocationStore): this;
+  setApplicationVersion(version: bigint): this;
+  setMaintenanceWave(waveId: string): this;
+  setActorTransferTimeout(timeoutMs: number): this;
+  /** Sets how long Message Follow relays traffic from the previous owner. */
+  setMessageFollowDuration(timeoutMs: number): this;
+  /** Sets the maximum duration for a replaced Session callback before its connection is closed. */
+  setSessionReplacementCallbackTimeout(timeoutMs: number): this;
+  configureLocations(): ZLinkLocationOptions;
+  configureStreamCompression(): ZLinkStreamCompressionBuilder;
+  addRouteMesh(meshName: string): ZLinkMeshNodeBuilder;
+  addClientServerChannel(name: string): ZLinkClientServerChannelRoleBuilder;
+  addFanoutChannel(name: string): ZLinkFanoutChannelBuilder;
+  addStreamNode(name: string): ZLinkStreamNodeBuilder;
+}
+
+export interface ZLinkClientServerChannelRoleBuilder {
+  client(): ZLinkClientServerChannelClientBuilder;
+  server(): ZLinkClientServerChannelServerBuilder;
+}
+
+export interface ZLinkClientServerChannelClientBuilder {
+  connect(endpoint: string): this;
+}
+
+export interface ZLinkClientServerChannelServerBuilder {
+  listen(port?: number): this;
+  setBindHost(bindHost: string): this;
+  setAdvertiseHost(advertiseHost: string): this;
+  setWeight(weight: number): this;
+  addHandlerGroup(groupName: string): this;
+  addSendHandler<TMessage>(handlerType: Type<ZLinkSendHandler<TMessage>>): this;
+  addRequestHandler<TRequest, TReply>(handlerType: Type<ZLinkRequestHandler<TRequest, TReply>>): this;
+}
+
+export interface ZLinkMeshPeerConnection {
+  readonly endpoint: string;
+  readonly expectedRoutingId?: RoutingId;
+}
+
+export interface ZLinkMeshPeerConnections {
+  connect(endpoint: string): void;
+  connect(expectedRoutingId: RoutingId, endpoint: string): void;
+  disconnect(endpoint: string): void;
+  listConnections(): readonly ZLinkMeshPeerConnection[];
+}
+
+export interface ZLinkMeshChannelBuilder {
+  client(): ZLinkMeshChannelClientBuilder;
+  server(): ZLinkMeshChannelServerBuilder;
+}
+
+export interface ZLinkMeshChannelClientBuilder {}
+
+export interface ZLinkMeshChannelServerBuilder {
+  setWeight(weight: number): this;
+  addHandlerGroup(groupName: string): this;
+  addSendHandler<TMessage>(handlerType: Type<ZLinkSendHandler<TMessage>>): this;
+  addRequestHandler<TRequest, TReply>(handlerType: Type<ZLinkRequestHandler<TRequest, TReply>>): this;
+}
+
+export interface ZLinkMeshNodeSocketConfig {
+  sendHighWaterMark: number;
+  receiveHighWaterMark: number;
+  mailboxMessageBudget: number;
+  mailboxByteBudget: number;
+  receiveTimeoutMs?: number;
+  sendTimeoutMs?: number;
+}
+
+export interface ZLinkStreamSocketConfig {
+  maxMessageSize: number;
+}
+
+export interface ZLinkMeshNodeBuilder {
+  channel(channelName: string): ZLinkMeshChannelBuilder;
+  listen(endpoint: string): this;
+  listen(port?: number): this;
+  setBindHost(bindHost: string): this;
+  setAdvertiseHost(advertiseHost: string): this;
+  routingId(routingId: RoutingId): this;
+  setRoutingIdPrefix(prefix: string): this;
+  setPlacementWeight(weight: number): this;
+  setActorLimit(limit: number): this;
+  setSpotLimit(limit: number): this;
+  setActivationConcurrency(limit: number): this;
+  setInstanceSpotIdleTimeout(timeoutMs: number): this;
+  configureRouterSocket(): ZLinkMeshNodeSocketConfig;
+  configureSpotPublisher(): ZLinkSpotPublisherConfig;
+  peerConnections(): ZLinkMeshPeerConnections;
+  setDefaultRequestTimeout(timeoutMs: number): this;
+  objects(): ZLinkMeshObjectRoleBuilder;
+  addRouteSendHandler<TMessage>(handlerType: Type<ZLinkRouteSendHandler<TMessage>>): this;
+  addRouteRequestHandler<TRequest, TReply>(handlerType: Type<ZLinkRouteRequestHandler<TRequest, TReply>>): this;
+}
+
+export interface ZLinkNetworkOptions {
+  bindHost: string;
+  advertiseHost?: string;
+}
+
+export interface ZLinkMeshObjectRoleBuilder {
+  client(): ZLinkMeshObjectClientBuilder;
+  server(): ZLinkMeshObjectServerBuilder;
+}
+
+export interface ZLinkMeshObjectClientBuilder {}
+
+export interface ZLinkMeshObjectServerBuilder {
+  addEntrySpot<TEntrySpot extends ZLinkEntrySpot>(entrySpotType: Type<TEntrySpot>): this;
+  addSpotFactory<TSpot extends ZLinkSpot>(
+    spotType: string,
+    implementation: Type<TSpot>,
+    configure: (builder: ZLinkUserSpotFactoryBuilder<TSpot>) => void
+  ): this;
+  addInstanceSpotFactory<TSpot extends ZLinkInstanceSpot>(
+    instanceSpotType: string,
+    implementation: Type<TSpot>,
+    configure: (builder: ZLinkInstanceSpotFactoryBuilder<TSpot>) => void
+  ): this;
+  addActorFactory<TActor extends ZLinkActor>(
+    actorType: string,
+    implementation: Type<ZLinkActorFactory<TActor>>,
+    configure: (builder: ZLinkActorFactoryBuilder<TActor>) => void
+  ): this;
+}
+
+export interface ZLinkMetadataPolicyBuilder {
+  allowSessionToActor(key: string): this;
+  allowActorToSession(key: string): this;
+}
+
+export interface ZLinkStreamCompressionBuilder {
+  useDefault(): this;
+  useLz4(): this;
+  use(codec: ZLinkStreamCompressionCodec): this;
+  disable(): this;
+}
+
+export interface ZLinkFanoutChannelBuilder {
+  enablePublisher(endpointOrPort?: string | number): this;
+  setBindHost(bindHost: string): this;
+  setAdvertiseHost(advertiseHost: string): this;
+  routingId(routingId: string): this;
+  setRoutingIdPrefix(prefix: string): this;
+  enableSubscriber(): this;
+  connect(endpoint: string): this;
+  subscriberConnections(): ZLinkEndpointConnections;
+}
+
+export interface ZLinkStreamNodeBuilder {
+  bind(endpointOrPort?: string | number): this;
+  setBindHost(bindHost: string): this;
+  setAdvertiseHost(advertiseHost: string): this;
+  configureSocket(): ZLinkStreamSocketConfig;
+  enableActorDispatch(): this;
+  setTlsServer(certificatePath: string, keyPath: string, requireClientCertificate?: boolean): this;
+  registerSession<TSession extends ZLinkSession>(sessionType: Type<TSession> | Type<ZLinkSessionFactory<TSession>>): this;
+}

package/src/contracts/Configuration/CodecContentType.ts

@@ -0,0 +1,68 @@
+import { ZLinkConfigurationException } from './ConfigurationException';
+
+const mediaTypePunctuation = new Set(
+  [..."!#$%&'*+-.^_`|~"].map((value) => value.charCodeAt(0))
+);
+
+export function normalizeCodecContentType(contentType: string): string {
+  if (typeof contentType !== 'string') {
+    throw invalidContentType();
+  }
+  let first = 0;
+  let last = contentType.length;
+  while (first < last && isOuterWhitespace(contentType.charCodeAt(first))) first += 1;
+  while (last > first && isOuterWhitespace(contentType.charCodeAt(last - 1))) last -= 1;
+
+  const value = contentType.slice(first, last);
+  let slash = -1;
+  let normalized = '';
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code === 0x2f) {
+      if (slash !== -1 || index === 0 || index === value.length - 1) {
+        throw invalidContentType();
+      }
+      slash = index;
+      normalized += '/';
+      continue;
+    }
+    if (!isTokenCharacter(code)) throw invalidContentType();
+    normalized += code >= 0x41 && code <= 0x5a
+      ? String.fromCharCode(code + 0x20)
+      : value[index]!;
+  }
+  if (slash === -1) throw invalidContentType();
+  return normalized;
+}
+
+export function isCanonicalCodecContentType(contentType: string): boolean {
+  if (typeof contentType !== 'string' || contentType.length === 0) return false;
+  let slash = -1;
+  for (let index = 0; index < contentType.length; index += 1) {
+    const code = contentType.charCodeAt(index);
+    if (code === 0x2f) {
+      if (slash !== -1 || index === 0 || index === contentType.length - 1) return false;
+      slash = index;
+      continue;
+    }
+    if (!isTokenCharacter(code) || (code >= 0x41 && code <= 0x5a)) return false;
+  }
+  return slash !== -1;
+}
+
+function isOuterWhitespace(code: number): boolean {
+  return code === 0x20 || code === 0x09;
+}
+
+function isTokenCharacter(code: number): boolean {
+  return (code >= 0x30 && code <= 0x39)
+    || (code >= 0x41 && code <= 0x5a)
+    || (code >= 0x61 && code <= 0x7a)
+    || mediaTypePunctuation.has(code);
+}
+
+function invalidContentType(): ZLinkConfigurationException {
+  return new ZLinkConfigurationException(
+    'Codec content type must be a parameter-free ASCII type/subtype.'
+  );
+}