@serve.zone/interfaces 7.28.0 → 8.0.0

package/changelog.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 2026-07-04 - 8.0.0
+
+### Breaking Changes
+
+- introduce canonical service port routing contracts (service-ports)
+  - Add shared service target port, domain route, public port mapping, and normalization helper contracts.
+  - Update service and App Store interfaces to support targetPorts, domain target references, and publicPortMappings.
+  - Extend gateway and Coretraffic routing contracts with transport-aware port routes, routeRef ownership, and remoteIngress intent.
+  - Breaking change: legacy SSH domain routing is no longer represented through domain protocol values; public TCP/UDP exposure now uses publicPortMappings.
+
 ## 2026-06-24 - 7.28.0
 
 ### Features

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@serve.zone/interfaces',
-    version: '7.28.0',
+    version: '8.0.0',
     description: 'Shared TypeScript interfaces and TypedRequest contracts for the serve.zone ecosystem.'
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLHVGQUF1RjtDQUNyRyxDQUFBIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHVGQUF1RjtDQUNyRyxDQUFBIn0=

package/dist_ts/appstore/types.d.ts

@@ -1,3 +1,4 @@
+import type { IServiceDomainRoute, IServicePublicPortMapping, IServiceTargetPort } from '../data/serviceports.js';
 export type TAppStorePlatformRequirement = 'mongodb' | 's3' | 'clickhouse' | 'valkey' | 'mariadb';
 export type TAppStoreSourceType = 'inline' | 'repoManifest' | 'dockerImage';
 export type TAppStoreTrackingMode = 'tag' | 'digest';
@@ -98,7 +99,12 @@ export interface IAppStoreAppMeta {
 }
 export interface IAppStoreVersionConfig {
     image: string;
-    port: number;
+    /** Legacy shorthand for targetPorts.web. New templates should prefer targetPorts. */
+    port?: number;
+    targetPorts?: IServiceTargetPort[];
+    domains?: IServiceDomainRoute[];
+    /** Edge/coretraffic public TCP/UDP exposure, distinct from Docker publishedPorts. */
+    publicPortMappings?: IServicePublicPortMapping[];
     envVars?: IAppStoreEnvVar[];
     volumes?: TAppStoreVolumeSpec[];
     publishedPorts?: IAppStorePublishedPort[];
@@ -155,8 +161,10 @@ export interface IAppStoreInstallRequest {
     version?: string;
     serviceName: string;
     domain?: string;
+    /** Legacy install-time override for the web target port. */
     port?: number;
     publishedPorts?: IAppStorePublishedPort[];
+    publicPortMappings?: IServicePublicPortMapping[];
     envVars?: Record<string, string>;
 }
 export interface IUpgradeableAppStoreService {

package/dist_ts/data/gateway.d.ts

@@ -173,7 +173,10 @@ export interface IGatewayClientOwnership {
     gatewayClientId?: string;
     /** App identifier within the owning gateway client platform. */
     appId: string;
-    hostname: string;
+    /** Hostname ownership for domain routes. Preserved for existing route keys. */
+    hostname?: string;
+    /** Stable non-domain route key, for example public-port mapping exposure refs. */
+    routeRef?: string;
 }
 /**
  * A single forward target of a gateway route.
@@ -187,7 +190,8 @@ export interface IGatewayRouteTarget {
  */
 export interface IGatewayRouteMatch {
     ports: number[];
-    domains: string[];
+    domains?: string[];
+    transport?: 'tcp' | 'udp' | 'all';
     path?: string;
 }
 /**
@@ -220,6 +224,10 @@ export interface IGatewayRouteConfig {
     name: string;
     match: IGatewayRouteMatch;
     action: IGatewayRouteAction;
+    remoteIngress?: {
+        enabled: boolean;
+        edgeFilter?: string[];
+    };
 }
 /**
  * Result of an idempotent gateway route sync.

package/dist_ts/data/index.d.ts

@@ -21,6 +21,7 @@ export * from './backup.js';
 export * from './clusternode.js';
 export * from './settings.js';
 export * from './service.js';
+export * from './serviceports.js';
 export * from './status.js';
 export * from './taskexecution.js';
 export * from './traffic.js';

package/dist_ts/data/index.js

@@ -21,9 +21,10 @@ export * from './backup.js';
 export * from './clusternode.js';
 export * from './settings.js';
 export * from './service.js';
+export * from './serviceports.js';
 export * from './status.js';
 export * from './taskexecution.js';
 export * from './traffic.js';
 export * from './user.js';
 export * from './version.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9kYXRhL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxjQUFjLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9kYXRhL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLGNBQWMsQ0FBQyJ9

package/dist_ts/data/service.d.ts

@@ -3,6 +3,7 @@ import type { IRegistryTarget } from './registry.js';
 import type { IAppStorePublishedPort } from '../appstore/index.js';
 import type { IHostedAppLifecycleState } from './hostedapp.js';
 import type { IServiceMailConfig } from './mail.js';
+import type { IServiceDomainRoute, IServicePublicPortMapping, IServiceTargetPort } from './serviceports.js';
 export interface IServiceVolume {
     /** Stable Docker volume name. If omitted, Coreflow derives one from service id and mount path. */
     name?: string;
@@ -109,8 +110,21 @@ export interface IService {
         antiAffinity?: boolean;
         scaleFactor: number;
         balancingStrategy: 'round-robin' | 'least-connections';
+        /**
+         * Canonical backend/container ports for this service. New domain routes
+         * and public mappings reference these targets by name or exact port.
+         */
+        targetPorts?: IServiceTargetPort[];
         ports: {
+            /**
+             * Legacy main backend port. New writes should declare targetPorts and
+             * keep this only as compatibility shorthand during migration.
+             */
             web: number;
+            /**
+             * Legacy implicit domain-to-port routes. Runtime code must not treat
+             * this as a permissive routing source for new services.
+             */
             custom?: {
                 [domain: string]: string;
             };
@@ -118,31 +132,10 @@ export interface IService {
         mail?: IServiceMailConfig;
         volumes?: IServiceVolume[];
         publishedPorts?: IAppStorePublishedPort[];
+        /** Edge/coretraffic public TCP/UDP exposure, distinct from Docker Swarm publishedPorts. */
+        publicPortMappings?: IServicePublicPortMapping[];
         resources?: IServiceRessources;
-        domains: {
-            /**
-             * Optional domain ID to specify which domain to use
-             * If not specified, will use the default domain or require manual configuration
-             */
-            domainId?: string;
-            /**
-             * The subdomain name (e.g., 'api', 'www', '@' for root)
-             */
-            name: string;
-            /**
-             * The port to expose (defaults to ports.web if not specified)
-             */
-            port?: number;
-            /**
-             * The protocol for this domain entry
-             */
-            protocol?: 'http' | 'https' | 'ssh';
-            /**
-             * Gateway source profile for this domain's route (e.g. 'standard'
-             * for internal-only access). Defaults to the gateway's public profile.
-             */
-            sourceProfileRef?: string;
-        }[];
+        domains: IServiceDomainRoute[];
         deploymentIds: string[];
     };
 }

package/dist_ts/data/serviceports.d.ts

@@ -0,0 +1,76 @@
+export type TServiceTargetProtocol = 'http' | 'https' | 'ssh' | 'tcp' | 'udp' | `custom:${string}`;
+export type TServiceTargetPortRef = string | number;
+export interface IServiceTargetPort {
+    name: string;
+    port: number;
+    portEnd?: number;
+    protocol: TServiceTargetProtocol;
+    description?: string;
+    default?: boolean;
+}
+export interface IServiceDomainRoute {
+    domainId?: string;
+    name: string;
+    targetPort?: TServiceTargetPortRef;
+    /**
+     * Legacy backend target port. New writes must use targetPort.
+     */
+    port?: number;
+    protocol?: 'http' | 'https';
+    sourceProfileRef?: string;
+}
+export interface IServicePublicPortMapping {
+    name: string;
+    publicPort: number;
+    publicPortEnd?: number;
+    targetPort: TServiceTargetPortRef;
+    protocol: 'tcp' | 'udp';
+    sourceProfileRef?: string;
+    exclusive: true;
+}
+export interface IResolvedServiceDomainRoute extends IServiceDomainRoute {
+    targetPort: TServiceTargetPortRef;
+    target: IServiceTargetPort;
+}
+export interface IResolvedServicePublicPortMapping extends IServicePublicPortMapping {
+    target: IServiceTargetPort;
+    targetPortStart: number;
+    targetPortEnd: number;
+    publicPortEnd: number;
+}
+export interface IServicePortSourceData {
+    name?: string;
+    ports?: {
+        web?: number;
+        custom?: Record<string, string>;
+    };
+    targetPorts?: IServiceTargetPort[];
+    domains?: IServiceDomainRoute[];
+    publicPortMappings?: IServicePublicPortMapping[];
+}
+export interface INormalizedServicePortConfig {
+    targetPorts: IServiceTargetPort[];
+    defaultTargetPort?: IServiceTargetPort;
+    domains: IResolvedServiceDomainRoute[];
+    publicPortMappings: IResolvedServicePublicPortMapping[];
+}
+export interface IServicePortNormalizationOptions {
+    /**
+     * Accept legacy domains[].port only when it resolves to a declared target.
+     * Defaults to true for staged migration reads.
+     */
+    allowLegacyDomainPort?: boolean;
+    /**
+     * Domain routes are HTTP(S) virtual-host routes. Defaults to true.
+     */
+    requireHttpDomainTargets?: boolean;
+}
+export declare function normalizeServicePortConfig(serviceDataArg: IServicePortSourceData, optionsArg?: IServicePortNormalizationOptions): INormalizedServicePortConfig;
+export declare function normalizeServicePortData<T extends IServicePortSourceData>(serviceDataArg: T, optionsArg?: IServicePortNormalizationOptions): T & {
+    targetPorts: IServiceTargetPort[];
+    domains?: IServiceDomainRoute[];
+    publicPortMappings?: IServicePublicPortMapping[];
+};
+export declare function resolveServiceTargetPort(targetPortsArg: IServiceTargetPort[], refArg: TServiceTargetPortRef): IServiceTargetPort | undefined;
+export declare function resolveDefaultServiceTargetPort(targetPortsArg: IServiceTargetPort[]): IServiceTargetPort | undefined;
+export declare function isHttpServiceTargetProtocol(protocolArg: TServiceTargetProtocol): boolean;

package/dist_ts/data/serviceports.js

@@ -0,0 +1,210 @@
+export function normalizeServicePortConfig(serviceDataArg, optionsArg = {}) {
+    const options = {
+        allowLegacyDomainPort: optionsArg.allowLegacyDomainPort ?? true,
+        requireHttpDomainTargets: optionsArg.requireHttpDomainTargets ?? true,
+    };
+    const serviceName = serviceDataArg.name || 'service';
+    const targetPorts = normalizeServiceTargetPorts(serviceDataArg, serviceName);
+    const defaultTargetPort = resolveDefaultServiceTargetPort(targetPorts);
+    const domains = (serviceDataArg.domains || []).map((domainArg) => {
+        const target = resolveServiceDomainTarget(domainArg, targetPorts, defaultTargetPort, serviceName, options);
+        if (options.requireHttpDomainTargets && !isHttpServiceTargetProtocol(target.protocol)) {
+            throw new Error(`Domain ${domainArg.name} on ${serviceName} references non-HTTP target '${target.name}' (${target.protocol})`);
+        }
+        if (target.portEnd && target.portEnd !== target.port) {
+            throw new Error(`Domain ${domainArg.name} on ${serviceName} references ranged target '${target.name}'`);
+        }
+        const normalizedDomain = {
+            ...domainArg,
+            targetPort: domainArg.targetPort ?? target.name,
+            target,
+        };
+        delete normalizedDomain.port;
+        return normalizedDomain;
+    });
+    const publicPortMappings = normalizeServicePublicPortMappings(serviceDataArg.publicPortMappings || [], targetPorts, serviceName);
+    return {
+        targetPorts,
+        defaultTargetPort,
+        domains,
+        publicPortMappings,
+    };
+}
+export function normalizeServicePortData(serviceDataArg, optionsArg = {}) {
+    const normalized = normalizeServicePortConfig(serviceDataArg, optionsArg);
+    return {
+        ...serviceDataArg,
+        targetPorts: normalized.targetPorts,
+        domains: normalized.domains.map(({ target, ...domainArg }) => domainArg),
+        publicPortMappings: normalized.publicPortMappings.map(({ target, targetPortStart, targetPortEnd, ...mappingArg }) => mappingArg),
+    };
+}
+export function resolveServiceTargetPort(targetPortsArg, refArg) {
+    if (typeof refArg === 'string') {
+        const normalizedRef = refArg.trim().toLowerCase();
+        return targetPortsArg.find((targetArg) => targetArg.name.trim().toLowerCase() === normalizedRef);
+    }
+    return targetPortsArg.find((targetArg) => targetArg.port === refArg && !targetArg.portEnd);
+}
+export function resolveDefaultServiceTargetPort(targetPortsArg) {
+    const explicitDefaults = targetPortsArg.filter((targetArg) => targetArg.default);
+    if (explicitDefaults.length > 1) {
+        throw new Error(`Multiple default target ports declared: ${explicitDefaults.map((targetArg) => targetArg.name).join(', ')}`);
+    }
+    return explicitDefaults[0]
+        || targetPortsArg.find((targetArg) => targetArg.name === 'web')
+        || targetPortsArg.find((targetArg) => isHttpServiceTargetProtocol(targetArg.protocol))
+        || targetPortsArg[0];
+}
+export function isHttpServiceTargetProtocol(protocolArg) {
+    return protocolArg === 'http' || protocolArg === 'https';
+}
+function normalizeServiceTargetPorts(serviceDataArg, serviceNameArg) {
+    const declaredTargets = [...(serviceDataArg.targetPorts || [])];
+    const legacyWebPort = Number(serviceDataArg.ports?.web);
+    if (declaredTargets.length === 0 && Number.isInteger(legacyWebPort) && legacyWebPort > 0) {
+        declaredTargets.push({
+            name: 'web',
+            port: legacyWebPort,
+            protocol: 'http',
+            default: true,
+        });
+    }
+    if (declaredTargets.length === 0) {
+        return [];
+    }
+    const seenNames = new Set();
+    const seenTuples = new Set();
+    const normalizedTargets = declaredTargets.map((targetArg) => {
+        const name = targetArg.name?.trim();
+        if (!name || !/^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,62}$/.test(name)) {
+            throw new Error(`Invalid target port name '${targetArg.name}' on ${serviceNameArg}`);
+        }
+        const normalizedName = name.toLowerCase();
+        if (seenNames.has(normalizedName)) {
+            throw new Error(`Duplicate target port name '${name}' on ${serviceNameArg}`);
+        }
+        seenNames.add(normalizedName);
+        const port = assertValidServicePort(targetArg.port, `target port ${name} on ${serviceNameArg}`);
+        const portEnd = targetArg.portEnd === undefined
+            ? undefined
+            : assertValidServicePort(targetArg.portEnd, `target port end ${name} on ${serviceNameArg}`);
+        if (portEnd !== undefined && portEnd < port) {
+            throw new Error(`target port range '${name}' on ${serviceNameArg} must be ascending`);
+        }
+        const protocol = targetArg.protocol || 'tcp';
+        const tuple = `${protocol}:${port}:${portEnd || port}`;
+        if (seenTuples.has(tuple)) {
+            throw new Error(`Duplicate target port tuple ${tuple} on ${serviceNameArg}`);
+        }
+        seenTuples.add(tuple);
+        return {
+            ...targetArg,
+            name,
+            port,
+            portEnd,
+            protocol,
+        };
+    });
+    if (!normalizedTargets.some((targetArg) => targetArg.default)) {
+        const webTarget = normalizedTargets.find((targetArg) => targetArg.name === 'web');
+        if (webTarget) {
+            webTarget.default = true;
+        }
+    }
+    return normalizedTargets;
+}
+function resolveServiceDomainTarget(domainArg, targetPortsArg, defaultTargetPortArg, serviceNameArg, optionsArg) {
+    const domainName = domainArg.name || '(unnamed domain)';
+    if (!targetPortsArg.length) {
+        throw new Error(`Domain ${domainName} on ${serviceNameArg} requires at least one declared target port`);
+    }
+    if (domainArg.targetPort !== undefined) {
+        const target = resolveServiceTargetPort(targetPortsArg, domainArg.targetPort);
+        if (!target) {
+            throw new Error(`Domain ${domainName} on ${serviceNameArg} references undeclared targetPort '${domainArg.targetPort}'`);
+        }
+        return target;
+    }
+    if (domainArg.port !== undefined) {
+        if (!optionsArg.allowLegacyDomainPort) {
+            throw new Error(`Domain ${domainName} on ${serviceNameArg} uses legacy port; use targetPort instead`);
+        }
+        const legacyPort = Number(domainArg.port);
+        const target = resolveServiceTargetPort(targetPortsArg, legacyPort);
+        if (!target) {
+            throw new Error(`Domain ${domainName} on ${serviceNameArg} references undeclared legacy port ${domainArg.port}`);
+        }
+        return target;
+    }
+    if (!defaultTargetPortArg) {
+        throw new Error(`Domain ${domainName} on ${serviceNameArg} has no targetPort and no default target port exists`);
+    }
+    return defaultTargetPortArg;
+}
+function normalizeServicePublicPortMappings(mappingsArg, targetPortsArg, serviceNameArg) {
+    const seenNames = new Set();
+    const seenPublicPorts = new Set();
+    return mappingsArg.map((mappingArg) => {
+        const name = mappingArg.name?.trim();
+        if (!name || !/^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,62}$/.test(name)) {
+            throw new Error(`Invalid public port mapping name '${mappingArg.name}' on ${serviceNameArg}`);
+        }
+        const normalizedName = name.toLowerCase();
+        if (seenNames.has(normalizedName)) {
+            throw new Error(`Duplicate public port mapping '${name}' on ${serviceNameArg}`);
+        }
+        seenNames.add(normalizedName);
+        if (mappingArg.exclusive !== true) {
+            throw new Error(`Public port mapping '${name}' on ${serviceNameArg} must be exclusive`);
+        }
+        if (!['tcp', 'udp'].includes(mappingArg.protocol)) {
+            throw new Error(`Public port mapping '${name}' on ${serviceNameArg} has unsupported protocol '${mappingArg.protocol}'`);
+        }
+        const target = resolveServiceTargetPort(targetPortsArg, mappingArg.targetPort);
+        if (!target) {
+            throw new Error(`Public port mapping '${name}' on ${serviceNameArg} references undeclared targetPort '${mappingArg.targetPort}'`);
+        }
+        const publicPort = assertValidServicePort(mappingArg.publicPort, `public port ${name} on ${serviceNameArg}`);
+        const targetStart = target.port;
+        const targetEnd = target.portEnd || target.port;
+        const publicPortEnd = mappingArg.publicPortEnd === undefined
+            ? publicPort + (targetEnd - targetStart)
+            : assertValidServicePort(mappingArg.publicPortEnd, `public port end ${name} on ${serviceNameArg}`);
+        if (publicPortEnd < publicPort) {
+            throw new Error(`Public port mapping '${name}' on ${serviceNameArg} must have an ascending public range`);
+        }
+        if ((publicPortEnd - publicPort) !== (targetEnd - targetStart)) {
+            throw new Error(`Public and target port ranges must have the same length for mapping '${name}' on ${serviceNameArg}`);
+        }
+        for (let offset = 0; offset <= publicPortEnd - publicPort; offset++) {
+            const key = `${mappingArg.protocol}:${publicPort + offset}`;
+            if (seenPublicPorts.has(key)) {
+                throw new Error(`Duplicate public port ${publicPort + offset}/${mappingArg.protocol} on ${serviceNameArg}`);
+            }
+            seenPublicPorts.add(key);
+        }
+        return {
+            ...mappingArg,
+            name,
+            publicPort,
+            publicPortEnd,
+            protocol: mappingArg.protocol,
+            target,
+            targetPortStart: targetStart,
+            targetPortEnd: targetEnd,
+        };
+    }).sort((a, b) => {
+        return a.protocol.localeCompare(b.protocol)
+            || a.publicPort - b.publicPort
+            || a.name.localeCompare(b.name);
+    });
+}
+function assertValidServicePort(portArg, labelArg) {
+    const port = Number(portArg);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error(`Invalid ${labelArg}: ${portArg}. Expected an integer between 1 and 65535.`);
+    }
+    return port;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"serviceports.js","sourceRoot":"","sources":["../../ts/data/serviceports.ts"],"names":[],"mappings":"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"}

package/dist_ts/data/traffic.d.ts

@@ -1,4 +1,11 @@
 import * as plugins from '../plugins.js';
 interface IReverseProxyConfig extends plugins.tsclass.network.IReverseProxyConfig {
 }
+export interface ICoretrafficPortRouteConfig {
+    name: string;
+    listenPort: number;
+    transport: 'tcp' | 'udp';
+    destinationIps: string[];
+    destinationPort: number;
+}
 export { type IReverseProxyConfig };

package/dist_ts/data/traffic.js

@@ -1,3 +1,3 @@
 import * as plugins from '../plugins.js';
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhZmZpYy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL2RhdGEvdHJhZmZpYy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGVBQWUsQ0FBQztBQUl6QyxPQUFPLEVBQTRCLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhZmZpYy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL2RhdGEvdHJhZmZpYy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGVBQWUsQ0FBQztBQVl6QyxPQUFPLEVBQTRCLENBQUMifQ==

package/dist_ts/requests/routing.d.ts

@@ -1,8 +1,9 @@
-import { type IReverseProxyConfig } from '../data/traffic.js';
+import { type ICoretrafficPortRouteConfig, type IReverseProxyConfig } from '../data/traffic.js';
 export interface IRequest_Coreflow_Coretraffic_RoutingUpdate {
     method: 'updateRouting';
     request: {
         reverseConfigs: IReverseProxyConfig[];
+        portRoutes?: ICoretrafficPortRouteConfig[];
     };
     response: {
         status: 'ok' | 'error';
@@ -19,6 +20,7 @@ export interface IRequest_Coretraffic_Coreflow_GetCurrentRouting {
     request: Record<string, never>;
     response: {
         reverseConfigs: IReverseProxyConfig[];
+        portRoutes?: ICoretrafficPortRouteConfig[];
     };
 }
 /**

package/dist_ts/requests/routing.js

@@ -1,2 +1,2 @@
 import {} from '../data/traffic.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGluZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL3JlcXVlc3RzL3JvdXRpbmcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUE0QixNQUFNLG9CQUFvQixDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGluZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL3JlcXVlc3RzL3JvdXRpbmcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUE4RCxNQUFNLG9CQUFvQixDQUFDIn0=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serve.zone/interfaces",
-  "version": "7.28.0",
+  "version": "8.0.0",
   "private": false,
   "description": "Shared TypeScript interfaces and TypedRequest contracts for the serve.zone ecosystem.",
   "exports": {
@@ -17,7 +17,7 @@
   "devDependencies": {
     "@git.zone/tsbuild": "^4.4.2",
     "@git.zone/tsdoc": "^2.1.1",
-    "@git.zone/tsrun": "^2.0.4",
+    "@git.zone/tsrun": "^2.0.5",
     "@git.zone/tstest": "^3.6.6",
     "@types/node": "^25.9.2"
   },

package/readme.md

@@ -52,13 +52,36 @@ const service: data.IService = {
     deploymentStrategy: 'limited-replicas',
     scaleFactor: 2,
     balancingStrategy: 'round-robin',
+    targetPorts: [
+      {
+        name: 'web',
+        port: 3000,
+        protocol: 'http',
+        default: true,
+      },
+      {
+        name: 'ssh',
+        port: 2222,
+        protocol: 'ssh',
+      },
+    ],
     ports: {
-      web: 3000,
+      web: 3000, // legacy compatibility shorthand during migration
     },
     domains: [
       {
         name: 'api',
         protocol: 'https',
+        targetPort: 'web',
+      },
+    ],
+    publicPortMappings: [
+      {
+        name: 'ssh-public',
+        publicPort: 2222,
+        targetPort: 'ssh',
+        protocol: 'tcp',
+        exclusive: true,
       },
     ],
     deploymentIds: [],
@@ -70,13 +93,29 @@ Common data contracts include:
 
 - `ICluster` and `IClusterNode` for cluster membership and provisioning state.
 - `IService`, `IDeployment`, `IImage`, `IRegistryTarget`, and `IExternalRegistry` for workload delivery.
+- Service port contracts including `IServiceTargetPort`, `IServiceDomainRoute`, and `IServicePublicPortMapping` for canonical backend targets, domain target references, and edge/Coretraffic TCP/UDP public exposure.
 - `IDomain`, `IDnsEntry`, and traffic contracts for routing and DNS management.
+- Traffic and gateway route contracts including `ICoretrafficPortRouteConfig`, routing `portRoutes`, gateway route `routeRef` ownership, optional match `domains`, `transport`, and `remoteIngress` route intent.
 - `ISecretBundle` and `ISecretGroup` for secret ownership and shared secret groups.
 - Mail gateway contracts for domain authorities, address bindings, WorkApp bindings, managed SMTP/API credentials, spool items, delivery journals, and inbound/outbound message payloads.
 - Service-level mail configuration through `IService.data.mail`, including per-address inbound `smtpForward` settings and outbound credential metadata. Cloudly settings include dcrouter gateway, SMTP submission, and inbound forward-target keys for reconciling those bindings.
 - `IUser`, `IIdentity`, and token-related contracts for authentication context.
 - `ICloudlyConfig`, `ICloudlySettings`, status, server, bare-metal, BaseOS, backup, and task execution interfaces for control-plane state.
 
+Shared service port helpers are exported from `data` so Cloudly, App Store resolution, Coreflow, Coretraffic, Onebox, and dcrouter agree on the same normalization rules:
+
+```typescript
+const normalizedPorts = data.normalizeServicePortConfig(service.data);
+const defaultTarget = data.resolveDefaultServiceTargetPort(normalizedPorts.targetPorts);
+const webTarget = data.resolveServiceTargetPort(normalizedPorts.targetPorts, 'web');
+
+if (webTarget && data.isHttpServiceTargetProtocol(webTarget.protocol)) {
+  // safe to use as a domain route target
+}
+```
+
+`normalizeServicePortData()` returns service data with canonical `targetPorts`, domain `targetPort` refs, and `publicPortMappings` while removing legacy domain `port` fields from normalized writes.
+
 ## TypedRequest Contracts
 
 Use `requests` when registering handlers with `@api.global/typedrequest` or when creating typed requests through a TypedSocket client.
@@ -111,16 +150,19 @@ Request groups are exported by product area:
 - `requests.certificate`
 - `requests.cluster`
 - `requests.config`
+- `requests.corestore`
 - `requests.deployment`
 - `requests.dns`
 - `requests.domain`
 - `requests.externalRegistry`
+- `requests.gateway`
 - `requests.hostedapp`
 - `requests.identity`
 - `requests.image`
 - `requests.inform`
 - `requests.log`
 - `requests.mail`
+- `requests.migration`
 - `requests.network`
 - `requests.node`
 - `requests.platform`
@@ -181,7 +223,7 @@ Good candidates for this package:
 Poor candidates for this package:
 
 - Private implementation details of one service.
-- Runtime helpers or convenience wrappers.
+- Runtime helpers or convenience wrappers, unless they are shared contract normalization or validation helpers used by multiple packages.
 - Compatibility aliases without an active consumer.
 
 ## Development

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/interfaces',
-  version: '7.28.0',
+  version: '8.0.0',
   description: 'Shared TypeScript interfaces and TypedRequest contracts for the serve.zone ecosystem.'
 }

package/ts/appstore/types.ts

@@ -1,3 +1,9 @@
+import type {
+  IServiceDomainRoute,
+  IServicePublicPortMapping,
+  IServiceTargetPort,
+} from '../data/serviceports.js';
+
 export type TAppStorePlatformRequirement = 'mongodb' | 's3' | 'clickhouse' | 'valkey' | 'mariadb';
 export type TAppStoreSourceType = 'inline' | 'repoManifest' | 'dockerImage';
 export type TAppStoreTrackingMode = 'tag' | 'digest';
@@ -114,7 +120,12 @@ export interface IAppStoreAppMeta {
 
 export interface IAppStoreVersionConfig {
   image: string;
-  port: number;
+  /** Legacy shorthand for targetPorts.web. New templates should prefer targetPorts. */
+  port?: number;
+  targetPorts?: IServiceTargetPort[];
+  domains?: IServiceDomainRoute[];
+  /** Edge/coretraffic public TCP/UDP exposure, distinct from Docker publishedPorts. */
+  publicPortMappings?: IServicePublicPortMapping[];
   envVars?: IAppStoreEnvVar[];
   volumes?: TAppStoreVolumeSpec[];
   publishedPorts?: IAppStorePublishedPort[];
@@ -175,8 +186,10 @@ export interface IAppStoreInstallRequest {
   version?: string;
   serviceName: string;
   domain?: string;
+  /** Legacy install-time override for the web target port. */
   port?: number;
   publishedPorts?: IAppStorePublishedPort[];
+  publicPortMappings?: IServicePublicPortMapping[];
   envVars?: Record<string, string>;
 }
 

package/ts/data/gateway.ts

@@ -185,7 +185,10 @@ export interface IGatewayClientOwnership {
   gatewayClientId?: string;
   /** App identifier within the owning gateway client platform. */
   appId: string;
-  hostname: string;
+  /** Hostname ownership for domain routes. Preserved for existing route keys. */
+  hostname?: string;
+  /** Stable non-domain route key, for example public-port mapping exposure refs. */
+  routeRef?: string;
 }
 
 /**
@@ -201,7 +204,8 @@ export interface IGatewayRouteTarget {
  */
 export interface IGatewayRouteMatch {
   ports: number[];
-  domains: string[];
+  domains?: string[];
+  transport?: 'tcp' | 'udp' | 'all';
   path?: string;
 }
 
@@ -237,6 +241,10 @@ export interface IGatewayRouteConfig {
   name: string;
   match: IGatewayRouteMatch;
   action: IGatewayRouteAction;
+  remoteIngress?: {
+    enabled: boolean;
+    edgeFilter?: string[];
+  };
 }
 
 /**

package/ts/data/index.ts

@@ -21,6 +21,7 @@ export * from './backup.js';
 export * from './clusternode.js';
 export * from './settings.js';
 export * from './service.js';
+export * from './serviceports.js';
 export * from './status.js';
 export * from './taskexecution.js';
 export * from './traffic.js';

package/ts/data/service.ts

@@ -3,6 +3,11 @@ import type { IRegistryTarget } from './registry.js';
 import type { IAppStorePublishedPort } from '../appstore/index.js';
 import type { IHostedAppLifecycleState } from './hostedapp.js';
 import type { IServiceMailConfig } from './mail.js';
+import type {
+  IServiceDomainRoute,
+  IServicePublicPortMapping,
+  IServiceTargetPort,
+} from './serviceports.js';
 
 export interface IServiceVolume {
   /** Stable Docker volume name. If omitted, Coreflow derives one from service id and mount path. */
@@ -119,38 +124,30 @@ export interface IService {
     
     scaleFactor: number;
     balancingStrategy: 'round-robin' | 'least-connections';
+    /**
+     * Canonical backend/container ports for this service. New domain routes
+     * and public mappings reference these targets by name or exact port.
+     */
+    targetPorts?: IServiceTargetPort[];
     ports: {
+      /**
+       * Legacy main backend port. New writes should declare targetPorts and
+       * keep this only as compatibility shorthand during migration.
+       */
       web: number;
+      /**
+       * Legacy implicit domain-to-port routes. Runtime code must not treat
+       * this as a permissive routing source for new services.
+       */
       custom?: { [domain: string]: string };
     };
     mail?: IServiceMailConfig;
     volumes?: IServiceVolume[];
     publishedPorts?: IAppStorePublishedPort[];
+    /** Edge/coretraffic public TCP/UDP exposure, distinct from Docker Swarm publishedPorts. */
+    publicPortMappings?: IServicePublicPortMapping[];
     resources?: IServiceRessources;
-    domains: {
-      /**
-       * Optional domain ID to specify which domain to use
-       * If not specified, will use the default domain or require manual configuration
-       */
-      domainId?: string;
-      /**
-       * The subdomain name (e.g., 'api', 'www', '@' for root)
-       */
-      name: string;
-      /**
-       * The port to expose (defaults to ports.web if not specified)
-       */
-      port?: number;
-      /**
-       * The protocol for this domain entry
-       */
-      protocol?: 'http' | 'https' | 'ssh';
-      /**
-       * Gateway source profile for this domain's route (e.g. 'standard'
-       * for internal-only access). Defaults to the gateway's public profile.
-       */
-      sourceProfileRef?: string;
-    }[];
+    domains: IServiceDomainRoute[];
     deploymentIds: string[];
   };
 }

package/ts/data/serviceports.ts

@@ -0,0 +1,338 @@
+export type TServiceTargetProtocol =
+  | 'http'
+  | 'https'
+  | 'ssh'
+  | 'tcp'
+  | 'udp'
+  | `custom:${string}`;
+
+export type TServiceTargetPortRef = string | number;
+
+export interface IServiceTargetPort {
+  name: string;
+  port: number;
+  portEnd?: number;
+  protocol: TServiceTargetProtocol;
+  description?: string;
+  default?: boolean;
+}
+
+export interface IServiceDomainRoute {
+  domainId?: string;
+  name: string;
+  targetPort?: TServiceTargetPortRef;
+  /**
+   * Legacy backend target port. New writes must use targetPort.
+   */
+  port?: number;
+  protocol?: 'http' | 'https';
+  sourceProfileRef?: string;
+}
+
+export interface IServicePublicPortMapping {
+  name: string;
+  publicPort: number;
+  publicPortEnd?: number;
+  targetPort: TServiceTargetPortRef;
+  protocol: 'tcp' | 'udp';
+  sourceProfileRef?: string;
+  exclusive: true;
+}
+
+export interface IResolvedServiceDomainRoute extends IServiceDomainRoute {
+  targetPort: TServiceTargetPortRef;
+  target: IServiceTargetPort;
+}
+
+export interface IResolvedServicePublicPortMapping extends IServicePublicPortMapping {
+  target: IServiceTargetPort;
+  targetPortStart: number;
+  targetPortEnd: number;
+  publicPortEnd: number;
+}
+
+export interface IServicePortSourceData {
+  name?: string;
+  ports?: {
+    web?: number;
+    custom?: Record<string, string>;
+  };
+  targetPorts?: IServiceTargetPort[];
+  domains?: IServiceDomainRoute[];
+  publicPortMappings?: IServicePublicPortMapping[];
+}
+
+export interface INormalizedServicePortConfig {
+  targetPorts: IServiceTargetPort[];
+  defaultTargetPort?: IServiceTargetPort;
+  domains: IResolvedServiceDomainRoute[];
+  publicPortMappings: IResolvedServicePublicPortMapping[];
+}
+
+export interface IServicePortNormalizationOptions {
+  /**
+   * Accept legacy domains[].port only when it resolves to a declared target.
+   * Defaults to true for staged migration reads.
+   */
+  allowLegacyDomainPort?: boolean;
+  /**
+   * Domain routes are HTTP(S) virtual-host routes. Defaults to true.
+   */
+  requireHttpDomainTargets?: boolean;
+}
+
+export function normalizeServicePortConfig(
+  serviceDataArg: IServicePortSourceData,
+  optionsArg: IServicePortNormalizationOptions = {},
+): INormalizedServicePortConfig {
+  const options: Required<IServicePortNormalizationOptions> = {
+    allowLegacyDomainPort: optionsArg.allowLegacyDomainPort ?? true,
+    requireHttpDomainTargets: optionsArg.requireHttpDomainTargets ?? true,
+  };
+  const serviceName = serviceDataArg.name || 'service';
+  const targetPorts = normalizeServiceTargetPorts(serviceDataArg, serviceName);
+  const defaultTargetPort = resolveDefaultServiceTargetPort(targetPorts);
+  const domains = (serviceDataArg.domains || []).map((domainArg) => {
+    const target = resolveServiceDomainTarget(domainArg, targetPorts, defaultTargetPort, serviceName, options);
+    if (options.requireHttpDomainTargets && !isHttpServiceTargetProtocol(target.protocol)) {
+      throw new Error(`Domain ${domainArg.name} on ${serviceName} references non-HTTP target '${target.name}' (${target.protocol})`);
+    }
+    if (target.portEnd && target.portEnd !== target.port) {
+      throw new Error(`Domain ${domainArg.name} on ${serviceName} references ranged target '${target.name}'`);
+    }
+    const normalizedDomain: IResolvedServiceDomainRoute = {
+      ...domainArg,
+      targetPort: domainArg.targetPort ?? target.name,
+      target,
+    };
+    delete normalizedDomain.port;
+    return normalizedDomain;
+  });
+  const publicPortMappings = normalizeServicePublicPortMappings(
+    serviceDataArg.publicPortMappings || [],
+    targetPorts,
+    serviceName,
+  );
+  return {
+    targetPorts,
+    defaultTargetPort,
+    domains,
+    publicPortMappings,
+  };
+}
+
+export function normalizeServicePortData<T extends IServicePortSourceData>(
+  serviceDataArg: T,
+  optionsArg: IServicePortNormalizationOptions = {},
+): T & {
+  targetPorts: IServiceTargetPort[];
+  domains?: IServiceDomainRoute[];
+  publicPortMappings?: IServicePublicPortMapping[];
+} {
+  const normalized = normalizeServicePortConfig(serviceDataArg, optionsArg);
+  return {
+    ...serviceDataArg,
+    targetPorts: normalized.targetPorts,
+    domains: normalized.domains.map(({ target, ...domainArg }) => domainArg),
+    publicPortMappings: normalized.publicPortMappings.map(({ target, targetPortStart, targetPortEnd, ...mappingArg }) => mappingArg),
+  };
+}
+
+export function resolveServiceTargetPort(
+  targetPortsArg: IServiceTargetPort[],
+  refArg: TServiceTargetPortRef,
+): IServiceTargetPort | undefined {
+  if (typeof refArg === 'string') {
+    const normalizedRef = refArg.trim().toLowerCase();
+    return targetPortsArg.find((targetArg) => targetArg.name.trim().toLowerCase() === normalizedRef);
+  }
+  return targetPortsArg.find((targetArg) => targetArg.port === refArg && !targetArg.portEnd);
+}
+
+export function resolveDefaultServiceTargetPort(
+  targetPortsArg: IServiceTargetPort[],
+): IServiceTargetPort | undefined {
+  const explicitDefaults = targetPortsArg.filter((targetArg) => targetArg.default);
+  if (explicitDefaults.length > 1) {
+    throw new Error(`Multiple default target ports declared: ${explicitDefaults.map((targetArg) => targetArg.name).join(', ')}`);
+  }
+  return explicitDefaults[0]
+    || targetPortsArg.find((targetArg) => targetArg.name === 'web')
+    || targetPortsArg.find((targetArg) => isHttpServiceTargetProtocol(targetArg.protocol))
+    || targetPortsArg[0];
+}
+
+export function isHttpServiceTargetProtocol(protocolArg: TServiceTargetProtocol): boolean {
+  return protocolArg === 'http' || protocolArg === 'https';
+}
+
+function normalizeServiceTargetPorts(
+  serviceDataArg: IServicePortSourceData,
+  serviceNameArg: string,
+): IServiceTargetPort[] {
+  const declaredTargets = [...(serviceDataArg.targetPorts || [])];
+  const legacyWebPort = Number(serviceDataArg.ports?.web);
+  if (declaredTargets.length === 0 && Number.isInteger(legacyWebPort) && legacyWebPort > 0) {
+    declaredTargets.push({
+      name: 'web',
+      port: legacyWebPort,
+      protocol: 'http',
+      default: true,
+    });
+  }
+  if (declaredTargets.length === 0) {
+    return [];
+  }
+
+  const seenNames = new Set<string>();
+  const seenTuples = new Set<string>();
+  const normalizedTargets = declaredTargets.map((targetArg) => {
+    const name = targetArg.name?.trim();
+    if (!name || !/^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,62}$/.test(name)) {
+      throw new Error(`Invalid target port name '${targetArg.name}' on ${serviceNameArg}`);
+    }
+    const normalizedName = name.toLowerCase();
+    if (seenNames.has(normalizedName)) {
+      throw new Error(`Duplicate target port name '${name}' on ${serviceNameArg}`);
+    }
+    seenNames.add(normalizedName);
+    const port = assertValidServicePort(targetArg.port, `target port ${name} on ${serviceNameArg}`);
+    const portEnd = targetArg.portEnd === undefined
+      ? undefined
+      : assertValidServicePort(targetArg.portEnd, `target port end ${name} on ${serviceNameArg}`);
+    if (portEnd !== undefined && portEnd < port) {
+      throw new Error(`target port range '${name}' on ${serviceNameArg} must be ascending`);
+    }
+    const protocol = targetArg.protocol || 'tcp';
+    const tuple = `${protocol}:${port}:${portEnd || port}`;
+    if (seenTuples.has(tuple)) {
+      throw new Error(`Duplicate target port tuple ${tuple} on ${serviceNameArg}`);
+    }
+    seenTuples.add(tuple);
+    return {
+      ...targetArg,
+      name,
+      port,
+      portEnd,
+      protocol,
+    };
+  });
+
+  if (!normalizedTargets.some((targetArg) => targetArg.default)) {
+    const webTarget = normalizedTargets.find((targetArg) => targetArg.name === 'web');
+    if (webTarget) {
+      webTarget.default = true;
+    }
+  }
+
+  return normalizedTargets;
+}
+
+function resolveServiceDomainTarget(
+  domainArg: IServiceDomainRoute,
+  targetPortsArg: IServiceTargetPort[],
+  defaultTargetPortArg: IServiceTargetPort | undefined,
+  serviceNameArg: string,
+  optionsArg: Required<IServicePortNormalizationOptions>,
+): IServiceTargetPort {
+  const domainName = domainArg.name || '(unnamed domain)';
+  if (!targetPortsArg.length) {
+    throw new Error(`Domain ${domainName} on ${serviceNameArg} requires at least one declared target port`);
+  }
+
+  if (domainArg.targetPort !== undefined) {
+    const target = resolveServiceTargetPort(targetPortsArg, domainArg.targetPort);
+    if (!target) {
+      throw new Error(`Domain ${domainName} on ${serviceNameArg} references undeclared targetPort '${domainArg.targetPort}'`);
+    }
+    return target;
+  }
+
+  if (domainArg.port !== undefined) {
+    if (!optionsArg.allowLegacyDomainPort) {
+      throw new Error(`Domain ${domainName} on ${serviceNameArg} uses legacy port; use targetPort instead`);
+    }
+    const legacyPort = Number(domainArg.port);
+    const target = resolveServiceTargetPort(targetPortsArg, legacyPort);
+    if (!target) {
+      throw new Error(`Domain ${domainName} on ${serviceNameArg} references undeclared legacy port ${domainArg.port}`);
+    }
+    return target;
+  }
+
+  if (!defaultTargetPortArg) {
+    throw new Error(`Domain ${domainName} on ${serviceNameArg} has no targetPort and no default target port exists`);
+  }
+  return defaultTargetPortArg;
+}
+
+function normalizeServicePublicPortMappings(
+  mappingsArg: IServicePublicPortMapping[],
+  targetPortsArg: IServiceTargetPort[],
+  serviceNameArg: string,
+): IResolvedServicePublicPortMapping[] {
+  const seenNames = new Set<string>();
+  const seenPublicPorts = new Set<string>();
+  return mappingsArg.map((mappingArg) => {
+    const name = mappingArg.name?.trim();
+    if (!name || !/^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,62}$/.test(name)) {
+      throw new Error(`Invalid public port mapping name '${mappingArg.name}' on ${serviceNameArg}`);
+    }
+    const normalizedName = name.toLowerCase();
+    if (seenNames.has(normalizedName)) {
+      throw new Error(`Duplicate public port mapping '${name}' on ${serviceNameArg}`);
+    }
+    seenNames.add(normalizedName);
+    if (mappingArg.exclusive !== true) {
+      throw new Error(`Public port mapping '${name}' on ${serviceNameArg} must be exclusive`);
+    }
+    if (!['tcp', 'udp'].includes(mappingArg.protocol)) {
+      throw new Error(`Public port mapping '${name}' on ${serviceNameArg} has unsupported protocol '${mappingArg.protocol}'`);
+    }
+    const target = resolveServiceTargetPort(targetPortsArg, mappingArg.targetPort);
+    if (!target) {
+      throw new Error(`Public port mapping '${name}' on ${serviceNameArg} references undeclared targetPort '${mappingArg.targetPort}'`);
+    }
+    const publicPort = assertValidServicePort(mappingArg.publicPort, `public port ${name} on ${serviceNameArg}`);
+    const targetStart = target.port;
+    const targetEnd = target.portEnd || target.port;
+    const publicPortEnd = mappingArg.publicPortEnd === undefined
+      ? publicPort + (targetEnd - targetStart)
+      : assertValidServicePort(mappingArg.publicPortEnd, `public port end ${name} on ${serviceNameArg}`);
+    if (publicPortEnd < publicPort) {
+      throw new Error(`Public port mapping '${name}' on ${serviceNameArg} must have an ascending public range`);
+    }
+    if ((publicPortEnd - publicPort) !== (targetEnd - targetStart)) {
+      throw new Error(`Public and target port ranges must have the same length for mapping '${name}' on ${serviceNameArg}`);
+    }
+    for (let offset = 0; offset <= publicPortEnd - publicPort; offset++) {
+      const key = `${mappingArg.protocol}:${publicPort + offset}`;
+      if (seenPublicPorts.has(key)) {
+        throw new Error(`Duplicate public port ${publicPort + offset}/${mappingArg.protocol} on ${serviceNameArg}`);
+      }
+      seenPublicPorts.add(key);
+    }
+    return {
+      ...mappingArg,
+      name,
+      publicPort,
+      publicPortEnd,
+      protocol: mappingArg.protocol,
+      target,
+      targetPortStart: targetStart,
+      targetPortEnd: targetEnd,
+    };
+  }).sort((a, b) => {
+    return a.protocol.localeCompare(b.protocol)
+      || a.publicPort - b.publicPort
+      || a.name.localeCompare(b.name);
+  });
+}
+
+function assertValidServicePort(portArg: number, labelArg: string): number {
+  const port = Number(portArg);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(`Invalid ${labelArg}: ${portArg}. Expected an integer between 1 and 65535.`);
+  }
+  return port;
+}

package/ts/data/traffic.ts

@@ -2,4 +2,12 @@ import * as plugins from '../plugins.js';
 
 interface IReverseProxyConfig extends plugins.tsclass.network.IReverseProxyConfig {}
 
+export interface ICoretrafficPortRouteConfig {
+  name: string;
+  listenPort: number;
+  transport: 'tcp' | 'udp';
+  destinationIps: string[];
+  destinationPort: number;
+}
+
 export { type IReverseProxyConfig };

package/ts/requests/routing.ts

@@ -1,9 +1,10 @@
-import { type IReverseProxyConfig } from '../data/traffic.js';
+import { type ICoretrafficPortRouteConfig, type IReverseProxyConfig } from '../data/traffic.js';
 
 export interface IRequest_Coreflow_Coretraffic_RoutingUpdate {
   method: 'updateRouting';
   request: {
     reverseConfigs: IReverseProxyConfig[];
+    portRoutes?: ICoretrafficPortRouteConfig[];
   };
   response: {
     status: 'ok' | 'error';
@@ -21,6 +22,7 @@ export interface IRequest_Coretraffic_Coreflow_GetCurrentRouting {
   request: Record<string, never>;
   response: {
     reverseConfigs: IReverseProxyConfig[];
+    portRoutes?: ICoretrafficPortRouteConfig[];
   };
 }