@serve.zone/interfaces 31.9.0 → 32.0.1

package/ts/requests/backup.ts

@@ -6,11 +6,17 @@ import type {
   IBackupArchiveObject,
   IBackupRecord,
   IBackupReplicationResult,
-  IIsolatedRestoreNodeState,
   IIsolatedRestoreRecord,
   TBackupSnapshot,
-  TIsolatedRestoreResourceMapping,
 } from '../data/backup.js';
+import type {
+  IIsolatedRestoreControlCleanupRequest,
+  IIsolatedRestoreControlExecuteRequest,
+  IIsolatedRestoreControlPrepareRequest,
+  IIsolatedRestoreControlStatusRequest,
+  IIsolatedRestoreControlWriteRequest,
+  IIsolatedRestoreProgress,
+} from '../data/isolatedrestore.js';
 import type { IService } from '../data/service.js';
 import type { IIdentity, IIdentityCredential } from '../data/user.js';
 import type { ICorestoreDatabaseClosureDescriptor } from '../runtime.corestore.relay.js';
@@ -400,7 +406,14 @@ extends plugins.typedrequestInterfaces.implementsTR<
     /** Cloudly verifies this credential and derives all actor claims server-side. */
     identity: IIdentityCredential;
     sourceBackupId: string;
-    targetNodeName: string;
+    /**
+     * The cluster node this restore is dispatched to, as the cluster document names it.
+     *
+     * Cloudly signs the restore grant for the `targetNodeName` that node carries, and every
+     * control call is routed by this id: the name is what the operator's grant authorizes, the id
+     * is what the relay routes on, and Cloudly is the one party that holds both.
+     */
+    targetNodeId: string;
     purpose: string;
     /** Caller-generated key; retries return the original restore. */
     idempotencyKey: string;
@@ -414,6 +427,8 @@ extends plugins.typedrequestInterfaces.implementsTR<
     id?: never;
     /** Alias-like caller input is forbidden as well. */
     restoreId?: never;
+    /** Derived from the node the restore is dispatched to; the grant carries it. */
+    targetNodeName?: never;
     /** Legacy runnable-service targeting is forbidden. */
     targetServiceId?: never;
     /** Generated by Cloudly. Explicitly forbidden as caller input. */
@@ -440,6 +455,9 @@ extends plugins.typedrequestInterfaces.implementsTR<
     sourceBackupId?: string;
     sourceServiceId?: string;
     clusterId?: string;
+    /** The node the restore is dispatched to. */
+    targetNodeId?: string;
+    /** The node name the restore grant authorizes. */
     targetNodeName?: string;
     scratchNamespaceId?: string;
     status?: IIsolatedRestoreRecord['status'];
@@ -473,54 +491,67 @@ extends plugins.typedrequestInterfaces.implementsTR<
 }
 
 /**
- * Prepares and stages one isolated restore on an exact cluster node. A missing
- * node state has revision 0; successful mutation returns the next revision.
+ * Carrying one isolated-restore control to one exact node of this cluster.
+ *
+ * Five contracts share one shape: `nodeId` names the node of this cluster, `control` is the body
+ * Corestore reads, and the answer is what that node states about the restore. The relay is a
+ * carrier: it forwards the control untouched, adds nothing to it and reads nothing out of it. The
+ * signed `restoreGrant` inside is the only authority Corestore accepts on these routes — it names
+ * the operation, expires within minutes, and binds the cluster, the node name, the canonical
+ * resource mappings and the archive manifest — so a relay can carry it but can neither widen it
+ * nor mint one.
+ *
+ * The node is a request field because one relay serves every node of its cluster over one
+ * session: the connection that answers proves which cluster is speaking, never which node is
+ * meant. No identity field: the cluster is the one the verified machine identity on the session
+ * `registerCloudlyClientSession` opened names, exactly as `getClusterRouteTable` and
+ * `getClusterPlatformDesiredState` work, and a request-level identity would be a second authority
+ * for the same fact, and the weaker of the two. No protocol offer either: that handshake exchanged
+ * one, and the relay stated its own again in `registerClusterRelay`'s `protocol` member, so
+ * neither fact belongs on a request.
+ *
+ * Sensitive ephemeral input on all five: the control carries a bearer grant, so exclude the
+ * complete request from hooks, logs, diagnostics and durable journals on every hop.
+ *
+ * A relay that cannot reach the node answers one of `data.isolatedRestoreNodeControlRefusals`
+ * instead of a progress; everything Corestore itself refused arrives under
+ * `restore-node-refused` with Corestore's own reason.
  */
-export interface IReq_Cloudly_Coreflow_PrepareIsolatedRestore
+export interface IReq_Cloudly_Relay_PrepareIsolatedRestoreOnNode
 extends plugins.typedrequestInterfaces.implementsTR<
   plugins.typedrequestInterfaces.ITypedRequest,
-  IReq_Cloudly_Coreflow_PrepareIsolatedRestore
+  IReq_Cloudly_Relay_PrepareIsolatedRestoreOnNode
 > {
-  method: 'coreflowPrepareIsolatedRestore';
+  method: 'prepareIsolatedRestoreOnNode';
   request: {
-    /**
-     * The compact RS256 restore grant Cloudly signed for exactly this
-     * operation, carried untouched to Corestore.
-     *
-     * Corestore accepts no other authority on an isolated-restore route: the
-     * grant names the operation, expires within minutes, and binds the cluster,
-     * the node, the canonical resource mappings and the archive manifest, so a
-     * relay can carry it but can neither widen it nor mint one. Sensitive
-     * ephemeral input: exclude the complete request from hooks, logs and
-     * journals on every hop.
-     */
-    restoreGrant: string;
-    clusterId: string;
-    targetNodeName: string;
-    restoreId: string;
-    expectedRevision: number;
-    sourceBackupId: string;
-    sourceServiceId: string;
-    scratchNamespaceId: string;
-    stagingArchiveId: string;
-    resourceMappings: TIsolatedRestoreResourceMapping[];
-    archiveManifest: IBackupArchiveManifest;
+    /** The cluster node whose Corestore stages this restore. */
+    nodeId: string;
+    /** `expectedRevision` is 0 for a restore this node does not hold yet; a replay returns its state. */
+    control: IIsolatedRestoreControlPrepareRequest;
   };
   response: {
-    state: IIsolatedRestoreNodeState;
+    progress: IIsolatedRestoreProgress;
   };
 }
 
 /**
- * Cloudly stages one archive object of an isolated restore on the relay's node.
+ * Cloudly stages one bounded chunk of one archive object on the relay's node.
  *
- * Cloudly holds the source backup, so these bytes travel Cloudly → relay and
- * the requester is the sender. One object per call, as the archive manifest
- * lists it: Corestore writes staged objects under a `write-object` grant, one
- * bounded chunk at a time, and the relay is what turns this stream into those
- * chunks. The object descriptor is the manifest entry itself — path, exact size
- * and digest — so the relay can prove the complete object before it counts as
- * written, and so a replayed stage settles on the same bytes.
+ * Cloudly holds the source backup, so these bytes travel Cloudly → relay → Corestore, one chunk
+ * per call as `data.isolatedRestoreContractLimits` bounds them: at most 512 KiB decoded per chunk,
+ * 4,096 chunks per object and 64 MiB per object. The chunk states the complete object — `path`,
+ * `size`, `sha256` — and authenticates its own bytes with `chunkSha256`, so a replayed chunk
+ * settles on the same bytes and a completed object is proved rather than assumed. The answer's
+ * `stagedObject` says where the next chunk continues, which is what lets an interrupted staging
+ * run resume at the byte the node already holds.
+ *
+ * That answer is a projection of Corestore's own: `path`, `nextOffset` and `completed` are top
+ * level on Corestore's write answer and become `stagedObject` here, Corestore's own `object`
+ * member is the received-object receipt it stored and is not carried, and the extra members the
+ * mutating routes add (`written`, `restored`, `ok`, `stagingArchiveDeleted`, `alreadyAbsent`) are
+ * dropped, so all five contracts answer the one shape a node can state.
+ *
+ * Sensitive ephemeral input; see `prepareIsolatedRestoreOnNode`.
  */
 export interface IReq_Cloudly_Relay_StageIsolatedRestoreArchive
 extends plugins.typedrequestInterfaces.implementsTR<
@@ -529,115 +560,79 @@ extends plugins.typedrequestInterfaces.implementsTR<
 > {
   method: 'stageIsolatedRestoreArchive';
   request: {
-    /**
-     * The compact RS256 restore grant for the `write-object` operation, carried
-     * untouched to Corestore. Sensitive ephemeral input, like every other
-     * grant on these routes.
-     */
-    restoreGrant: string;
-    clusterId: string;
-    targetNodeName: string;
-    restoreId: string;
-    expectedRevision: number;
-    /** The manifest entry these bytes complete: `path`, `size`, `sha256`. */
-    object: IBackupArchiveObject;
-    /** Requester sends the object bytes; the TypedHandler receives them. */
-    archive: plugins.typedrequestInterfaces.TVirtualStream<'send'>;
+    /** The cluster node whose Corestore holds the staging tree. */
+    nodeId: string;
+    control: IIsolatedRestoreControlWriteRequest;
   };
   response: {
-    state: IIsolatedRestoreNodeState;
+    progress: IIsolatedRestoreProgress;
   };
 }
 
-/** Read-only status for one exact cluster/node/restore routing key. */
-export interface IReq_Cloudly_Coreflow_GetIsolatedRestoreStatus
+/** Reads what one node holds for a restore, without changing it; see `prepareIsolatedRestoreOnNode`. */
+export interface IReq_Cloudly_Relay_GetIsolatedRestoreProgressOnNode
 extends plugins.typedrequestInterfaces.implementsTR<
   plugins.typedrequestInterfaces.ITypedRequest,
-  IReq_Cloudly_Coreflow_GetIsolatedRestoreStatus
+  IReq_Cloudly_Relay_GetIsolatedRestoreProgressOnNode
 > {
-  method: 'coreflowGetIsolatedRestoreStatus';
+  method: 'getIsolatedRestoreProgressOnNode';
   request: {
-    /**
-     * The compact RS256 restore grant Cloudly signed for exactly this
-     * operation, carried untouched to Corestore.
-     *
-     * Corestore accepts no other authority on an isolated-restore route: the
-     * grant names the operation, expires within minutes, and binds the cluster,
-     * the node, the canonical resource mappings and the archive manifest, so a
-     * relay can carry it but can neither widen it nor mint one. Sensitive
-     * ephemeral input: exclude the complete request from hooks, logs and
-     * journals on every hop.
-     */
-    restoreGrant: string;
-    clusterId: string;
-    targetNodeName: string;
-    restoreId: string;
+    /** The cluster node whose Corestore is read. */
+    nodeId: string;
+    control: IIsolatedRestoreControlStatusRequest;
   };
   response: {
-    found: boolean;
-    state?: IIsolatedRestoreNodeState;
+    progress: IIsolatedRestoreProgress;
   };
 }
 
-export interface IReq_Cloudly_Coreflow_ExecuteIsolatedRestore
+/**
+ * Restores every staged mapping into the scratch namespace on that node.
+ *
+ * `executed` requires every mapping of the plan to be completed, and a run that stopped answers
+ * `failed` with its staging tree intact, so the caller can read the progress and clean up rather
+ * than guess what is on the node.
+ *
+ * Sensitive ephemeral input; see `prepareIsolatedRestoreOnNode`.
+ */
+export interface IReq_Cloudly_Relay_ExecuteIsolatedRestoreOnNode
 extends plugins.typedrequestInterfaces.implementsTR<
   plugins.typedrequestInterfaces.ITypedRequest,
-  IReq_Cloudly_Coreflow_ExecuteIsolatedRestore
+  IReq_Cloudly_Relay_ExecuteIsolatedRestoreOnNode
 > {
-  method: 'coreflowExecuteIsolatedRestore';
+  method: 'executeIsolatedRestoreOnNode';
   request: {
-    /**
-     * The compact RS256 restore grant Cloudly signed for exactly this
-     * operation, carried untouched to Corestore.
-     *
-     * Corestore accepts no other authority on an isolated-restore route: the
-     * grant names the operation, expires within minutes, and binds the cluster,
-     * the node, the canonical resource mappings and the archive manifest, so a
-     * relay can carry it but can neither widen it nor mint one. Sensitive
-     * ephemeral input: exclude the complete request from hooks, logs and
-     * journals on every hop.
-     */
-    restoreGrant: string;
-    clusterId: string;
-    targetNodeName: string;
-    restoreId: string;
-    expectedRevision: number;
+    /** The cluster node that runs the restore. */
+    nodeId: string;
+    control: IIsolatedRestoreControlExecuteRequest;
   };
   response: {
-    state: IIsolatedRestoreNodeState;
+    progress: IIsolatedRestoreProgress;
   };
 }
 
 /**
- * Idempotent cleanup mutation. A cleanup-failed state remains retryable and
- * does not authorize release of the source-backup hold.
+ * Idempotent cleanup of everything this restore left on that node.
+ *
+ * A node that already cleaned up answers `cleaned` again rather than refusing, and a cleanup that
+ * failed stays retryable: the source-backup hold is released by the control plane only once a node
+ * states `cleaned`.
+ *
+ * Sensitive ephemeral input; see `prepareIsolatedRestoreOnNode`.
  */
-export interface IReq_Cloudly_Coreflow_CleanupIsolatedRestore
+export interface IReq_Cloudly_Relay_CleanupIsolatedRestoreOnNode
 extends plugins.typedrequestInterfaces.implementsTR<
   plugins.typedrequestInterfaces.ITypedRequest,
-  IReq_Cloudly_Coreflow_CleanupIsolatedRestore
+  IReq_Cloudly_Relay_CleanupIsolatedRestoreOnNode
 > {
-  method: 'coreflowCleanupIsolatedRestore';
+  method: 'cleanupIsolatedRestoreOnNode';
   request: {
-    /**
-     * The compact RS256 restore grant Cloudly signed for exactly this
-     * operation, carried untouched to Corestore.
-     *
-     * Corestore accepts no other authority on an isolated-restore route: the
-     * grant names the operation, expires within minutes, and binds the cluster,
-     * the node, the canonical resource mappings and the archive manifest, so a
-     * relay can carry it but can neither widen it nor mint one. Sensitive
-     * ephemeral input: exclude the complete request from hooks, logs and
-     * journals on every hop.
-     */
-    restoreGrant: string;
-    clusterId: string;
-    targetNodeName: string;
-    restoreId: string;
-    expectedRevision: number;
+    /** The cluster node whose staging tree and scratch resources are removed. */
+    nodeId: string;
+    control: IIsolatedRestoreControlCleanupRequest;
   };
   response: {
-    state: IIsolatedRestoreNodeState;
+    progress: IIsolatedRestoreProgress;
   };
 }
 

package/ts/requests/cluster.ts

@@ -77,17 +77,17 @@ export interface IReq_Any_Cloudly_UpdateCluster extends plugins.typedrequestInte
  * The response carries the block Cloudly published, which is the same block every cluster-side
  * component then reads from `ICluster.data.relay`.
  */
-export interface IReq_Any_Cloudly_EnableClusterRelayV1 extends plugins.typedrequestInterfaces.implementsTR<
+export interface IReq_Any_Cloudly_EnableClusterRelay extends plugins.typedrequestInterfaces.implementsTR<
   plugins.typedrequestInterfaces.ITypedRequest,
-  IReq_Any_Cloudly_EnableClusterRelayV1
+  IReq_Any_Cloudly_EnableClusterRelay
 > {
-  method: 'enableClusterRelayV1';
+  method: 'enableClusterRelay';
   request: {
     identity: userInterfaces.IIdentity;
     clusterId: string;
   };
   response: {
-    relay: clusterInterfaces.IClusterRelayV1;
+    relay: clusterInterfaces.IClusterRelay;
   };
 }
 
@@ -98,11 +98,11 @@ export interface IReq_Any_Cloudly_EnableClusterRelayV1 extends plugins.typedrequ
  * the response rather than absent: the caller learns that the block is gone, not that the
  * response forgot it.
  */
-export interface IReq_Any_Cloudly_DisableClusterRelayV1 extends plugins.typedrequestInterfaces.implementsTR<
+export interface IReq_Any_Cloudly_DisableClusterRelay extends plugins.typedrequestInterfaces.implementsTR<
   plugins.typedrequestInterfaces.ITypedRequest,
-  IReq_Any_Cloudly_DisableClusterRelayV1
+  IReq_Any_Cloudly_DisableClusterRelay
 > {
-  method: 'disableClusterRelayV1';
+  method: 'disableClusterRelay';
   request: {
     identity: userInterfaces.IIdentity;
     clusterId: string;
@@ -136,17 +136,17 @@ export interface IReq_Any_Cloudly_GetClusterRelayRegistrations extends plugins.t
 /**
  * The cluster relay tells Cloudly where it listens, over its own authenticated socket.
  *
- * Sent after `registerCloudlyClientSessionV1`, so the cluster is the one the verified machine
+ * Sent after `registerCloudlyClientSession`, so the cluster is the one the verified machine
  * identity on that socket names and is never a request field. `Relay` names the role, not a
  * component: whichever process fills it for a cluster sends this.
  */
-export interface IReq_Relay_Cloudly_RegisterClusterRelayV1 extends plugins.typedrequestInterfaces.implementsTR<
+export interface IReq_Relay_Cloudly_RegisterClusterRelay extends plugins.typedrequestInterfaces.implementsTR<
   plugins.typedrequestInterfaces.ITypedRequest,
-  IReq_Relay_Cloudly_RegisterClusterRelayV1
+  IReq_Relay_Cloudly_RegisterClusterRelay
 > {
-  method: 'registerClusterRelayV1';
-  request: clusterInterfaces.IClusterRelayRegistrationV1;
-  response: clusterInterfaces.IClusterRelayRegistrationResponseV1;
+  method: 'registerClusterRelay';
+  request: clusterInterfaces.IRegisterClusterRelayRequest;
+  response: clusterInterfaces.IRegisterClusterRelayResponse;
 }
 
 /**

package/ts/requests/clusteringress.ts

@@ -1,4 +1,5 @@
 import * as clusterIngressInterfaces from '../data/clusteringress.js';
+import type { IProtocolOffer } from '../protocol.js';
 import * as plugins from '../plugins.js';
 
 /**
@@ -65,6 +66,10 @@ export interface IReq_Relay_Cloudly_GetClusterRouteTable extends plugins.typedre
  * `revision` is the table the relay holds, so an accepted ingress knows at once
  * whether it has to fetch one. Cloudly answers `null`: the table is the relay's
  * to state, not Cloudly's to echo.
+ *
+ * Both hops judge the body in the one server order `protocol.readProtocolOffer`
+ * states, negotiating before the bearer is verified, as the shape states at
+ * `validateClusterIngressRegistration`.
  */
 export interface IReq_Ingress_Relay_Cloudly_RegisterClusterIngress extends plugins.typedrequestInterfaces.implementsTR<
   plugins.typedrequestInterfaces.ITypedRequest,
@@ -84,10 +89,14 @@ export interface IReq_Ingress_Relay_Cloudly_RegisterClusterIngress extends plugi
     nodeId: string;
     /** Optional capability names; an ingress that states none states nothing. */
     capabilities?: string[];
+    /** Read and negotiated by the relay and by Cloudly before the bearer is verified. */
+    protocol: IProtocolOffer;
   };
   response: {
     accepted: true;
     revision: number | null;
+    /** The offer of the side that accepted, so an ingress judges the session it opened. */
+    protocol: IProtocolOffer;
   };
 }
 

package/ts/requests/config.ts

@@ -3,7 +3,7 @@ import * as clusterInterfaces from '../data/cluster.js';
 import * as userInterfaces from '../data/user.js';
 import type { IService } from '../data/service.js';
 import type { IPlatformBinding, IPlatformProviderConfig } from '../platform/types.js';
-import type { ICorestoreCredentialPublicationGrantV1 } from '../runtime.corestore.js';
+import type { ICorestoreCredentialPublicationGrant } from '../runtime.corestore.js';
 
 export interface IRequest_Any_Cloudly_GetClusterConfig
 extends plugins.typedrequestInterfaces.implementsTR<
@@ -19,7 +19,7 @@ extends plugins.typedrequestInterfaces.implementsTR<
     services: IService[];
     platformProviderConfigs?: IPlatformProviderConfig[];
     platformBindings?: IPlatformBinding[];
-    corestoreCredentialPublicationGrants?: ICorestoreCredentialPublicationGrantV1[];
+    corestoreCredentialPublicationGrants?: ICorestoreCredentialPublicationGrant[];
   };
 }
 
@@ -34,7 +34,7 @@ extends plugins.typedrequestInterfaces.implementsTR<
     services: IService[];
     platformProviderConfigs?: IPlatformProviderConfig[];
     platformBindings?: IPlatformBinding[];
-    corestoreCredentialPublicationGrants?: ICorestoreCredentialPublicationGrantV1[];
+    corestoreCredentialPublicationGrants?: ICorestoreCredentialPublicationGrant[];
   };
   response: {};
 }

package/ts/requests/corestore.ts

@@ -1,5 +1,6 @@
 import * as plugins from '../plugins.js';
 import type { IIdentity } from '../data/user.js';
+import { hasExactKeys } from '../private/dataproperties.js';
 
 /**
  * A provisioned corestore resource (NoSQLDB database or ObjectStorage bucket)
@@ -30,7 +31,6 @@ export interface ICorestoreServiceResources {
 export interface ICorestoreNodeInventory {
   /** Swarm node hostnames of the reporting coreflow. */
   nodeNames: string[];
-  protocolVersion: 1;
   checkedAt: number;
   reachable: boolean;
   errorCode?: 'NODE_DISCOVERY_FAILED' | 'CORESTORE_UNREACHABLE';
@@ -66,7 +66,6 @@ export interface ICorestoreInventoryProbe {
   status: TCorestoreInventoryProbeStatus;
   connectionId?: string;
   reporterSessionId?: string;
-  capabilityVersion?: number;
   observedNodeNames: string[];
   checkedAt: number;
   lastSuccessfulInventoryAt?: number;
@@ -82,7 +81,6 @@ export interface ICorestoreInventoryReport {
 
 /** Final registration tag restored only after identity and capability tags. */
 export interface ICoreflowInventoryRegistration {
-  registrationVersion: 1;
   reporterSessionId: string;
   registeredAt: number;
 }
@@ -118,22 +116,12 @@ const isClusterCorestoreRecord = (
     || Object.getPrototypeOf(valueArg) === null)
 );
 
-const hasClusterCorestoreKeys = (
-  valueArg: Record<string, unknown>,
-  keysArg: readonly string[],
-  optionalKeysArg: readonly string[] = [],
-): boolean => {
-  const actualKeys = Object.keys(valueArg);
-  return keysArg.every((keyArg) => actualKeys.includes(keyArg))
-    && actualKeys.every((keyArg) => keysArg.includes(keyArg) || optionalKeysArg.includes(keyArg));
-};
-
 const validateClusterCorestoreServiceResources = (
   valueArg: unknown,
   pathArg: string,
 ): string[] => {
   if (!isClusterCorestoreRecord(valueArg)
-    || !hasClusterCorestoreKeys(
+    || !hasExactKeys(
       valueArg,
       ['serviceId', 'resources', 'updatedAt'],
       ['serviceName'],
@@ -155,7 +143,7 @@ const validateClusterCorestoreServiceResources = (
   for (const [index, resource] of valueArg.resources.entries()) {
     const resourcePath = `${pathArg} resources[${index}]`;
     if (!isClusterCorestoreRecord(resource)
-      || !hasClusterCorestoreKeys(
+      || !hasExactKeys(
         resource,
         ['capability', 'provider', 'resourceName', 'createdAt'],
       )) {
@@ -193,7 +181,7 @@ export const validateClusterCorestoreInventory = (
   pathArg = 'cluster corestore inventory',
 ): string[] => {
   if (!isClusterCorestoreRecord(valueArg)
-    || !hasClusterCorestoreKeys(
+    || !hasExactKeys(
       valueArg,
       ['nodeId', 'checkedAt', 'reachable', 'services'],
       ['errorCode'],

package/ts/requests/network.ts

@@ -3,94 +3,94 @@ import type { IIdentity, IIdentityCredential } from '../data/user.js';
 import type { IRuntimeNetworkAddressPlan, TRuntimeNetworkAddressPlanWritableData } from '../data/networkaddressplan.js';
 import type { IRuntimeNetworkNodeReadiness, IRuntimeRouterIncarnation } from '../data/networknode.js';
 import type {
-  IPrivateNetworkV1, IServicePrivateNetworksV1, ISetServicePrivateNetworksV1,
-  TPrivateNetworkMutationV1,
+  IPrivateNetwork, IServicePrivateNetworks, ISetServicePrivateNetworks,
+  TPrivateNetworkMutation,
 } from '../data/privatenetwork.js';
-import type { IServicePublishedPortsV1, ISetServicePublishedPortsV1 } from '../data/networkprojection.js';
+import type { IServicePublishedPorts, ISetServicePublishedPorts } from '../data/networkprojection.js';
 
 /** Current organization picker data. Entries are never cached authorization grants. */
-export interface IReq_Cloudly_ListOwnedOrganizationsV1 extends plugins.typedrequestInterfaces.implementsTR<
-  plugins.typedrequestInterfaces.ITypedRequest, IReq_Cloudly_ListOwnedOrganizationsV1
+export interface IReq_Cloudly_ListOwnedOrganizations extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest, IReq_Cloudly_ListOwnedOrganizations
 > {
-  method: 'listOwnedOrganizationsV1';
+  method: 'listOwnedOrganizations';
   request: { identity: IIdentityCredential };
   /** Limited to the server-held OIDC token's grant and current canonical owner membership. */
   response: { organizations: Array<{ id: string; name: string; slug: string }> };
 }
 
 /** Organization-scoped attachment choices; excludes service configuration and secrets. */
-export interface IReq_Cloudly_ListPrivateNetworkServiceCandidatesV1 extends plugins.typedrequestInterfaces.implementsTR<
-  plugins.typedrequestInterfaces.ITypedRequest, IReq_Cloudly_ListPrivateNetworkServiceCandidatesV1
+export interface IReq_Cloudly_ListPrivateNetworkServiceCandidates extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest, IReq_Cloudly_ListPrivateNetworkServiceCandidates
 > {
-  method: 'listPrivateNetworkServiceCandidatesV1';
+  method: 'listPrivateNetworkServiceCandidates';
   /** Each page requires a fresh canonical organization-owner authority observation. */
   request: { identity: IIdentityCredential; organizationId: string; cursor: string | null; limit: number };
   response: { services: Array<{ id: string; name: string }>; nextCursor: string | null };
 }
 
 /** Every request is authorized against live canonical membership and Cloudly policy. */
-export interface IReq_Cloudly_ListPrivateNetworksV1 extends plugins.typedrequestInterfaces.implementsTR<
-  plugins.typedrequestInterfaces.ITypedRequest, IReq_Cloudly_ListPrivateNetworksV1
+export interface IReq_Cloudly_ListPrivateNetworks extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest, IReq_Cloudly_ListPrivateNetworks
 > {
-  method: 'listPrivateNetworksV1';
+  method: 'listPrivateNetworks';
   request: { identity: IIdentityCredential; organizationId: string; cursor: string | null; limit: number };
-  response: { networks: IPrivateNetworkV1[]; nextCursor: string | null };
+  response: { networks: IPrivateNetwork[]; nextCursor: string | null };
 }
 
-export interface IReq_Cloudly_GetPrivateNetworkV1 extends plugins.typedrequestInterfaces.implementsTR<
-  plugins.typedrequestInterfaces.ITypedRequest, IReq_Cloudly_GetPrivateNetworkV1
+export interface IReq_Cloudly_GetPrivateNetwork extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest, IReq_Cloudly_GetPrivateNetwork
 > {
-  method: 'getPrivateNetworkV1';
+  method: 'getPrivateNetwork';
   request: { identity: IIdentityCredential; organizationId: string; networkId: string };
-  response: { network: IPrivateNetworkV1 | null };
+  response: { network: IPrivateNetwork | null };
 }
 
-export interface IReq_Cloudly_MutatePrivateNetworkV1 extends plugins.typedrequestInterfaces.implementsTR<
-  plugins.typedrequestInterfaces.ITypedRequest, IReq_Cloudly_MutatePrivateNetworkV1
+export interface IReq_Cloudly_MutatePrivateNetwork extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest, IReq_Cloudly_MutatePrivateNetwork
 > {
-  method: 'mutatePrivateNetworkV1';
-  request: { identity: IIdentityCredential; mutation: TPrivateNetworkMutationV1 };
+  method: 'mutatePrivateNetwork';
+  request: { identity: IIdentityCredential; mutation: TPrivateNetworkMutation };
   /** Historical on replay; neither acceptance nor replay proves applied packet/DNS state. */
-  response: { network: IPrivateNetworkV1; replayed: boolean };
+  response: { network: IPrivateNetwork; replayed: boolean };
 }
 
-export interface IReq_Cloudly_GetServicePrivateNetworksV1 extends plugins.typedrequestInterfaces.implementsTR<
-  plugins.typedrequestInterfaces.ITypedRequest, IReq_Cloudly_GetServicePrivateNetworksV1
+export interface IReq_Cloudly_GetServicePrivateNetworks extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest, IReq_Cloudly_GetServicePrivateNetworks
 > {
-  method: 'getServicePrivateNetworksV1';
+  method: 'getServicePrivateNetworks';
   request: { identity: IIdentityCredential; organizationId: string; serviceId: string };
-  response: { membership: IServicePrivateNetworksV1 | null };
+  response: { membership: IServicePrivateNetworks | null };
 }
 
-export interface IReq_Cloudly_SetServicePrivateNetworksV1 extends plugins.typedrequestInterfaces.implementsTR<
-  plugins.typedrequestInterfaces.ITypedRequest, IReq_Cloudly_SetServicePrivateNetworksV1
+export interface IReq_Cloudly_SetServicePrivateNetworks extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest, IReq_Cloudly_SetServicePrivateNetworks
 > {
-  method: 'setServicePrivateNetworksV1';
-  request: { identity: IIdentityCredential; mutation: ISetServicePrivateNetworksV1 };
+  method: 'setServicePrivateNetworks';
+  request: { identity: IIdentityCredential; mutation: ISetServicePrivateNetworks };
   /** Exact desired membership; enforcement and outstanding revocations remain separately observed. */
-  response: { membership: IServicePrivateNetworksV1; replayed: boolean };
+  response: { membership: IServicePrivateNetworks; replayed: boolean };
 }
 
 /** null means the service has never had an authorized published-port policy. */
-export interface IReq_Cloudly_GetServicePublishedPortsV1 extends plugins.typedrequestInterfaces.implementsTR<
-  plugins.typedrequestInterfaces.ITypedRequest, IReq_Cloudly_GetServicePublishedPortsV1
+export interface IReq_Cloudly_GetServicePublishedPorts extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest, IReq_Cloudly_GetServicePublishedPorts
 > {
-  method: 'getServicePublishedPortsV1';
+  method: 'getServicePublishedPorts';
   request: { identity: IIdentityCredential; organizationId: string; serviceId: string };
-  response: { publishedPorts: IServicePublishedPortsV1 | null };
+  response: { publishedPorts: IServicePublishedPorts | null };
 }
 
-export interface IReq_Cloudly_SetServicePublishedPortsV1 extends plugins.typedrequestInterfaces.implementsTR<
-  plugins.typedrequestInterfaces.ITypedRequest, IReq_Cloudly_SetServicePublishedPortsV1
+export interface IReq_Cloudly_SetServicePublishedPorts extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest, IReq_Cloudly_SetServicePublishedPorts
 > {
-  method: 'setServicePublishedPortsV1';
-  request: { identity: IIdentityCredential; mutation: ISetServicePublishedPortsV1 };
+  method: 'setServicePublishedPorts';
+  request: { identity: IIdentityCredential; mutation: ISetServicePublishedPorts };
   /**
    * The accepted document including its `revision`; historical on replay. Cloudly
    * derives each projection entry's `authorization` reference from that revision,
    * and acceptance is neither node placement nor applied packet state.
    */
-  response: { publishedPorts: IServicePublishedPortsV1; replayed: boolean };
+  response: { publishedPorts: IServicePublishedPorts; replayed: boolean };
 }
 
 export interface IRequest_Any_Cloudly_GetNetworkNodes {